src/dupe.cc

   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 <cinttypes>
  23
  24 #include "main.h"
  25 #include "dupe.h"
  26
  27 #include "cache.h"
  28 #include "collect-table.h"
  29 #include "dnd.h"
  30 #include "filedata.h"
  31 #include "history-list.h"
  32 #include "image-load.h"
  33 #include "img-view.h"
  34 #include "layout-image.h"
  35 #include "layout-util.h"
  36 #include "md5-util.h"
  37 #include "menu.h"
  38 #include "misc.h"
  39 #include "pixbuf-util.h"
  40 #include "print.h"
  41 #include "thumb.h"
  42 #include "ui-fileops.h"
  43 #include "ui-menu.h"
  44 #include "ui-misc.h"
  45 #include "ui-tree-edit.h"
  46 #include "uri-utils.h"
  47 #include "utilops.h"
  48 #include "window.h"
  49
  50 #include <cmath>
  51
  52
  53 #define DUPE_DEF_WIDTH 800
  54 #define DUPE_DEF_HEIGHT 400
  55 #define DUPE_PROGRESS_PULSE_STEP 0.0001
  56
  57 /** column assignment order (simply change them here)
  58  */
  59 enum {
  60         DUPE_COLUMN_POINTER = 0,
  61         DUPE_COLUMN_RANK,
  62         DUPE_COLUMN_THUMB,
  63         DUPE_COLUMN_NAME,
  64         DUPE_COLUMN_SIZE,
  65         DUPE_COLUMN_DATE,
  66         DUPE_COLUMN_DIMENSIONS,
  67         DUPE_COLUMN_PATH,
  68         DUPE_COLUMN_COLOR,
  69         DUPE_COLUMN_SET,
  70         DUPE_COLUMN_COUNT       /**< total columns */
  71 };
  72
  73 enum DUPE_CHECK_RESULT {
  74         DUPE_MATCH = 0,
  75         DUPE_NO_MATCH,
  76         DUPE_NAME_MATCH
  77 };
  78
  79 /** Used for similarity checks. One for each item pushed
  80  * onto the thread pool.
  81  */
  82 struct DupeQueueItem
  83 {
  84         DupeItem *needle;
  85         DupeWindow *dw;
  86         GList *work; /**< pointer into \a dw->list or \a dw->second_list (#DupeItem) */
  87         gint index; /**< The order items pushed onto thread pool. Used to sort returned matches */
  88 };
  89
  90 /** Used for similarity checks thread. One for each pair match found.
  91  */
  92 struct DupeSearchMatch
  93 {
  94         DupeItem *a; /**< \a a / \a b matched pair found */
  95         DupeItem *b; /**< \a a / \a b matched pair found */
  96         gdouble rank;
  97         gint index; /**< The order items pushed onto thread pool. Used to sort returned matches */
  98 };
  99
 100 static DupeMatchType param_match_mask;
 101 static GList *dupe_window_list = nullptr;       /**< list of open DupeWindow *s */
 102
 103 /*
 104  * Well, after adding the 'compare two sets' option things got a little sloppy in here
 105  * because we have to account for two 'modes' everywhere. (be careful).
 106  */
 107
 108 static void dupe_match_unlink(DupeItem *a, DupeItem *b);
 109 static DupeItem *dupe_match_find_parent(DupeWindow *dw, DupeItem *child);
 110
 111 static gint dupe_match(DupeItem *a, DupeItem *b, DupeMatchType mask, gdouble *rank, gint fast);
 112
 113 static void dupe_thumb_step(DupeWindow *dw);
 114 static gint dupe_check_cb(gpointer data);
 115
 116 static void dupe_second_add(DupeWindow *dw, DupeItem *di);
 117 static void dupe_second_remove(DupeWindow *dw, DupeItem *di);
 118 static GtkWidget *dupe_menu_popup_second(DupeWindow *dw, DupeItem *di);
 119
 120 static void dupe_dnd_init(DupeWindow *dw);
 121
 122 static void dupe_notify_cb(FileData *fd, NotifyType type, gpointer data);
 123 static void delete_finished_cb(gboolean success, const gchar *dest_path, gpointer data);
 124
 125 static GtkWidget *submenu_add_export(GtkWidget *menu, GtkWidget **menu_item, GCallback func, gpointer data);
 126 static void dupe_pop_menu_export_cb(GtkWidget *widget, gpointer data);
 127
 128 static void dupe_init_list_cache(DupeWindow *dw);
 129 static void dupe_destroy_list_cache(DupeWindow *dw);
 130 static gboolean dupe_insert_in_list_cache(DupeWindow *dw, FileData *fd);
 131
 132 static void dupe_match_link(DupeItem *a, DupeItem *b, gdouble rank);
 133 static gint dupe_match_link_exists(DupeItem *child, DupeItem *parent);
 134
 135 /**
 136  * This array must be kept in sync with the contents of:\n
 137  *  @link dupe_window_keypress_cb() @endlink \n
 138  *  @link dupe_menu_popup_main() @endlink
 139  *
 140  * See also @link hard_coded_window_keys @endlink
 141  **/
 142 hard_coded_window_keys dupe_window_keys[] = {
 143         {GDK_CONTROL_MASK, 'C', N_("Copy")},
 144         {GDK_CONTROL_MASK, 'M', N_("Move")},
 145         {GDK_CONTROL_MASK, 'R', N_("Rename")},
 146         {GDK_CONTROL_MASK, 'D', N_("Move to Trash")},
 147         {GDK_SHIFT_MASK, GDK_KEY_Delete, N_("Delete")},
 148         {static_cast<GdkModifierType>(0), GDK_KEY_Delete, N_("Remove")},
 149         {GDK_CONTROL_MASK, GDK_KEY_Delete, N_("Clear")},
 150         {GDK_CONTROL_MASK, 'A', N_("Select all")},
 151         {static_cast<GdkModifierType>(GDK_CONTROL_MASK + GDK_SHIFT_MASK), 'A', N_("Select none")},
 152         {GDK_CONTROL_MASK, 'T', N_("Toggle thumbs")},
 153         {GDK_CONTROL_MASK, 'W', N_("Close window")},
 154         {static_cast<GdkModifierType>(0), GDK_KEY_Return, N_("View")},
 155         {static_cast<GdkModifierType>(0), 'V', N_("View in new window")},
 156         {static_cast<GdkModifierType>(0), 'C', N_("Collection from selection")},
 157         {GDK_CONTROL_MASK, 'L', N_("Append list")},
 158         {static_cast<GdkModifierType>(0), '0', N_("Select none")},
 159         {static_cast<GdkModifierType>(0), '1', N_("Select group 1 duplicates")},
 160         {static_cast<GdkModifierType>(0), '2', N_("Select group 2 duplicates")},
 161         {static_cast<GdkModifierType>(0), 0, nullptr}
 162 };
 163
 164 /**
 165  * @brief The function run in threads for similarity checks
 166  * @param d1 #DupeQueueItem
 167  * @param d2 #DupeWindow
 168  *
 169  * Used only for similarity checks.\n
 170  * Search \a dqi->list for \a dqi->needle and if a match is
 171  * found, create a #DupeSearchMatch and add to \a dw->search_matches list\n
 172  * If \a dw->abort is set, just increment \a dw->thread_count
 173  */
 174 static void dupe_comparison_func(gpointer d1, gpointer d2)
 175 {
 176         auto dqi = static_cast<DupeQueueItem *>(d1);
 177         auto dw = static_cast<DupeWindow *>(d2);
 178         DupeSearchMatch *dsm;
 179         DupeItem *di;
 180         GList *matches = nullptr;
 181         gdouble rank = 0;
 182
 183         if (!dw->abort)
 184                 {
 185                 GList *work = dqi->work;
 186                 while (work)
 187                         {
 188                         di = static_cast<DupeItem *>(work->data);
 189
 190                         /* forward for second set, back for simple compare */
 191                         if (dw->second_set)
 192                                 {
 193                                 work = work->next;
 194                                 }
 195                         else
 196                                 {
 197                                 work = work->prev;
 198                                 }
 199
 200                         if (dupe_match(di, dqi->needle, dqi->dw->match_mask, &rank, TRUE))
 201                                 {
 202                                 dsm = g_new0(DupeSearchMatch, 1);
 203                                 dsm->a = di;
 204                                 dsm->b = dqi->needle;
 205                                 dsm->rank = rank;
 206                                 matches = g_list_prepend(matches, dsm);
 207                                 dsm->index = dqi->index;
 208                                 }
 209
 210                         if (dw->abort)
 211                                 {
 212                                 break;
 213                                 }
 214                         }
 215
 216                 matches = g_list_reverse(matches);
 217                 g_mutex_lock(&dw->search_matches_mutex);
 218                 dw->search_matches = g_list_concat(dw->search_matches, matches);
 219                 g_mutex_unlock(&dw->search_matches_mutex);
 220                 }
 221
 222         g_mutex_lock(&dw->thread_count_mutex);
 223         dw->thread_count++;
 224         g_mutex_unlock(&dw->thread_count_mutex);
 225         g_free(dqi);
 226 }
 227
 228 /*
 229  * ------------------------------------------------------------------
 230  * Window updates
 231  * ------------------------------------------------------------------
 232  */
 233
 234 /**
 235  * @brief Update display of status label
 236  * @param dw
 237  * @param count_only
 238  *
 239  *
 240  */
 241 static void dupe_window_update_count(DupeWindow *dw, gboolean count_only)
 242 {
 243         gchar *text;
 244
 245         if (!dw->list)
 246                 {
 247                 text = g_strdup(_("Drop files to compare them."));
 248                 }
 249         else if (count_only)
 250                 {
 251                 text = g_strdup_printf(_("%d files"), g_list_length(dw->list));
 252                 }
 253         else
 254                 {
 255                 text = g_strdup_printf(_("%d matches found in %d files"), g_list_length(dw->dupes), g_list_length(dw->list));
 256                 }
 257
 258         if (dw->second_set)
 259                 {
 260                 gchar *buf = g_strconcat(text, " ", _("[set 1]"), NULL);
 261                 g_free(text);
 262                 text = buf;
 263                 }
 264         gtk_label_set_text(GTK_LABEL(dw->status_label), text);
 265
 266         g_free(text);
 267 }
 268
 269 /**
 270  * @brief Returns time in µsec since Epoch
 271  * @returns
 272  *
 273  *
 274  */
 275 static guint64 msec_time()
 276 {
 277         struct timeval tv;
 278
 279         if (gettimeofday(&tv, nullptr) == -1) return 0;
 280
 281         return static_cast<guint64>(tv.tv_sec) * 1000000 + static_cast<guint64>(tv.tv_usec);
 282 }
 283
 284 static gint dupe_iterations(gint n)
 285 {
 286         return (n * ((n + 1) / 2));
 287 }
 288
 289 /**
 290  * @brief
 291  * @param dw
 292  * @param status
 293  * @param value
 294  * @param force
 295  *
 296  * If \a status is blank, clear status bar text and set progress to zero. \n
 297  * If \a force is not set, after 2 secs has elapsed, update time-to-go every 250 ms.
 298  */
 299 static void dupe_window_update_progress(DupeWindow *dw, const gchar *status, gdouble value, gboolean force)
 300 {
 301         const gchar *status_text;
 302
 303         if (status)
 304                 {
 305                 guint64 new_time = 0;
 306
 307                 if (dw->setup_n % 10 == 0)
 308                         {
 309                         new_time = msec_time() - dw->setup_time;
 310                         }
 311
 312                 if (!force &&
 313                     value != 0.0 &&
 314                     dw->setup_count > 0 &&
 315                     new_time > 2000000)
 316                         {
 317                         gchar *buf;
 318                         gint t;
 319                         gint d;
 320                         guint32 rem;
 321
 322                         if (new_time - dw->setup_time_count < 250000) return;
 323                         dw->setup_time_count = new_time;
 324
 325                         if (dw->setup_done)
 326                                 {
 327                                 if (dw->second_set)
 328                                         {
 329                                         t = dw->setup_count;
 330                                         d = dw->setup_count - dw->setup_n;
 331                                         }
 332                                 else
 333                                         {
 334                                         t = dupe_iterations(dw->setup_count);
 335                                         d = dupe_iterations(dw->setup_count - dw->setup_n);
 336                                         }
 337                                 }
 338                         else
 339                                 {
 340                                 t = dw->setup_count;
 341                                 d = dw->setup_count - dw->setup_n;
 342                                 }
 343
 344                         rem = (t - d) ? (static_cast<gdouble>(dw->setup_time_count / 1000000) / (t - d)) * d : 0;
 345
 346                         gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dw->extra_label), value);
 347
 348                         buf = g_strdup_printf("%s %d:%02d ", status, rem / 60, rem % 60);
 349                         gtk_progress_bar_set_text(GTK_PROGRESS_BAR(dw->extra_label), buf);
 350                         g_free(buf);
 351
 352                         return;
 353                         }
 354                 else if (force ||
 355                          value == 0.0 ||
 356                          dw->setup_count == 0 ||
 357                          dw->setup_time_count == 0 ||
 358                          (new_time > 0 && new_time - dw->setup_time_count >= 250000))
 359                         {
 360                         if (dw->setup_time_count == 0) dw->setup_time_count = 1;
 361                         if (new_time > 0) dw->setup_time_count = new_time;
 362                         gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dw->extra_label), value);
 363                         status_text = status;
 364                         }
 365                 else
 366                         {
 367                         status_text = nullptr;
 368                         }
 369                 }
 370         else
 371                 {
 372                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dw->extra_label), 0.0);
 373                 status_text = " ";
 374                 }
 375
 376         if (status_text) gtk_progress_bar_set_text(GTK_PROGRESS_BAR(dw->extra_label), status_text);
 377 }
 378
 379 static void widget_set_cursor(GtkWidget *widget, gint icon)
 380 {
 381         GdkCursor *cursor;
 382         GdkDisplay *display;
 383
 384         if (!gtk_widget_get_window(widget)) return;
 385
 386         if (icon == -1)
 387                 {
 388                 cursor = nullptr;
 389                 }
 390         else
 391                 {
 392                 display = gdk_display_get_default();
 393                 cursor = gdk_cursor_new_for_display(display, static_cast<GdkCursorType>(icon));
 394                 }
 395
 396         gdk_window_set_cursor(gtk_widget_get_window(widget), cursor);
 397
 398         if (cursor) g_object_unref(G_OBJECT(cursor));
 399 }
 400
 401 /*
 402  * ------------------------------------------------------------------
 403  * row color utils
 404  * ------------------------------------------------------------------
 405  */
 406
 407 static void dupe_listview_realign_colors(DupeWindow *dw)
 408 {
 409         GtkTreeModel *store;
 410         GtkTreeIter iter;
 411         gboolean color_set = TRUE;
 412         DupeItem *parent = nullptr;
 413         gboolean valid;
 414
 415         store = gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview));
 416         valid = gtk_tree_model_get_iter_first(store, &iter);
 417         while (valid)
 418                 {
 419                 DupeItem *child;
 420                 DupeItem *child_parent;
 421
 422                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &child, -1);
 423                 child_parent = dupe_match_find_parent(dw, child);
 424                 if (!parent || parent != child_parent)
 425                         {
 426                         if (!parent)
 427                                 {
 428                                 /* keep the first row as it is */
 429                                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_COLOR, &color_set, -1);
 430                                 }
 431                         else
 432                                 {
 433                                 color_set = !color_set;
 434                                 }
 435                         parent = dupe_match_find_parent(dw, child);
 436                         }
 437                 gtk_list_store_set(GTK_LIST_STORE(store), &iter, DUPE_COLUMN_COLOR, color_set, -1);
 438
 439                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
 440                 }
 441 }
 442
 443 /*
 444  * ------------------------------------------------------------------
 445  * Dupe item utils
 446  * ------------------------------------------------------------------
 447  */
 448
 449 static DupeItem *dupe_item_new(FileData *fd)
 450 {
 451         DupeItem *di;
 452
 453         di = g_new0(DupeItem, 1);
 454
 455         di->fd = file_data_ref(fd);
 456         di->group_rank = 0.0;
 457
 458         return di;
 459 }
 460
 461 static void dupe_item_free(DupeItem *di)
 462 {
 463         file_data_unref(di->fd);
 464         image_sim_free(di->simd);
 465         g_free(di->md5sum);
 466         if (di->pixbuf) g_object_unref(di->pixbuf);
 467
 468         g_free(di);
 469 }
 470
 471 #pragma GCC diagnostic push
 472 #pragma GCC diagnostic ignored "-Wunused-function"
 473 static DupeItem *dupe_item_find_fd_by_list_unused(FileData *fd, GList *work)
 474 {
 475         while (work)
 476                 {
 477                 DupeItem *di = static_cast<DupeItem *>(work->data);
 478
 479                 if (di->fd == fd) return di;
 480
 481                 work = work->next;
 482                 }
 483
 484         return NULL;
 485 }
 486
 487 static DupeItem *dupe_item_find_fd_unused(DupeWindow *dw, FileData *fd)
 488 {
 489         DupeItem *di;
 490
 491         di = dupe_item_find_fd_by_list_unused(fd, dw->list);
 492         if (!di && dw->second_set) di = dupe_item_find_fd_by_list_unused(fd, dw->second_list);
 493
 494         return di;
 495 }
 496
 497 static DupeItem *dupe_item_find_path_by_list_unused(const gchar *path, GList *work)
 498 {
 499         while (work)
 500                 {
 501                 DupeItem *di = static_cast<DupeItem *>(work->data);
 502
 503                 if (strcmp(di->fd->path, path) == 0) return di;
 504
 505                 work = work->next;
 506                 }
 507
 508         return NULL;
 509 }
 510
 511 static DupeItem *dupe_item_find_path_unused(DupeWindow *dw, const gchar *path)
 512 {
 513         DupeItem *di;
 514
 515         di = dupe_item_find_path_by_list_unused(path, dw->list);
 516         if (!di && dw->second_set) di = dupe_item_find_path_by_list_unused(path, dw->second_list);
 517
 518         return di;
 519 }
 520 #pragma GCC diagnostic pop
 521
 522 /*
 523  * ------------------------------------------------------------------
 524  * Image property cache
 525  * ------------------------------------------------------------------
 526  */
 527
 528 static void dupe_item_read_cache(DupeItem *di)
 529 {
 530         gchar *path;
 531         CacheData *cd;
 532
 533         if (!di) return;
 534
 535         path = cache_find_location(CACHE_TYPE_SIM, di->fd->path);
 536         if (!path) return;
 537
 538         if (filetime(di->fd->path) != filetime(path))
 539                 {
 540                 g_free(path);
 541                 return;
 542                 }
 543
 544         cd = cache_sim_data_load(path);
 545         g_free(path);
 546
 547         if (cd)
 548                 {
 549                 if (!di->simd && cd->sim)
 550                         {
 551                         di->simd = cd->sim;
 552                         cd->sim = nullptr;
 553                         }
 554                 if (di->width == 0 && di->height == 0 && cd->dimensions)
 555                         {
 556                         di->width = cd->width;
 557                         di->height = cd->height;
 558                         di->dimensions = (di->width << 16) + di->height;
 559                         }
 560                 if (!di->md5sum && cd->have_md5sum)
 561                         {
 562                         di->md5sum = md5_digest_to_text(cd->md5sum);
 563                         }
 564                 cache_sim_data_free(cd);
 565                 }
 566 }
 567
 568 static void dupe_item_write_cache(DupeItem *di)
 569 {
 570         gchar *base;
 571         mode_t mode = 0755;
 572
 573         if (!di) return;
 574
 575         base = cache_get_location(CACHE_TYPE_SIM, di->fd->path, FALSE, &mode);
 576         if (recursive_mkdir_if_not_exists(base, mode))
 577                 {
 578                 CacheData *cd;
 579
 580                 cd = cache_sim_data_new();
 581                 cd->path = cache_get_location(CACHE_TYPE_SIM, di->fd->path, TRUE, nullptr);
 582
 583                 if (di->width != 0) cache_sim_data_set_dimensions(cd, di->width, di->height);
 584                 if (di->md5sum)
 585                         {
 586                         guchar digest[16];
 587                         if (md5_digest_from_text(di->md5sum, digest)) cache_sim_data_set_md5sum(cd, digest);
 588                         }
 589                 if (di->simd) cache_sim_data_set_similarity(cd, di->simd);
 590
 591                 if (cache_sim_data_save(cd))
 592                         {
 593                         filetime_set(cd->path, filetime(di->fd->path));
 594                         }
 595                 cache_sim_data_free(cd);
 596                 }
 597         g_free(base);
 598 }
 599
 600 /*
 601  * ------------------------------------------------------------------
 602  * Window list utils
 603  * ------------------------------------------------------------------
 604  */
 605
 606 static gint dupe_listview_find_item(GtkListStore *store, DupeItem *item, GtkTreeIter *iter)
 607 {
 608         gboolean valid;
 609         gint row = 0;
 610
 611         valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), iter);
 612         while (valid)
 613                 {
 614                 DupeItem *item_n;
 615                 gtk_tree_model_get(GTK_TREE_MODEL(store), iter, DUPE_COLUMN_POINTER, &item_n, -1);
 616                 if (item_n == item) return row;
 617
 618                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(store), iter);
 619                 row++;
 620                 }
 621
 622         return -1;
 623 }
 624
 625 static void dupe_listview_add(DupeWindow *dw, DupeItem *parent, DupeItem *child)
 626 {
 627         DupeItem *di;
 628         gint row;
 629         gchar *text[DUPE_COLUMN_COUNT];
 630         GtkListStore *store;
 631         GtkTreeIter iter;
 632         gboolean color_set = FALSE;
 633         gint rank;
 634
 635         if (!parent) return;
 636
 637         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
 638
 639         if (child)
 640                 {
 641                 DupeMatch *dm;
 642
 643                 row = dupe_listview_find_item(store, parent, &iter);
 644                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, DUPE_COLUMN_COLOR, &color_set, -1);
 645
 646                 row++;
 647
 648                 if (child->group)
 649                         {
 650                         dm = static_cast<DupeMatch *>(child->group->data);
 651                         rank = static_cast<gint>(floor(dm->rank));
 652                         }
 653                 else
 654                         {
 655                         rank = 1;
 656                         log_printf("NULL group in item!\n");
 657                         }
 658                 }
 659         else
 660                 {
 661                 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter))
 662                         {
 663                         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, DUPE_COLUMN_COLOR, &color_set, -1);
 664                         color_set = !color_set;
 665                         dw->set_count++;
 666                         }
 667                 else
 668                         {
 669                         color_set = FALSE;
 670                         }
 671                 row = 0;
 672                 rank = 0;
 673                 }
 674
 675         di = (child) ? child : parent;
 676
 677         if (!child && dw->second_set)
 678                 {
 679                 text[DUPE_COLUMN_RANK] = g_strdup("[1]");
 680                 }
 681         else if (rank == 0)
 682                 {
 683                 text[DUPE_COLUMN_RANK] = g_strdup((di->second) ? "(2)" : "");
 684                 }
 685         else
 686                 {
 687                 text[DUPE_COLUMN_RANK] = g_strdup_printf("%d%s", rank, (di->second) ? " (2)" : "");
 688                 }
 689
 690         text[DUPE_COLUMN_THUMB] = nullptr;
 691         text[DUPE_COLUMN_NAME] = const_cast<gchar *>(di->fd->name);
 692         text[DUPE_COLUMN_SIZE] = text_from_size(di->fd->size);
 693         text[DUPE_COLUMN_DATE] = const_cast<gchar *>(text_from_time(di->fd->date));
 694         if (di->width > 0 && di->height > 0)
 695                 {
 696                 text[DUPE_COLUMN_DIMENSIONS] = g_strdup_printf("%d x %d", di->width, di->height);
 697                 }
 698         else
 699                 {
 700                 text[DUPE_COLUMN_DIMENSIONS] = g_strdup("");
 701                 }
 702         text[DUPE_COLUMN_PATH] = di->fd->path;
 703         text[DUPE_COLUMN_COLOR] = nullptr;
 704
 705         gtk_list_store_insert(store, &iter, row);
 706         gtk_list_store_set(store, &iter,
 707                                 DUPE_COLUMN_POINTER, di,
 708                                 DUPE_COLUMN_RANK, text[DUPE_COLUMN_RANK],
 709                                 DUPE_COLUMN_THUMB, NULL,
 710                                 DUPE_COLUMN_NAME, text[DUPE_COLUMN_NAME],
 711                                 DUPE_COLUMN_SIZE, text[DUPE_COLUMN_SIZE],
 712                                 DUPE_COLUMN_DATE, text[DUPE_COLUMN_DATE],
 713                                 DUPE_COLUMN_DIMENSIONS, text[DUPE_COLUMN_DIMENSIONS],
 714                                 DUPE_COLUMN_PATH, text[DUPE_COLUMN_PATH],
 715                                 DUPE_COLUMN_COLOR, color_set,
 716                                 DUPE_COLUMN_SET, dw->set_count,
 717                                 -1);
 718
 719         g_free(text[DUPE_COLUMN_RANK]);
 720         g_free(text[DUPE_COLUMN_SIZE]);
 721         g_free(text[DUPE_COLUMN_DIMENSIONS]);
 722 }
 723
 724 static void dupe_listview_select_dupes(DupeWindow *dw, DupeSelectType parents);
 725
 726 static void dupe_listview_populate(DupeWindow *dw)
 727 {
 728         GtkListStore *store;
 729         GList *work;
 730
 731         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
 732         gtk_list_store_clear(store);
 733
 734         work = g_list_last(dw->dupes);
 735         while (work)
 736                 {
 737                 auto parent = static_cast<DupeItem *>(work->data);
 738                 GList *temp;
 739
 740                 dupe_listview_add(dw, parent, nullptr);
 741
 742                 temp = g_list_last(parent->group);
 743                 while (temp)
 744                         {
 745                         auto dm = static_cast<DupeMatch *>(temp->data);
 746                         DupeItem *child;
 747
 748                         child = dm->di;
 749
 750                         dupe_listview_add(dw, parent, child);
 751
 752                         temp = temp->prev;
 753                         }
 754
 755                 work = work->prev;
 756                 }
 757
 758         gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dw->listview));
 759
 760         if (options->duplicates_select_type == DUPE_SELECT_GROUP1)
 761                 {
 762                 dupe_listview_select_dupes(dw, DUPE_SELECT_GROUP1);
 763                 }
 764         else if (options->duplicates_select_type == DUPE_SELECT_GROUP2)
 765                 {
 766                 dupe_listview_select_dupes(dw, DUPE_SELECT_GROUP2);
 767                 }
 768
 769 }
 770
 771 static void dupe_listview_remove(DupeWindow *dw, DupeItem *di)
 772 {
 773         GtkListStore *store;
 774         GtkTreeIter iter;
 775         gint row;
 776
 777         if (!di) return;
 778
 779         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
 780         row = dupe_listview_find_item(store, di, &iter);
 781         if (row < 0) return;
 782
 783         tree_view_move_cursor_away(GTK_TREE_VIEW(dw->listview), &iter, TRUE);
 784         gtk_list_store_remove(store, &iter);
 785
 786         if (g_list_find(dw->dupes, di) != nullptr)
 787                 {
 788                 if (!dw->color_frozen) dupe_listview_realign_colors(dw);
 789                 }
 790 }
 791
 792
 793 static GList *dupe_listview_get_filelist(DupeWindow *, GtkWidget *listview)
 794 {
 795         GtkTreeModel *store;
 796         GtkTreeIter iter;
 797         gboolean valid;
 798         GList *list = nullptr;
 799
 800         store = gtk_tree_view_get_model(GTK_TREE_VIEW(listview));
 801         valid = gtk_tree_model_get_iter_first(store, &iter);
 802         while (valid)
 803                 {
 804                 DupeItem *di;
 805                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
 806                 list = g_list_prepend(list, file_data_ref(di->fd));
 807
 808                 valid = gtk_tree_model_iter_next(store, &iter);
 809                 }
 810
 811         return g_list_reverse(list);
 812 }
 813
 814
 815 static GList *dupe_listview_get_selection(DupeWindow *, GtkWidget *listview)
 816 {
 817         GtkTreeModel *store;
 818         GtkTreeSelection *selection;
 819         GList *slist;
 820         GList *list = nullptr;
 821         GList *work;
 822
 823         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
 824         slist = gtk_tree_selection_get_selected_rows(selection, &store);
 825         work = slist;
 826         while (work)
 827                 {
 828                 auto tpath = static_cast<GtkTreePath *>(work->data);
 829                 DupeItem *di = nullptr;
 830                 GtkTreeIter iter;
 831
 832                 gtk_tree_model_get_iter(store, &iter, tpath);
 833                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
 834                 if (di)
 835                         {
 836                         list = g_list_prepend(list, file_data_ref(di->fd));
 837                         }
 838                 work = work->next;
 839                 }
 840         g_list_free_full(slist, reinterpret_cast<GDestroyNotify>(gtk_tree_path_free));
 841
 842         return g_list_reverse(list);
 843 }
 844
 845 static gboolean dupe_listview_item_is_selected(DupeWindow *, DupeItem *di, GtkWidget *listview)
 846 {
 847         GtkTreeModel *store;
 848         GtkTreeSelection *selection;
 849         GList *slist;
 850         GList *work;
 851         gboolean found = FALSE;
 852
 853         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
 854         slist = gtk_tree_selection_get_selected_rows(selection, &store);
 855         work = slist;
 856         while (!found && work)
 857                 {
 858                 auto tpath = static_cast<GtkTreePath *>(work->data);
 859                 DupeItem *di_n;
 860                 GtkTreeIter iter;
 861
 862                 gtk_tree_model_get_iter(store, &iter, tpath);
 863                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di_n, -1);
 864                 if (di_n == di) found = TRUE;
 865                 work = work->next;
 866                 }
 867         g_list_free_full(slist, reinterpret_cast<GDestroyNotify>(gtk_tree_path_free));
 868
 869         return found;
 870 }
 871
 872 static void dupe_listview_select_dupes(DupeWindow *dw, DupeSelectType parents)
 873 {
 874         GtkTreeModel *store;
 875         GtkTreeSelection *selection;
 876         GtkTreeIter iter;
 877         gboolean valid;
 878         gint set_count = 0;
 879         gint set_count_last = -1;
 880
 881         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->listview));
 882         gtk_tree_selection_unselect_all(selection);
 883
 884         store = gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview));
 885         valid = gtk_tree_model_get_iter_first(store, &iter);
 886         while (valid)
 887                 {
 888                 DupeItem *di;
 889
 890                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, DUPE_COLUMN_SET, &set_count, -1);
 891                 if (set_count != set_count_last)
 892                         {
 893                         set_count_last = set_count;
 894                         if (parents == DUPE_SELECT_GROUP1)
 895                                 {
 896                                 gtk_tree_selection_select_iter(selection, &iter);
 897                                 }
 898                         }
 899                 else
 900                         {
 901                         if (parents == DUPE_SELECT_GROUP2)
 902                                 {
 903                                 gtk_tree_selection_select_iter(selection, &iter);
 904                                 }
 905                         }
 906                 valid = gtk_tree_model_iter_next(store, &iter);
 907                 }
 908 }
 909
 910 /*
 911  * ------------------------------------------------------------------
 912  * Match group manipulation
 913  * ------------------------------------------------------------------
 914  */
 915
 916 /**
 917  * @brief Search \a parent->group for \a child (#DupeItem)
 918  * @param child
 919  * @param parent
 920  * @returns
 921  *
 922  */
 923 static DupeMatch *dupe_match_find_match(DupeItem *child, DupeItem *parent)
 924 {
 925         GList *work;
 926
 927         work = parent->group;
 928         while (work)
 929                 {
 930                 auto dm = static_cast<DupeMatch *>(work->data);
 931                 if (dm->di == child) return dm;
 932                 work = work->next;
 933                 }
 934         return nullptr;
 935 }
 936
 937 /**
 938  * @brief Create #DupeMatch structure for \a child, and insert into \a parent->group list.
 939  * @param child
 940  * @param parent
 941  * @param rank
 942  *
 943  */
 944 static void dupe_match_link_child(DupeItem *child, DupeItem *parent, gdouble rank)
 945 {
 946         DupeMatch *dm;
 947
 948         dm = g_new0(DupeMatch, 1);
 949         dm->di = child;
 950         dm->rank = rank;
 951         parent->group = g_list_append(parent->group, dm);
 952 }
 953
 954 /**
 955  * @brief Link \a a & \a b as both parent and child
 956  * @param a
 957  * @param b
 958  * @param rank
 959  *
 960  * Link \a a as child of \a b, and \a b as child of \a a
 961  */
 962 static void dupe_match_link(DupeItem *a, DupeItem *b, gdouble rank)
 963 {
 964         dupe_match_link_child(a, b, rank);
 965         dupe_match_link_child(b, a, rank);
 966 }
 967
 968 /**
 969  * @brief Remove \a child #DupeMatch from \a parent->group list.
 970  * @param child
 971  * @param parent
 972  *
 973  */
 974 static void dupe_match_unlink_child(DupeItem *child, DupeItem *parent)
 975 {
 976         DupeMatch *dm;
 977
 978         dm = dupe_match_find_match(child, parent);
 979         if (dm)
 980                 {
 981                 parent->group = g_list_remove(parent->group, dm);
 982                 g_free(dm);
 983                 }
 984 }
 985
 986 /**
 987  * @brief  Unlink \a a from \a b, and \a b from \a a
 988  * @param a
 989  * @param b
 990  *
 991  * Free the relevant #DupeMatch items from the #DupeItem group lists
 992  */
 993 static void dupe_match_unlink(DupeItem *a, DupeItem *b)
 994 {
 995         dupe_match_unlink_child(a, b);
 996         dupe_match_unlink_child(b, a);
 997 }
 998
 999 /**
1000  * @brief
1001  * @param parent
1002  * @param unlink_children
1003  *
1004  * If \a unlink_children is set, unlink all entries in \a parent->group list. \n
1005  * Free the \a parent->group list and set group_rank to zero;
1006  */
1007 static void dupe_match_link_clear(DupeItem *parent, gboolean unlink_children)
1008 {
1009         if (unlink_children)
1010                 {
1011                 GList *work;
1012
1013                 work = parent->group;
1014                 while (work)
1015                         {
1016                         auto dm = static_cast<DupeMatch *>(work->data);
1017                         work = work->next;
1018
1019                         dupe_match_unlink_child(parent, dm->di);
1020                         }
1021                 }
1022
1023         g_list_free_full(parent->group, g_free);
1024         parent->group = nullptr;
1025         parent->group_rank = 0.0;
1026 }
1027
1028 /**
1029  * @brief Search \a parent->group list for \a child
1030  * @param child
1031  * @param parent
1032  * @returns boolean TRUE/FALSE found/not found
1033  *
1034  */
1035 static gint dupe_match_link_exists(DupeItem *child, DupeItem *parent)
1036 {
1037         return (dupe_match_find_match(child, parent) != nullptr);
1038 }
1039
1040 /**
1041  * @brief  Search \a parent->group for \a child, and return \a child->rank
1042  * @param child
1043  * @param parent
1044  * @returns \a dm->di->rank
1045  *
1046  */
1047 static gdouble dupe_match_link_rank(DupeItem *child, DupeItem *parent)
1048 {
1049         DupeMatch *dm;
1050
1051         dm = dupe_match_find_match(child, parent);
1052         if (dm) return dm->rank;
1053
1054         return 0.0;
1055 }
1056
1057 /**
1058  * @brief Find highest rank in \a child->group
1059  * @param child
1060  * @returns
1061  *
1062  * Search the #DupeMatch entries in the \a child->group list.
1063  * Return the #DupeItem with the highest rank. If more than one have
1064  * the same rank, the first encountered is used.
1065  */
1066 static DupeItem *dupe_match_highest_rank(DupeItem *child)
1067 {
1068         DupeMatch *dr;
1069         GList *work;
1070
1071         dr = nullptr;
1072         work = child->group;
1073         while (work)
1074                 {
1075                 auto dm = static_cast<DupeMatch *>(work->data);
1076                 if (!dr || dm->rank > dr->rank)
1077                         {
1078                         dr = dm;
1079                         }
1080                 work = work->next;
1081                 }
1082
1083         return (dr) ? dr->di : nullptr;
1084 }
1085
1086 /**
1087  * @brief Compute and store \a parent->group_rank
1088  * @param parent
1089  *
1090  * Group_rank = (sum of all child ranks) / n
1091  */
1092 static void dupe_match_rank_update(DupeItem *parent)
1093 {
1094         GList *work;
1095         gdouble rank = 0.0;
1096         gint c = 0;
1097
1098         work = parent->group;
1099         while (work)
1100                 {
1101                 auto dm = static_cast<DupeMatch *>(work->data);
1102                 work = work->next;
1103                 rank += dm->rank;
1104                 c++;
1105                 }
1106
1107         if (c > 0)
1108                 {
1109                 parent->group_rank = rank / c;
1110                 }
1111         else
1112                 {
1113                 parent->group_rank = 0.0;
1114                 }
1115 }
1116
1117 static DupeItem *dupe_match_find_parent(DupeWindow *dw, DupeItem *child)
1118 {
1119         GList *work;
1120
1121         if (g_list_find(dw->dupes, child)) return child;
1122
1123         work = child->group;
1124         while (work)
1125                 {
1126                 auto dm = static_cast<DupeMatch *>(work->data);
1127                 if (g_list_find(dw->dupes, dm->di)) return dm->di;
1128                 work = work->next;
1129                 }
1130
1131         return nullptr;
1132 }
1133
1134 /**
1135  * @brief
1136  * @param work (#DupeItem) dw->list or dw->second_list
1137  *
1138  * Unlink all #DupeItem-s in \a work.
1139  * Do not unlink children.
1140  */
1141 static void dupe_match_reset_list(GList *work)
1142 {
1143         while (work)
1144                 {
1145                 auto di = static_cast<DupeItem *>(work->data);
1146                 work = work->next;
1147
1148                 dupe_match_link_clear(di, FALSE);
1149                 }
1150 }
1151
1152 static void dupe_match_reparent(DupeWindow *dw, DupeItem *old_parent, DupeItem *new_parent)
1153 {
1154         GList *work;
1155
1156         if (!old_parent || !new_parent || !dupe_match_link_exists(old_parent, new_parent)) return;
1157
1158         dupe_match_link_clear(new_parent, TRUE);
1159         work = old_parent->group;
1160         while (work)
1161                 {
1162                 auto dm = static_cast<DupeMatch *>(work->data);
1163                 dupe_match_unlink_child(old_parent, dm->di);
1164                 dupe_match_link_child(new_parent, dm->di, dm->rank);
1165                 work = work->next;
1166                 }
1167
1168         new_parent->group = old_parent->group;
1169         old_parent->group = nullptr;
1170
1171         work = g_list_find(dw->dupes, old_parent);
1172         if (work) work->data = new_parent;
1173 }
1174
1175 static void dupe_match_print_group(DupeItem *di)
1176 {
1177         GList *work;
1178
1179         log_printf("+ %f %s\n", di->group_rank, di->fd->name);
1180
1181         work = di->group;
1182         while (work)
1183                 {
1184                 auto dm = static_cast<DupeMatch *>(work->data);
1185                 work = work->next;
1186
1187                 log_printf("  %f %s\n", dm->rank, dm->di->fd->name);
1188                 }
1189
1190         log_printf("\n");
1191 }
1192
1193 static void dupe_match_print_list(GList *list)
1194 {
1195         GList *work;
1196
1197         work = list;
1198         while (work)
1199                 {
1200                 auto di = static_cast<DupeItem *>(work->data);
1201                 dupe_match_print_group(di);
1202                 work = work->next;
1203                 }
1204 }
1205
1206 /* level 3, unlinking and orphan handling */
1207 /**
1208  * @brief
1209  * @param child
1210  * @param parent \a di from \a child->group
1211  * @param[inout] list \a dw->list sorted by rank (#DupeItem)
1212  * @param dw
1213  * @returns modified \a list
1214  *
1215  * Called for each entry in \a child->group (#DupeMatch) with \a parent set to \a dm->di. \n
1216  * Find the highest rank #DupeItem of the \a parent's children. \n
1217  * If that is == \a child OR
1218  * highest rank #DupeItem of \a child == \a parent then FIXME:
1219  *
1220  */
1221 static GList *dupe_match_unlink_by_rank(DupeItem *child, DupeItem *parent, GList *list, DupeWindow *dw)
1222 {
1223         DupeItem *best = nullptr;
1224
1225         best = dupe_match_highest_rank(parent); // highest rank in parent->group
1226         if (best == child || dupe_match_highest_rank(child) == parent)
1227                 {
1228                 GList *work;
1229                 gdouble rank;
1230
1231                 DEBUG_2("link found %s to %s [%d]", child->fd->name, parent->fd->name, g_list_length(parent->group));
1232
1233                 work = parent->group;
1234                 while (work)
1235                         {
1236                         auto dm = static_cast<DupeMatch *>(work->data);
1237                         DupeItem *orphan;
1238
1239                         work = work->next;
1240                         orphan = dm->di;
1241                         if (orphan != child && g_list_length(orphan->group) < 2)
1242                                 {
1243                                 dupe_match_link_clear(orphan, TRUE);
1244                                 if (!dw->second_set || orphan->second)
1245                                         {
1246                                         dupe_match(orphan, child, dw->match_mask, &rank, FALSE);
1247                                         dupe_match_link(orphan, child, rank);
1248                                         }
1249                                 list = g_list_remove(list, orphan);
1250                                 }
1251                         }
1252
1253                 rank = dupe_match_link_rank(child, parent); // child->rank
1254                 dupe_match_link_clear(parent, TRUE);
1255                 dupe_match_link(child, parent, rank);
1256                 list = g_list_remove(list, parent);
1257                 }
1258         else
1259                 {
1260                 DEBUG_2("unlinking %s and %s", child->fd->name, parent->fd->name);
1261
1262                 dupe_match_unlink(child, parent);
1263                 }
1264
1265         return list;
1266 }
1267
1268 /* level 2 */
1269 /**
1270  * @brief
1271  * @param[inout] list \a dw->list sorted by rank (#DupeItem)
1272  * @param di
1273  * @param dw
1274  * @returns modified \a list
1275  *
1276  * Called for each entry in \a list.
1277  * Call unlink for each child in \a di->group
1278  */
1279 static GList *dupe_match_group_filter(GList *list, DupeItem *di, DupeWindow *dw)
1280 {
1281         GList *work;
1282
1283         work = g_list_last(di->group);
1284         while (work)
1285                 {
1286                 auto dm = static_cast<DupeMatch *>(work->data);
1287                 work = work->prev;
1288                 list = dupe_match_unlink_by_rank(di, dm->di, list, dw);
1289                 }
1290
1291         return list;
1292 }
1293
1294 /* level 1 (top) */
1295 /**
1296  * @brief
1297  * @param[inout] list \a dw->list sorted by rank (#DupeItem)
1298  * @param dw
1299  * @returns Filtered \a list
1300  *
1301  * Called once.
1302  * Call group filter for each \a di in \a list
1303  */
1304 static GList *dupe_match_group_trim(GList *list, DupeWindow *dw)
1305 {
1306         GList *work;
1307
1308         work = list;
1309         while (work)
1310                 {
1311                 auto di = static_cast<DupeItem *>(work->data);
1312                 if (!di->second) list = dupe_match_group_filter(list, di, dw);
1313                 work = work->next;
1314                 if (di->second) list = g_list_remove(list, di);
1315                 }
1316
1317         return list;
1318 }
1319
1320 static gint dupe_match_sort_groups_cb(gconstpointer a, gconstpointer b)
1321 {
1322         auto da = static_cast<const DupeMatch *>(a);
1323         auto db = static_cast<const DupeMatch *>(b);
1324
1325         if (da->rank > db->rank) return -1;
1326         if (da->rank < db->rank) return 1;
1327         return 0;
1328 }
1329
1330 /**
1331  * @brief Sorts the children of each #DupeItem in \a list
1332  * @param list #DupeItem
1333  *
1334  * Sorts the #DupeItem->group children on rank
1335  */
1336 static void dupe_match_sort_groups(GList *list)
1337 {
1338         GList *work;
1339
1340         work = list;
1341         while (work)
1342                 {
1343                 auto di = static_cast<DupeItem *>(work->data);
1344                 di->group = g_list_sort(di->group, dupe_match_sort_groups_cb);
1345                 work = work->next;
1346                 }
1347 }
1348
1349 static gint dupe_match_totals_sort_cb(gconstpointer a, gconstpointer b)
1350 {
1351         auto da = static_cast<const DupeItem *>(a);
1352         auto db = static_cast<const DupeItem *>(b);
1353
1354         if (g_list_length(da->group) > g_list_length(db->group)) return -1;
1355         if (g_list_length(da->group) < g_list_length(db->group)) return 1;
1356
1357         if (da->group_rank < db->group_rank) return -1;
1358         if (da->group_rank > db->group_rank) return 1;
1359
1360         return 0;
1361 }
1362
1363 /**
1364  * @brief Callback for group_rank sort
1365  * @param a
1366  * @param b
1367  * @returns
1368  *
1369  *
1370  */
1371 static gint dupe_match_rank_sort_cb(gconstpointer a, gconstpointer b)
1372 {
1373         auto da = static_cast<const DupeItem *>(a);
1374         auto db = static_cast<const DupeItem *>(b);
1375
1376         if (da->group_rank > db->group_rank) return -1;
1377         if (da->group_rank < db->group_rank) return 1;
1378         return 0;
1379 }
1380
1381 /**
1382  * @brief Sorts \a source_list by group-rank
1383  * @param source_list #DupeItem
1384  * @returns
1385  *
1386  * Computes group_rank for each #DupeItem. \n
1387  * Items with no group list are ignored.
1388  * Returns allocated GList of #DupeItem-s sorted by group_rank
1389  */
1390 static GList *dupe_match_rank_sort(GList *source_list)
1391 {
1392         GList *list = nullptr;
1393         GList *work;
1394
1395         work = source_list;
1396         while (work)
1397                 {
1398                 auto di = static_cast<DupeItem *>(work->data);
1399
1400                 if (di->group)
1401                         {
1402                         dupe_match_rank_update(di); // Compute and store group_rank for di
1403                         list = g_list_prepend(list, di);
1404                         }
1405
1406                 work = work->next;
1407                 }
1408
1409         return g_list_sort(list, dupe_match_rank_sort_cb);
1410 }
1411
1412 /**
1413  * @brief Returns allocated GList of dupes sorted by totals
1414  * @param source_list
1415  * @returns
1416  *
1417  *
1418  */
1419 static GList *dupe_match_totals_sort(GList *source_list)
1420 {
1421         source_list = g_list_sort(source_list, dupe_match_totals_sort_cb);
1422
1423         source_list = g_list_first(source_list);
1424         return g_list_reverse(source_list);
1425 }
1426
1427 /**
1428  * @brief
1429  * @param dw
1430  *
1431  * Called once.
1432  */
1433 static void dupe_match_rank(DupeWindow *dw)
1434 {
1435         GList *list;
1436
1437         list = dupe_match_rank_sort(dw->list); // sorted by group_rank, no-matches filtered out
1438
1439         if (required_debug_level(2)) dupe_match_print_list(list);
1440
1441         DEBUG_1("Similar items: %d", g_list_length(list));
1442         list = dupe_match_group_trim(list, dw);
1443         DEBUG_1("Unique groups: %d", g_list_length(list));
1444
1445         dupe_match_sort_groups(list);
1446
1447         if (required_debug_level(2)) dupe_match_print_list(list);
1448
1449         list = dupe_match_rank_sort(list);
1450         if (options->sort_totals)
1451                 {
1452                 list = dupe_match_totals_sort(list);
1453                 }
1454         if (required_debug_level(2)) dupe_match_print_list(list);
1455
1456         g_list_free(dw->dupes);
1457         dw->dupes = list;
1458 }
1459
1460 /*
1461  * ------------------------------------------------------------------
1462  * Match group tests
1463  * ------------------------------------------------------------------
1464  */
1465
1466 /**
1467  * @brief
1468  * @param[in] a
1469  * @param[in] b
1470  * @param[in] mask
1471  * @param[out] rank
1472  * @param[in] fast
1473  * @returns
1474  *
1475  * For similarity checks, compute rank - (similarity factor between a and b). \n
1476  * If rank < user-set sim value, returns FALSE.
1477  */
1478 static gboolean dupe_match(DupeItem *a, DupeItem *b, DupeMatchType mask, gdouble *rank, gint fast)
1479 {
1480         *rank = 0.0;
1481
1482         if (a->fd->path == b->fd->path) return FALSE;
1483
1484         if (mask & DUPE_MATCH_ALL)
1485                 {
1486                 return TRUE;
1487                 }
1488         if (mask & DUPE_MATCH_PATH)
1489                 {
1490                 if (utf8_compare(a->fd->path, b->fd->path, TRUE) != 0) return FALSE;
1491                 }
1492         if (mask & DUPE_MATCH_NAME)
1493                 {
1494                 if (strcmp(a->fd->collate_key_name, b->fd->collate_key_name) != 0) return FALSE;
1495                 }
1496         if (mask & DUPE_MATCH_NAME_CI)
1497                 {
1498                 if (strcmp(a->fd->collate_key_name_nocase, b->fd->collate_key_name_nocase) != 0) return FALSE;
1499                 }
1500         if (mask & DUPE_MATCH_NAME_CONTENT)
1501                 {
1502                 if (strcmp(a->fd->collate_key_name, b->fd->collate_key_name) == 0)
1503                         {
1504                         if (!a->md5sum) a->md5sum = md5_text_from_file_utf8(a->fd->path, "");
1505                         if (!b->md5sum) b->md5sum = md5_text_from_file_utf8(b->fd->path, "");
1506                         if (a->md5sum[0] == '\0' ||
1507                             b->md5sum[0] == '\0' ||
1508                             strcmp(a->md5sum, b->md5sum) != 0)
1509                                 {
1510                                 return TRUE;
1511                                 }
1512                         else
1513                                 {
1514                                 return FALSE;
1515                                 }
1516                         }
1517                 else
1518                         {
1519                         return FALSE;
1520                         }
1521                 }
1522         if (mask & DUPE_MATCH_NAME_CI_CONTENT)
1523                 {
1524                 if (strcmp(a->fd->collate_key_name_nocase, b->fd->collate_key_name_nocase) == 0)
1525                         {
1526                         if (!a->md5sum) a->md5sum = md5_text_from_file_utf8(a->fd->path, "");
1527                         if (!b->md5sum) b->md5sum = md5_text_from_file_utf8(b->fd->path, "");
1528                         if (a->md5sum[0] == '\0' ||
1529                             b->md5sum[0] == '\0' ||
1530                             strcmp(a->md5sum, b->md5sum) != 0)
1531                                 {
1532                                 return TRUE;
1533                                 }
1534                         else
1535                                 {
1536                                 return FALSE;
1537                                 }
1538                         }
1539                 else
1540                         {
1541                         return FALSE;
1542                         }
1543                 }
1544         if (mask & DUPE_MATCH_SIZE)
1545                 {
1546                 if (a->fd->size != b->fd->size) return FALSE;
1547                 }
1548         if (mask & DUPE_MATCH_DATE)
1549                 {
1550                 if (a->fd->date != b->fd->date) return FALSE;
1551                 }
1552         if (mask & DUPE_MATCH_SUM)
1553                 {
1554                 if (!a->md5sum) a->md5sum = md5_text_from_file_utf8(a->fd->path, "");
1555                 if (!b->md5sum) b->md5sum = md5_text_from_file_utf8(b->fd->path, "");
1556                 if (a->md5sum[0] == '\0' ||
1557                     b->md5sum[0] == '\0' ||
1558                     strcmp(a->md5sum, b->md5sum) != 0) return FALSE;
1559                 }
1560         if (mask & DUPE_MATCH_DIM)
1561                 {
1562                 if (a->width == 0) image_load_dimensions(a->fd, &a->width, &a->height);
1563                 if (b->width == 0) image_load_dimensions(b->fd, &b->width, &b->height);
1564                 if (a->width != b->width || a->height != b->height) return FALSE;
1565                 }
1566         if (mask & DUPE_MATCH_SIM_HIGH ||
1567             mask & DUPE_MATCH_SIM_MED ||
1568             mask & DUPE_MATCH_SIM_LOW ||
1569             mask & DUPE_MATCH_SIM_CUSTOM)
1570                 {
1571                 gdouble f;
1572                 gdouble m;
1573
1574                 if (mask & DUPE_MATCH_SIM_HIGH) m = 0.95;
1575                 else if (mask & DUPE_MATCH_SIM_MED) m = 0.90;
1576                 else if (mask & DUPE_MATCH_SIM_CUSTOM) m = static_cast<gdouble>(options->duplicates_similarity_threshold) / 100.0;
1577                 else m = 0.85;
1578
1579                 if (fast)
1580                         {
1581                         f = image_sim_compare_fast(a->simd, b->simd, m);
1582                         }
1583                 else
1584                         {
1585                         f = image_sim_compare(a->simd, b->simd);
1586                         }
1587
1588                 *rank = f * 100.0;
1589
1590                 if (f < m) return FALSE;
1591
1592                 DEBUG_3("similar: %32s %32s = %f", a->fd->name, b->fd->name, f);
1593                 }
1594
1595         return TRUE;
1596 }
1597
1598 /**
1599  * @brief  Determine if there is a match
1600  * @param di1
1601  * @param di2
1602  * @param data
1603  * @returns DUPE_MATCH/DUPE_NO_MATCH/DUPE_NAME_MATCH
1604  *                      DUPE_NAME_MATCH is used for name != contents searches:
1605  *                                                      the name and content match i.e.
1606  *                                                      no match, but keep searching
1607  *
1608  * Called when stepping down the array looking for adjacent matches,
1609  * and from the 2nd set search.
1610  *
1611  * Is not used for similarity checks.
1612  */
1613 static DUPE_CHECK_RESULT dupe_match_check(DupeItem *di1, DupeItem *di2, gpointer data)
1614 {
1615         auto dw = static_cast<DupeWindow *>(data);
1616         DupeMatchType mask = dw->match_mask;
1617
1618         if (mask & DUPE_MATCH_ALL)
1619                 {
1620                 return DUPE_MATCH;
1621                 }
1622         if (mask & DUPE_MATCH_PATH)
1623                 {
1624                 if (utf8_compare(di1->fd->path, di2->fd->path, TRUE) != 0)
1625                         {
1626                         return DUPE_NO_MATCH;
1627                         }
1628                 }
1629         if (mask & DUPE_MATCH_NAME)
1630                 {
1631                 if (g_strcmp0(di1->fd->collate_key_name, di2->fd->collate_key_name) != 0)
1632                         {
1633                         return DUPE_NO_MATCH;
1634                         }
1635                 }
1636         if (mask & DUPE_MATCH_NAME_CI)
1637                 {
1638                 if (g_strcmp0(di1->fd->collate_key_name_nocase, di2->fd->collate_key_name_nocase) != 0 )
1639                         {
1640                         return DUPE_NO_MATCH;
1641                         }
1642                 }
1643         if (mask & DUPE_MATCH_NAME_CONTENT)
1644                 {
1645                 if (g_strcmp0(di1->fd->collate_key_name, di2->fd->collate_key_name) == 0)
1646                         {
1647                         if (g_strcmp0(di1->md5sum, di2->md5sum) == 0)
1648                                 {
1649                                 return DUPE_NAME_MATCH;
1650                                 }
1651                         }
1652                 else
1653                         {
1654                         return DUPE_NO_MATCH;
1655                         }
1656                 }
1657         if (mask & DUPE_MATCH_NAME_CI_CONTENT)
1658                 {
1659                 if (strcmp(di1->fd->collate_key_name_nocase, di2->fd->collate_key_name_nocase) == 0)
1660                         {
1661                         if (g_strcmp0(di1->md5sum, di2->md5sum) == 0)
1662                                 {
1663                                 return DUPE_NAME_MATCH;
1664                                 }
1665                         }
1666                 else
1667                         {
1668                         return DUPE_NO_MATCH;
1669                         }
1670                 }
1671         if (mask & DUPE_MATCH_SIZE)
1672                 {
1673                 if (di1->fd->size != di2->fd->size)
1674                         {
1675                         return DUPE_NO_MATCH;
1676                         }
1677                 }
1678         if (mask & DUPE_MATCH_DATE)
1679                 {
1680                 if (di1->fd->date != di2->fd->date)
1681                         {
1682                         return DUPE_NO_MATCH;
1683                         }
1684                 }
1685         if (mask & DUPE_MATCH_SUM)
1686                 {
1687                 if (g_strcmp0(di1->md5sum, di2->md5sum) != 0)
1688                         {
1689                         return DUPE_NO_MATCH;
1690                         }
1691                 }
1692         if (mask & DUPE_MATCH_DIM)
1693                 {
1694                 if (di1->dimensions != di2->dimensions)
1695                         {
1696                         return DUPE_NO_MATCH;
1697                         }
1698                 }
1699
1700         return DUPE_MATCH;
1701 }
1702
1703 /**
1704  * @brief The callback for the binary search
1705  * @param a
1706  * @param b
1707  * @param param_match_mask
1708  * @returns negative/0/positive
1709  *
1710  * Is not used for similarity checks.
1711  *
1712  * Used only when two file sets are used.
1713  * Requires use of a global for param_match_mask because there is no
1714  * g_array_binary_search_with_data() function in glib.
1715  */
1716 static gint dupe_match_binary_search_cb(gconstpointer a, gconstpointer b)
1717 {
1718         auto di1 = *(static_cast<const DupeItem *const *>(a));
1719         auto di2 = static_cast<const DupeItem *>(b);
1720         DupeMatchType mask = param_match_mask;
1721
1722         if (mask & DUPE_MATCH_ALL)
1723                 {
1724                 return 0;
1725                 }
1726         if (mask & DUPE_MATCH_PATH)
1727                 {
1728                 return utf8_compare(di1->fd->path, di2->fd->path, TRUE);
1729                 }
1730         if (mask & DUPE_MATCH_NAME)
1731                 {
1732                 return g_strcmp0(di1->fd->collate_key_name, di2->fd->collate_key_name);
1733                 }
1734         if (mask & DUPE_MATCH_NAME_CI)
1735                 {
1736                 return strcmp(di1->fd->collate_key_name_nocase, di2->fd->collate_key_name_nocase);
1737                 }
1738         if (mask & DUPE_MATCH_NAME_CONTENT)
1739                 {
1740                 return g_strcmp0(di1->fd->collate_key_name, di2->fd->collate_key_name);
1741                 }
1742         if (mask & DUPE_MATCH_NAME_CI_CONTENT)
1743                 {
1744                 return strcmp(di1->fd->collate_key_name_nocase, di2->fd->collate_key_name_nocase);
1745                 }
1746         if (mask & DUPE_MATCH_SIZE)
1747                 {
1748                 return (di1->fd->size - di2->fd->size);
1749                 }
1750         if (mask & DUPE_MATCH_DATE)
1751                 {
1752                 return (di1->fd->date - di2->fd->date);
1753                 }
1754         if (mask & DUPE_MATCH_SUM)
1755                 {
1756                 return g_strcmp0(di1->md5sum, di2->md5sum);
1757                 }
1758         if (mask & DUPE_MATCH_DIM)
1759                 {
1760                 return (di1->dimensions - di2->dimensions);
1761                 }
1762
1763         return 0;
1764 }
1765
1766 /**
1767  * @brief The callback for the array sort
1768  * @param a
1769  * @param b
1770  * @param data
1771  * @returns negative/0/positive
1772  *
1773  * Is not used for similarity checks.
1774 */
1775 static gint dupe_match_sort_cb(gconstpointer a, gconstpointer b, gpointer data)
1776 {
1777         auto di1 = *(static_cast<const DupeItem *const *>(a));
1778         auto di2 = *(static_cast<const DupeItem *const *>(b));
1779         auto dw = static_cast<DupeWindow *>(data);
1780         DupeMatchType mask = dw->match_mask;
1781
1782         if (mask & DUPE_MATCH_ALL)
1783                 {
1784                 return 0;
1785                 }
1786         if (mask & DUPE_MATCH_PATH)
1787                 {
1788                 return utf8_compare(di1->fd->path, di2->fd->path, TRUE);
1789                 }
1790         if (mask & DUPE_MATCH_NAME)
1791                 {
1792                 return g_strcmp0(di1->fd->collate_key_name, di2->fd->collate_key_name);
1793                 }
1794         if (mask & DUPE_MATCH_NAME_CI)
1795                 {
1796                 return strcmp(di1->fd->collate_key_name_nocase, di2->fd->collate_key_name_nocase);
1797                 }
1798         if (mask & DUPE_MATCH_NAME_CONTENT)
1799                 {
1800                 return g_strcmp0(di1->fd->collate_key_name, di2->fd->collate_key_name);
1801                 }
1802         if (mask & DUPE_MATCH_NAME_CI_CONTENT)
1803                 {
1804                 return strcmp(di1->fd->collate_key_name_nocase, di2->fd->collate_key_name_nocase);
1805                 }
1806         if (mask & DUPE_MATCH_SIZE)
1807                 {
1808                 return (di1->fd->size - di2->fd->size);
1809                 }
1810         if (mask & DUPE_MATCH_DATE)
1811                 {
1812                 return (di1->fd->date - di2->fd->date);
1813                 }
1814         if (mask & DUPE_MATCH_SUM)
1815                 {
1816                 if (di1->md5sum[0] == '\0' || di2->md5sum[0] == '\0')
1817                     {
1818                         return -1;
1819                         }
1820                 else
1821                         {
1822                         return strcmp(di1->md5sum, di2->md5sum);
1823                         }
1824                 }
1825         if (mask & DUPE_MATCH_DIM)
1826                 {
1827                 if (!di1 || !di2 || !di1->width || !di1->height || !di2->width || !di2->height)
1828                         {
1829                         return -1;
1830                         }
1831                 return (di1->dimensions - di2->dimensions);
1832                 }
1833
1834         return 0; // should not execute
1835 }
1836
1837 /**
1838  * @brief Check for duplicate matches
1839  * @param dw
1840  *
1841  * Is not used for similarity checks.
1842  *
1843  * Loads the file sets into an array and sorts on the searched
1844  * for parameter.
1845  *
1846  * If one file set, steps down the array looking for adjacent equal values.
1847  *
1848  * If two file sets, steps down the first set and for each value
1849  * does a binary search for matches in the second set.
1850  */
1851 static void dupe_array_check(DupeWindow *dw )
1852 {
1853         GArray *array_set1;
1854         GArray *array_set2;
1855         GList *work;
1856         gint i_set1;
1857         gint i_set2;
1858         DUPE_CHECK_RESULT check_result;
1859         param_match_mask = dw->match_mask;
1860         guint out_match_index;
1861         gboolean match_found = FALSE;;
1862
1863         if (!dw->list) return;
1864
1865         array_set1 = g_array_new(TRUE, TRUE, sizeof(gpointer));
1866         array_set2 = g_array_new(TRUE, TRUE, sizeof(gpointer));
1867         dupe_match_reset_list(dw->list);
1868
1869         work = dw->list;
1870         while (work)
1871                 {
1872                 auto di = static_cast<DupeItem *>(work->data);
1873                 g_array_append_val(array_set1, di);
1874                 work = work->next;
1875                 }
1876
1877         g_array_sort_with_data(array_set1, dupe_match_sort_cb, dw);
1878
1879         if (dw->second_set)
1880                 {
1881                 /* Two sets - nothing can be done until a second set is loaded */
1882                 if (dw->second_list)
1883                         {
1884                         work = dw->second_list;
1885                         while (work)
1886                                 {
1887                                 g_array_append_val(array_set2, (work->data));
1888                                 work = work->next;
1889                                 }
1890                         g_array_sort_with_data(array_set2, dupe_match_sort_cb, dw);
1891
1892                         for (i_set1 = 0; i_set1 <= static_cast<gint>(array_set1->len) - 1; i_set1++)
1893                                 {
1894                                 auto di1 = static_cast<DupeItem *>(g_array_index(array_set1, gpointer, i_set1));
1895                                 DupeItem *di2 = nullptr;
1896                                 /* If multiple identical entries in set 1, use the last one */
1897                                 if (i_set1 < static_cast<gint>(array_set1->len) - 2)
1898                                         {
1899                                         di2 = static_cast<DupeItem *>(g_array_index(array_set1, gpointer, i_set1 + 1));
1900                                         check_result = dupe_match_check(di1, di2, dw);
1901                                         if (check_result == DUPE_MATCH || check_result == DUPE_NAME_MATCH)
1902                                                 {
1903                                                 continue;
1904                                                 }
1905                                         }
1906
1907 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION >= 62))
1908                                 match_found = g_array_binary_search(array_set2, di1, dupe_match_binary_search_cb, &out_match_index);
1909 #else
1910                                 gint i;
1911
1912                                 match_found = FALSE;
1913                                 for(i=0; i < array_set2->len; i++)
1914                                         {
1915                                         di2 = static_cast<DupeItem *>(g_array_index(array_set2,  gpointer, i));
1916                                         check_result = dupe_match_check(di1, di2, dw);
1917                                         if (check_result == DUPE_MATCH)
1918                                                 {
1919                                                 match_found = TRUE;
1920                                                 out_match_index = i;
1921                                                 break;
1922                                                 }
1923                                         }
1924 #endif
1925
1926                                 if (match_found)
1927                                         {
1928                                         di2 = static_cast<DupeItem *>(g_array_index(array_set2, gpointer, out_match_index));
1929
1930                                         check_result = dupe_match_check(di1, di2, dw);
1931                                         if (check_result == DUPE_MATCH || check_result == DUPE_NAME_MATCH)
1932                                                 {
1933                                                 if (check_result == DUPE_MATCH)
1934                                                         {
1935                                                         dupe_match_link(di2, di1, 0.0);
1936                                                         }
1937                                                 i_set2 = out_match_index + 1;
1938
1939                                                 if (i_set2 > static_cast<gint>(array_set2->len) - 1)
1940                                                         {
1941                                                         break;
1942                                                         }
1943                                                 /* Look for multiple matches in set 2 for item di1 */
1944                                                 di2 = static_cast<DupeItem *>(g_array_index(array_set2, gpointer, i_set2));
1945                                                 check_result = dupe_match_check(di1, di2, dw);
1946                                                 while (check_result == DUPE_MATCH || check_result == DUPE_NAME_MATCH)
1947                                                         {
1948                                                         if (check_result == DUPE_MATCH)
1949                                                                 {
1950                                                                 dupe_match_link(di2, di1, 0.0);
1951                                                                 }
1952                                                         i_set2++;
1953                                                         if (i_set2 > static_cast<gint>(array_set2->len) - 1)
1954                                                                 {
1955                                                                 break;
1956                                                                 }
1957                                                         di2 = static_cast<DupeItem *>(g_array_index(array_set2, gpointer, i_set2));
1958                                                         check_result = dupe_match_check(di1, di2, dw);
1959                                                         }
1960                                                 }
1961                                         }
1962                                 }
1963                         }
1964                 }
1965         else
1966                 {
1967                 /* File set 1 only */
1968                 g_list_free(dw->dupes);
1969                 dw->dupes = nullptr;
1970
1971                 if (static_cast<gint>(array_set1->len) > 1)
1972                         {
1973                         for (i_set1 = 0; i_set1 <= static_cast<gint>(array_set1->len) - 2; i_set1++)
1974                                 {
1975                                 auto di1 = static_cast<DupeItem *>(g_array_index(array_set1, gpointer, i_set1));
1976                                 auto di2 = static_cast<DupeItem *>(g_array_index(array_set1, gpointer, i_set1 + 1));
1977
1978                                 check_result = dupe_match_check(di1, di2, dw);
1979                                 if (check_result == DUPE_MATCH || check_result == DUPE_NAME_MATCH)
1980                                         {
1981                                         if (check_result == DUPE_MATCH)
1982                                                 {
1983                                                 dupe_match_link(di2, di1, 0.0);
1984                                                 }
1985                                         i_set1++;
1986
1987                                         if ( i_set1 + 1 > static_cast<gint>(array_set1->len) - 1)
1988                                                 {
1989                                                 break;
1990                                                 }
1991                                         /* Look for multiple matches for item di1 */
1992                                         di2 = static_cast<DupeItem *>(g_array_index(array_set1, gpointer, i_set1 + 1));
1993                                         check_result = dupe_match_check(di1, di2, dw);
1994                                         while (check_result == DUPE_MATCH || check_result == DUPE_NAME_MATCH)
1995                                                 {
1996                                                 if (check_result == DUPE_MATCH)
1997                                                         {
1998                                                         dupe_match_link(di2, di1, 0.0);
1999                                                         }
2000                                                 i_set1++;
2001
2002                                                 if (i_set1 + 1 > static_cast<gint>(array_set1->len) - 1)
2003                                                         {
2004                                                         break;
2005                                                         }
2006                                                 di2 = static_cast<DupeItem *>(g_array_index(array_set1, gpointer, i_set1 + 1));
2007                                                 check_result = dupe_match_check(di1, di2, dw);
2008                                                 }
2009                                         }
2010                                 }
2011                         }
2012                 }
2013         g_array_free(array_set1, TRUE);
2014         g_array_free(array_set2, TRUE);
2015 }
2016
2017 /**
2018  * @brief Look for similarity match
2019  * @param dw
2020  * @param needle
2021  * @param start
2022  *
2023  * Only used for similarity checks.\n
2024  * Called from dupe_check_cb.
2025  * Called for each entry in the list.
2026  * Steps through the list looking for matches against needle.
2027  * Pushes a #DupeQueueItem onto thread pool queue.
2028  */
2029 static void dupe_list_check_match(DupeWindow *dw, DupeItem *needle, GList *start)
2030 {
2031         GList *work;
2032         DupeQueueItem *dqi;
2033
2034         if (dw->second_set)
2035                 {
2036                 work = dw->second_list;
2037                 }
2038         else if (start)
2039                 {
2040                 work = start;
2041                 }
2042         else
2043                 {
2044                 work = g_list_last(dw->list);
2045                 }
2046
2047         dqi = g_new0(DupeQueueItem, 1);
2048         dqi->needle = needle;
2049         dqi->dw = dw;
2050         dqi->work = work;
2051         dqi->index = dw->queue_count;
2052         g_thread_pool_push(dw->dupe_comparison_thread_pool, dqi, nullptr);
2053 }
2054
2055 /*
2056  * ------------------------------------------------------------------
2057  * Thumbnail handling
2058  * ------------------------------------------------------------------
2059  */
2060
2061 static void dupe_listview_set_thumb(DupeWindow *dw, DupeItem *di, GtkTreeIter *iter)
2062 {
2063         GtkListStore *store;
2064         GtkTreeIter iter_n;
2065
2066         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
2067         if (!iter)
2068                 {
2069                 if (dupe_listview_find_item(store, di, &iter_n) >= 0)
2070                         {
2071                         iter = &iter_n;
2072                         }
2073                 }
2074
2075         if (iter) gtk_list_store_set(store, iter, DUPE_COLUMN_THUMB, di->pixbuf, -1);
2076 }
2077
2078 static void dupe_thumb_do(DupeWindow *dw)
2079 {
2080         DupeItem *di;
2081
2082         if (!dw->thumb_loader || !dw->thumb_item) return;
2083         di = dw->thumb_item;
2084
2085         if (di->pixbuf) g_object_unref(di->pixbuf);
2086         di->pixbuf = thumb_loader_get_pixbuf(dw->thumb_loader);
2087
2088         dupe_listview_set_thumb(dw, di, nullptr);
2089 }
2090
2091 static void dupe_thumb_error_cb(ThumbLoader *, gpointer data)
2092 {
2093         auto dw = static_cast<DupeWindow *>(data);
2094
2095         dupe_thumb_do(dw);
2096         dupe_thumb_step(dw);
2097 }
2098
2099 static void dupe_thumb_done_cb(ThumbLoader *, gpointer data)
2100 {
2101         auto dw = static_cast<DupeWindow *>(data);
2102
2103         dupe_thumb_do(dw);
2104         dupe_thumb_step(dw);
2105 }
2106
2107 static void dupe_thumb_step(DupeWindow *dw)
2108 {
2109         GtkTreeModel *store;
2110         GtkTreeIter iter;
2111         DupeItem *di = nullptr;
2112         gboolean valid;
2113         gint row = 0;
2114         gint length = 0;
2115
2116         store = gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview));
2117         valid = gtk_tree_model_get_iter_first(store, &iter);
2118
2119         while (!di && valid)
2120                 {
2121                 GdkPixbuf *pixbuf;
2122
2123                 length++;
2124                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, DUPE_COLUMN_THUMB, &pixbuf, -1);
2125                 if (pixbuf || di->pixbuf)
2126                         {
2127                         if (!pixbuf) gtk_list_store_set(GTK_LIST_STORE(store), &iter, DUPE_COLUMN_THUMB, di->pixbuf, -1);
2128                         row++;
2129                         di = nullptr;
2130                         }
2131                 valid = gtk_tree_model_iter_next(store, &iter);
2132                 }
2133         if (valid)
2134                 {
2135                 while (gtk_tree_model_iter_next(store, &iter)) length++;
2136                 }
2137
2138         if (!di)
2139                 {
2140                 dw->thumb_item = nullptr;
2141                 thumb_loader_free(dw->thumb_loader);
2142                 dw->thumb_loader = nullptr;
2143
2144                 dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
2145                 return;
2146                 }
2147
2148         dupe_window_update_progress(dw, _("Loading thumbs..."),
2149                                     length == 0 ? 0.0 : static_cast<gdouble>(row) / length, FALSE);
2150
2151         dw->thumb_item = di;
2152         thumb_loader_free(dw->thumb_loader);
2153         dw->thumb_loader = thumb_loader_new(options->thumbnails.max_width, options->thumbnails.max_height);
2154
2155         thumb_loader_set_callbacks(dw->thumb_loader,
2156                                    dupe_thumb_done_cb,
2157                                    dupe_thumb_error_cb,
2158                                    nullptr,
2159                                    dw);
2160
2161         /* start it */
2162         if (!thumb_loader_start(dw->thumb_loader, di->fd))
2163                 {
2164                 /* error, handle it, do next */
2165                 DEBUG_1("error loading thumb for %s", di->fd->path);
2166                 dupe_thumb_do(dw);
2167                 dupe_thumb_step(dw);
2168                 }
2169 }
2170
2171 /*
2172  * ------------------------------------------------------------------
2173  * Dupe checking loop
2174  * ------------------------------------------------------------------
2175  */
2176
2177 static void dupe_check_stop(DupeWindow *dw)
2178 {
2179         if (dw->idle_id > 0)
2180                 {
2181                 g_source_remove(dw->idle_id);
2182                 dw->idle_id = 0;
2183                 }
2184
2185         dw->abort = TRUE;
2186
2187         while (dw->thread_count < dw->queue_count) // Wait for the queue to empty
2188                 {
2189                 dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
2190                 widget_set_cursor(dw->listview, -1);
2191                 }
2192
2193         g_list_free(dw->search_matches);
2194         dw->search_matches = nullptr;
2195
2196         if (dw->idle_id || dw->img_loader || dw->thumb_loader)
2197                 {
2198                 if (dw->idle_id > 0)
2199                         {
2200                         g_source_remove(dw->idle_id);
2201                         dw->idle_id = 0;
2202                         }
2203                 dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
2204                 widget_set_cursor(dw->listview, -1);
2205                 }
2206
2207         if (dw->add_files_queue_id)
2208                 {
2209                 g_source_remove(dw->add_files_queue_id);
2210                 dw->add_files_queue_id = 0;
2211                 dupe_destroy_list_cache(dw);
2212                 gtk_widget_set_sensitive(dw->controls_box, TRUE);
2213                 if (g_list_length(dw->add_files_queue) > 0)
2214                         {
2215                         filelist_free(dw->add_files_queue);
2216                         }
2217                 dw->add_files_queue = nullptr;
2218                 dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
2219                 widget_set_cursor(dw->listview, -1);
2220                 }
2221
2222         thumb_loader_free(dw->thumb_loader);
2223         dw->thumb_loader = nullptr;
2224
2225         image_loader_free(dw->img_loader);
2226         dw->img_loader = nullptr;
2227 }
2228
2229 static void dupe_check_stop_cb(GtkWidget *, gpointer data)
2230 {
2231         auto dw = static_cast<DupeWindow *>(data);
2232
2233         dupe_check_stop(dw);
2234 }
2235
2236 static void dupe_loader_done_cb(ImageLoader *il, gpointer data)
2237 {
2238         auto dw = static_cast<DupeWindow *>(data);
2239         GdkPixbuf *pixbuf;
2240
2241         pixbuf = image_loader_get_pixbuf(il);
2242
2243         if (dw->setup_point)
2244                 {
2245                 auto di = static_cast<DupeItem *>(dw->setup_point->data);
2246
2247                 if (!di->simd)
2248                         {
2249                         di->simd = image_sim_new_from_pixbuf(pixbuf);
2250                         }
2251                 else
2252                         {
2253                         image_sim_fill_data(di->simd, pixbuf);
2254                         }
2255
2256                 if (di->width == 0 && di->height == 0)
2257                         {
2258                         di->width = gdk_pixbuf_get_width(pixbuf);
2259                         di->height = gdk_pixbuf_get_height(pixbuf);
2260                         }
2261                 if (options->thumbnails.enable_caching)
2262                         {
2263                         dupe_item_write_cache(di);
2264                         }
2265
2266                 image_sim_alternate_processing(di->simd);
2267                 }
2268
2269         image_loader_free(dw->img_loader);
2270         dw->img_loader = nullptr;
2271
2272         dw->idle_id = g_idle_add(dupe_check_cb, dw);
2273 }
2274
2275 static void dupe_setup_reset(DupeWindow *dw)
2276 {
2277         dw->setup_point = nullptr;
2278         dw->setup_n = 0;
2279         dw->setup_time = msec_time();
2280         dw->setup_time_count = 0;
2281 }
2282
2283 static GList *dupe_setup_point_step(DupeWindow *dw, GList *p)
2284 {
2285         if (!p) return nullptr;
2286
2287         if (p->next) return p->next;
2288
2289         if (dw->second_set && g_list_first(p) == dw->list) return dw->second_list;
2290
2291         return nullptr;
2292 }
2293
2294 /**
2295  * @brief Generates the sumcheck or dimensions
2296  * @param list Set1 or set2
2297  * @returns TRUE/FALSE = not completed/completed
2298  *
2299  * Ensures that the DIs contain the MD5SUM or dimensions for all items in
2300  * the list. One item at a time. Re-enters if not completed.
2301  */
2302 static gboolean create_checksums_dimensions(DupeWindow *dw, GList *list)
2303 {
2304                 if ((dw->match_mask & DUPE_MATCH_SUM) ||
2305                         (dw->match_mask & DUPE_MATCH_NAME_CONTENT) ||
2306                         (dw->match_mask & DUPE_MATCH_NAME_CI_CONTENT))
2307                         {
2308                         /* MD5SUM only */
2309                         if (!dw->setup_point) dw->setup_point = list; // setup_point clear on 1st entry
2310
2311                         while (dw->setup_point)
2312                                 {
2313                                 auto di = static_cast<DupeItem *>(dw->setup_point->data);
2314
2315                                 dw->setup_point = dupe_setup_point_step(dw, dw->setup_point);
2316                                 dw->setup_n++;
2317
2318                                 if (!di->md5sum)
2319                                         {
2320                                         dupe_window_update_progress(dw, _("Reading checksums..."),
2321                                                 dw->setup_count == 0 ? 0.0 : static_cast<gdouble>(dw->setup_n - 1) / dw->setup_count, FALSE);
2322
2323                                         if (options->thumbnails.enable_caching)
2324                                                 {
2325                                                 dupe_item_read_cache(di);
2326                                                 if (di->md5sum)
2327                                                         {
2328                                                         return TRUE;
2329                                                         }
2330                                                 }
2331
2332                                         di->md5sum = md5_text_from_file_utf8(di->fd->path, "");
2333                                         if (options->thumbnails.enable_caching)
2334                                                 {
2335                                                 dupe_item_write_cache(di);
2336                                                 }
2337                                         return TRUE;
2338                                         }
2339                                 }
2340                         dupe_setup_reset(dw);
2341                         }
2342
2343                 if ((dw->match_mask & DUPE_MATCH_DIM)  )
2344                         {
2345                         /* Dimensions only */
2346                         if (!dw->setup_point) dw->setup_point = list;
2347
2348                         while (dw->setup_point)
2349                                 {
2350                                 auto di = static_cast<DupeItem *>(dw->setup_point->data);
2351
2352                                 dw->setup_point = dupe_setup_point_step(dw, dw->setup_point);
2353                                 dw->setup_n++;
2354                                 if (di->width == 0 && di->height == 0)
2355                                         {
2356                                         dupe_window_update_progress(dw, _("Reading dimensions..."),
2357                                                 dw->setup_count == 0 ? 0.0 : static_cast<gdouble>(dw->setup_n - 1) / dw->setup_count, FALSE);
2358
2359                                         if (options->thumbnails.enable_caching)
2360                                                 {
2361                                                 dupe_item_read_cache(di);
2362                                                 if (di->width != 0 || di->height != 0)
2363                                                         {
2364                                                         return TRUE;
2365                                                         }
2366                                                 }
2367
2368                                         image_load_dimensions(di->fd, &di->width, &di->height);
2369                                         di->dimensions = (di->width << 16) + di->height;
2370                                         if (options->thumbnails.enable_caching)
2371                                                 {
2372                                                 dupe_item_write_cache(di);
2373                                                 }
2374                                         return TRUE;
2375                                         }
2376                                 }
2377                         dupe_setup_reset(dw);
2378                         }
2379
2380         return FALSE;
2381 }
2382
2383 /**
2384  * @brief Compare func. for sorting search matches
2385  * @param a #DupeSearchMatch
2386  * @param b #DupeSearchMatch
2387  * @returns
2388  *
2389  * Used only for similarity checks\n
2390  * Sorts search matches on order they were inserted into the pool queue
2391  */
2392 static gint sort_func(gconstpointer a, gconstpointer b)
2393 {
2394         return static_cast<const DupeSearchMatch *>(a)->index - static_cast<const DupeSearchMatch *>(b)->index;
2395 }
2396
2397 /**
2398  * @brief Check set 1 (and set 2) for matches
2399  * @param data DupeWindow
2400  * @returns TRUE/FALSE = not completed/completed
2401  *
2402  * Initiated from start, loader done and item remove
2403  *
2404  * On first entry generates di->MD5SUM, di->dimensions and sim data,
2405  * and updates the cache.
2406  */
2407 static gboolean dupe_check_cb(gpointer data)
2408 {
2409         auto dw = static_cast<DupeWindow *>(data);
2410         DupeSearchMatch *search_match_list_item;
2411
2412         if (!dw->idle_id)
2413                 {
2414                 return G_SOURCE_REMOVE;
2415                 }
2416
2417         if (!dw->setup_done) /* Clear on 1st entry */
2418                 {
2419                 if (dw->list)
2420                         {
2421                         if (create_checksums_dimensions(dw, dw->list))
2422                                 {
2423                                 return G_SOURCE_CONTINUE;
2424                                 }
2425                         }
2426                 if (dw->second_list)
2427                         {
2428                         if (create_checksums_dimensions(dw, dw->second_list))
2429                                 {
2430                                 return G_SOURCE_CONTINUE;
2431                                 }
2432                         }
2433                 if ((dw->match_mask & DUPE_MATCH_SIM_HIGH ||
2434                      dw->match_mask & DUPE_MATCH_SIM_MED ||
2435                      dw->match_mask & DUPE_MATCH_SIM_LOW ||
2436                      dw->match_mask & DUPE_MATCH_SIM_CUSTOM) &&
2437                     !(dw->setup_mask & DUPE_MATCH_SIM_MED) )
2438                         {
2439                         /* Similarity only */
2440                         if (!dw->setup_point) dw->setup_point = dw->list;
2441
2442                         while (dw->setup_point)
2443                                 {
2444                                 auto di = static_cast<DupeItem *>(dw->setup_point->data);
2445
2446                                 if (!di->simd)
2447                                         {
2448                                         dupe_window_update_progress(dw, _("Reading similarity data..."),
2449                                                 dw->setup_count == 0 ? 0.0 : static_cast<gdouble>(dw->setup_n) / dw->setup_count, FALSE);
2450
2451                                         if (options->thumbnails.enable_caching)
2452                                                 {
2453                                                 dupe_item_read_cache(di);
2454                                                 if (cache_sim_data_filled(di->simd))
2455                                                         {
2456                                                         image_sim_alternate_processing(di->simd);
2457                                                         return G_SOURCE_CONTINUE;
2458                                                         }
2459                                                 }
2460
2461                                         dw->img_loader = image_loader_new(di->fd);
2462                                         image_loader_set_buffer_size(dw->img_loader, 8);
2463                                         g_signal_connect(G_OBJECT(dw->img_loader), "error", (GCallback)dupe_loader_done_cb, dw);
2464                                         g_signal_connect(G_OBJECT(dw->img_loader), "done", (GCallback)dupe_loader_done_cb, dw);
2465
2466                                         if (!image_loader_start(dw->img_loader))
2467                                                 {
2468                                                 image_sim_free(di->simd);
2469                                                 di->simd = image_sim_new();
2470                                                 image_loader_free(dw->img_loader);
2471                                                 dw->img_loader = nullptr;
2472                                                 return G_SOURCE_CONTINUE;
2473                                                 }
2474                                         dw->idle_id = 0;
2475                                         return G_SOURCE_REMOVE;
2476                                         }
2477
2478                                 dw->setup_point = dupe_setup_point_step(dw, dw->setup_point);
2479                                 dw->setup_n++;
2480                                 }
2481                         dw->setup_mask = static_cast<DupeMatchType>(dw->setup_mask | DUPE_MATCH_SIM_MED);
2482                         dupe_setup_reset(dw);
2483                         }
2484
2485                 /* End of setup not done */
2486                 dupe_window_update_progress(dw, _("Comparing..."), 0.0, FALSE);
2487                 dw->setup_done = TRUE;
2488                 dupe_setup_reset(dw);
2489                 dw->setup_count = g_list_length(dw->list);
2490                 }
2491
2492         /* Setup done - dw->working set to NULL below
2493          * Set before 1st entry: dw->working = g_list_last(dw->list)
2494          * Set before 1st entry: dw->setup_count = g_list_length(dw->list)
2495          */
2496         if (!dw->working)
2497                 {
2498                 /* Similarity check threads may still be running */
2499                 if (dw->setup_count > 0 && (dw->match_mask == DUPE_MATCH_SIM_HIGH ||
2500                         dw->match_mask == DUPE_MATCH_SIM_MED ||
2501                         dw->match_mask == DUPE_MATCH_SIM_LOW ||
2502                         dw->match_mask == DUPE_MATCH_SIM_CUSTOM))
2503                         {
2504                         if( dw->thread_count < dw->queue_count)
2505                                 {
2506                                 dupe_window_update_progress(dw, _("Comparing..."), 0.0, FALSE);
2507
2508                                 return G_SOURCE_CONTINUE;
2509                                 }
2510
2511                         if (dw->search_matches_sorted == nullptr)
2512                                 {
2513                                 dw->search_matches_sorted = g_list_sort(dw->search_matches, sort_func);
2514                                 dupe_setup_reset(dw);
2515                                 }
2516
2517                         while (dw->search_matches_sorted)
2518                                 {
2519                                 dw->setup_n++;
2520                                 dupe_window_update_progress(dw, _("Sorting..."), 0.0, FALSE);
2521                                 search_match_list_item = static_cast<DupeSearchMatch *>(dw->search_matches_sorted->data);
2522
2523                                 if (!dupe_match_link_exists(search_match_list_item->a, search_match_list_item->b))
2524                                         {
2525                                         dupe_match_link(search_match_list_item->a, search_match_list_item->b, search_match_list_item->rank);
2526                                         }
2527
2528                                 dw->search_matches_sorted = dw->search_matches_sorted->next;
2529
2530                                 if (dw->search_matches_sorted != nullptr)
2531                                         {
2532                                         return G_SOURCE_CONTINUE;
2533                                         }
2534                                 }
2535                         g_list_free(dw->search_matches);
2536                         dw->search_matches = nullptr;
2537                         g_list_free(dw->search_matches_sorted);
2538                         dw->search_matches_sorted = nullptr;
2539                         dw->setup_count = 0;
2540                         }
2541                 else
2542                         {
2543                         if (dw->setup_count > 0)
2544                                 {
2545                                 dw->setup_count = 0;
2546                                 dupe_window_update_progress(dw, _("Sorting..."), 1.0, TRUE);
2547                                 return G_SOURCE_CONTINUE;
2548                                 }
2549                         }
2550
2551                 dw->idle_id = 0;
2552                 dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
2553
2554                 dupe_match_rank(dw);
2555                 dupe_window_update_count(dw, FALSE);
2556
2557                 dupe_listview_populate(dw);
2558
2559                 /* check thumbs */
2560                 if (dw->show_thumbs) dupe_thumb_step(dw);
2561
2562                 widget_set_cursor(dw->listview, -1);
2563
2564                 return G_SOURCE_REMOVE;
2565                 /* The end */
2566                 }
2567
2568         /* Setup done - working */
2569         if (dw->match_mask == DUPE_MATCH_SIM_HIGH ||
2570                 dw->match_mask == DUPE_MATCH_SIM_MED ||
2571                 dw->match_mask == DUPE_MATCH_SIM_LOW ||
2572                 dw->match_mask == DUPE_MATCH_SIM_CUSTOM)
2573                 {
2574                 /* This is the similarity comparison */
2575                 dupe_list_check_match(dw, static_cast<DupeItem *>(dw->working->data), dw->working);
2576                 dupe_window_update_progress(dw, _("Queuing..."), dw->setup_count == 0 ? 0.0 : static_cast<gdouble>(dw->setup_n) / dw->setup_count, FALSE);
2577                 dw->setup_n++;
2578                 dw->queue_count++;
2579
2580                 dw->working = dw->working->prev; /* Is NULL when complete */
2581                 }
2582         else
2583                 {
2584                 /* This is the comparison for all other parameters.
2585                  * dupe_array_check() processes the entire list in one go
2586                 */
2587                 dw->working = nullptr;
2588                 dupe_window_update_progress(dw, _("Comparing..."), 0.0, FALSE);
2589                 dupe_array_check(dw);
2590                 }
2591
2592         return G_SOURCE_CONTINUE;
2593 }
2594
2595 static void dupe_check_start(DupeWindow *dw)
2596 {
2597         dw->setup_done = FALSE;
2598
2599         dw->setup_count = g_list_length(dw->list);
2600         if (dw->second_set) dw->setup_count += g_list_length(dw->second_list);
2601
2602         dw->setup_mask = DUPE_MATCH_NONE;
2603         dupe_setup_reset(dw);
2604
2605         dw->working = g_list_last(dw->list);
2606
2607         dupe_window_update_count(dw, TRUE);
2608         widget_set_cursor(dw->listview, GDK_WATCH);
2609         dw->queue_count = 0;
2610         dw->thread_count = 0;
2611         dw->search_matches_sorted = nullptr;
2612         dw->abort = FALSE;
2613
2614         if (dw->idle_id) return;
2615
2616         dw->idle_id = g_idle_add(dupe_check_cb, dw);
2617 }
2618
2619 static gboolean dupe_check_start_cb(gpointer data)
2620 {
2621         auto dw = static_cast<DupeWindow *>(data);
2622
2623         dupe_check_start(dw);
2624
2625         return FALSE;
2626 }
2627
2628 /*
2629  * ------------------------------------------------------------------
2630  * Item addition, removal
2631  * ------------------------------------------------------------------
2632  */
2633
2634 static void dupe_item_remove(DupeWindow *dw, DupeItem *di)
2635 {
2636         if (!di) return;
2637
2638         /* handle things that may be in progress... */
2639         if (dw->working && dw->working->data == di)
2640                 {
2641                 dw->working = dw->working->prev;
2642                 }
2643         if (dw->thumb_loader && dw->thumb_item == di)
2644                 {
2645                 dupe_thumb_step(dw);
2646                 }
2647         if (dw->setup_point && dw->setup_point->data == di)
2648                 {
2649                 dw->setup_point = dupe_setup_point_step(dw, dw->setup_point);
2650                 if (dw->img_loader)
2651                         {
2652                         image_loader_free(dw->img_loader);
2653                         dw->img_loader = nullptr;
2654                         dw->idle_id = g_idle_add(dupe_check_cb, dw);
2655                         }
2656                 }
2657
2658         if (di->group && dw->dupes)
2659                 {
2660                 /* is a dupe, must remove from group/reset children if a parent */
2661                 DupeItem *parent;
2662
2663                 parent = dupe_match_find_parent(dw, di);
2664                 if (di == parent)
2665                         {
2666                         if (g_list_length(parent->group) < 2)
2667                                 {
2668                                 DupeItem *child;
2669
2670                                 child = dupe_match_highest_rank(parent);
2671                                 dupe_match_link_clear(child, TRUE);
2672                                 dupe_listview_remove(dw, child);
2673
2674                                 dupe_match_link_clear(parent, TRUE);
2675                                 dupe_listview_remove(dw, parent);
2676                                 dw->dupes = g_list_remove(dw->dupes, parent);
2677                                 }
2678                         else
2679                                 {
2680                                 DupeItem *new_parent;
2681                                 DupeMatch *dm;
2682
2683                                 dm = static_cast<DupeMatch *>(parent->group->data);
2684                                 new_parent = dm->di;
2685                                 dupe_match_reparent(dw, parent, new_parent);
2686                                 dupe_listview_remove(dw, parent);
2687                                 }
2688                         }
2689                 else
2690                         {
2691                         if (g_list_length(parent->group) < 2)
2692                                 {
2693                                 dupe_match_link_clear(parent, TRUE);
2694                                 dupe_listview_remove(dw, parent);
2695                                 dw->dupes = g_list_remove(dw->dupes, parent);
2696                                 }
2697                         dupe_match_link_clear(di, TRUE);
2698                         dupe_listview_remove(dw, di);
2699                         }
2700                 }
2701         else
2702                 {
2703                 /* not a dupe, or not sorted yet, simply reset */
2704                 dupe_match_link_clear(di, TRUE);
2705                 }
2706
2707         if (dw->second_list && g_list_find(dw->second_list, di))
2708                 {
2709                 dupe_second_remove(dw, di);
2710                 }
2711         else
2712                 {
2713                 dw->list = g_list_remove(dw->list, di);
2714                 }
2715         dupe_item_free(di);
2716
2717         dupe_window_update_count(dw, FALSE);
2718 }
2719
2720 #pragma GCC diagnostic push
2721 #pragma GCC diagnostic ignored "-Wunused-function"
2722 static gboolean dupe_item_remove_by_path_unused(DupeWindow *dw, const gchar *path)
2723 {
2724         DupeItem *di;
2725
2726         di = dupe_item_find_path_unused(dw, path);
2727         if (!di) return FALSE;
2728
2729         dupe_item_remove(dw, di);
2730
2731         return TRUE;
2732 }
2733 #pragma GCC diagnostic pop
2734
2735 static gboolean dupe_files_add_queue_cb(gpointer data)
2736 {
2737         DupeItem *di = nullptr;
2738         auto dw = static_cast<DupeWindow *>(data);
2739         FileData *fd;
2740         GList *queue = dw->add_files_queue;
2741
2742         gtk_progress_bar_pulse(GTK_PROGRESS_BAR(dw->extra_label));
2743
2744         if (queue == nullptr)
2745                 {
2746                 dw->add_files_queue_id = 0;
2747                 dupe_destroy_list_cache(dw);
2748                 g_idle_add(dupe_check_start_cb, dw);
2749                 gtk_widget_set_sensitive(dw->controls_box, TRUE);
2750                 return FALSE;
2751                 }
2752
2753         fd = static_cast<FileData *>(queue->data);
2754         if (fd)
2755                 {
2756                 if (isfile(fd->path))
2757                         {
2758                         di = dupe_item_new(fd);
2759                         }
2760                 else if (isdir(fd->path))
2761                         {
2762                         GList *f, *d;
2763                         dw->add_files_queue = g_list_remove(dw->add_files_queue, g_list_first(dw->add_files_queue)->data);
2764
2765                         if (filelist_read(fd, &f, &d))
2766                                 {
2767                                 f = filelist_filter(f, FALSE);
2768                                 d = filelist_filter(d, TRUE);
2769
2770                                 dw->add_files_queue = g_list_concat(f, dw->add_files_queue);
2771                                 dw->add_files_queue = g_list_concat(d, dw->add_files_queue);
2772                                 }
2773                         }
2774                 else
2775                         {
2776                         /* Not a file and not a dir */
2777                         dw->add_files_queue = g_list_remove(dw->add_files_queue, g_list_first(dw->add_files_queue)->data);
2778                         }
2779                 }
2780
2781         if (!di)
2782                 {
2783                 /* A dir was found. Process the contents on next entry */
2784                 return TRUE;
2785                 }
2786
2787         dw->add_files_queue = g_list_remove(dw->add_files_queue, g_list_first(dw->add_files_queue)->data);
2788
2789         dupe_item_read_cache(di);
2790
2791         /* Ensure images in the lists have unique FileDatas */
2792         if (!dupe_insert_in_list_cache(dw, di->fd))
2793                 {
2794                 dupe_item_free(di);
2795                 return TRUE;
2796                 }
2797
2798         if (dw->second_drop)
2799                 {
2800                 dupe_second_add(dw, di);
2801                 }
2802         else
2803                 {
2804                 dw->list = g_list_prepend(dw->list, di);
2805                 }
2806
2807         if (dw->add_files_queue != nullptr)
2808                 {
2809                 return TRUE;
2810                 }
2811         else
2812                 {
2813                 dw->add_files_queue_id = 0;
2814                 dupe_destroy_list_cache(dw);
2815                 g_idle_add(dupe_check_start_cb, dw);
2816                 gtk_widget_set_sensitive(dw->controls_box, TRUE);
2817                 return FALSE;
2818                 }
2819 }
2820
2821 static void dupe_files_add(DupeWindow *dw, CollectionData *, CollectInfo *info,
2822                            FileData *fd, gboolean recurse)
2823 {
2824         DupeItem *di = nullptr;
2825
2826         if (info)
2827                 {
2828                 di = dupe_item_new(info->fd);
2829                 }
2830         else if (fd)
2831                 {
2832                 if (isfile(fd->path) && !g_file_test(fd->path, G_FILE_TEST_IS_SYMLINK))
2833                         {
2834                         di = dupe_item_new(fd);
2835                         }
2836                 else if (isdir(fd->path) && recurse)
2837                         {
2838                         GList *f, *d;
2839                         if (filelist_read(fd, &f, &d))
2840                                 {
2841                                 GList *work;
2842
2843                                 f = filelist_filter(f, FALSE);
2844                                 d = filelist_filter(d, TRUE);
2845
2846                                 work = f;
2847                                 while (work)
2848                                         {
2849                                         dupe_files_add(dw, nullptr, nullptr, static_cast<FileData *>(work->data), TRUE);
2850                                         work = work->next;
2851                                         }
2852                                 filelist_free(f);
2853                                 work = d;
2854                                 while (work)
2855                                         {
2856                                         dupe_files_add(dw, nullptr, nullptr, static_cast<FileData *>(work->data), TRUE);
2857                                         work = work->next;
2858                                         }
2859                                 filelist_free(d);
2860                                 }
2861                         }
2862                 }
2863
2864         if (!di) return;
2865
2866         dupe_item_read_cache(di);
2867
2868         /* Ensure images in the lists have unique FileDatas */
2869         GList *work;
2870         DupeItem *di_list;
2871         work = g_list_first(dw->list);
2872         while (work)
2873                 {
2874                 di_list = static_cast<DupeItem *>(work->data);
2875                 if (di_list->fd == di->fd)
2876                         {
2877                         return;
2878                         }
2879                 else
2880                         {
2881                         work = work->next;
2882                         }
2883                 }
2884
2885         if (dw->second_list)
2886                 {
2887                 work = g_list_first(dw->second_list);
2888                 while (work)
2889                         {
2890                         di_list = static_cast<DupeItem *>(work->data);
2891                         if (di_list->fd == di->fd)
2892                                 {
2893                                 return;
2894                                 }
2895                         else
2896                                 {
2897                                 work = work->next;
2898                                 }
2899                         }
2900                 }
2901
2902         if (dw->second_drop)
2903                 {
2904                 dupe_second_add(dw, di);
2905                 }
2906         else
2907                 {
2908                 dw->list = g_list_prepend(dw->list, di);
2909                 }
2910 }
2911
2912 static void dupe_init_list_cache(DupeWindow *dw)
2913 {
2914         dw->list_cache = g_hash_table_new(g_direct_hash, g_direct_equal);
2915         dw->second_list_cache = g_hash_table_new(g_direct_hash, g_direct_equal);
2916
2917         for (GList *i = dw->list; i != nullptr; i = i->next)
2918                 {
2919                         auto di = static_cast<DupeItem *>(i->data);
2920
2921                         g_hash_table_add(dw->list_cache, di->fd);
2922                 }
2923
2924         for (GList *i = dw->second_list; i != nullptr; i = i->next)
2925                 {
2926                         auto di = static_cast<DupeItem *>(i->data);
2927
2928                         g_hash_table_add(dw->second_list_cache, di->fd);
2929                 }
2930 }
2931
2932 static void dupe_destroy_list_cache(DupeWindow *dw)
2933 {
2934         g_hash_table_destroy(dw->list_cache);
2935         g_hash_table_destroy(dw->second_list_cache);
2936 }
2937
2938 /**
2939  * @brief Return true if the fd was not in the cache
2940  * @param dw
2941  * @param fd
2942  * @returns
2943  *
2944  *
2945  */
2946 static gboolean dupe_insert_in_list_cache(DupeWindow *dw, FileData *fd)
2947 {
2948         GHashTable *table =
2949                 dw->second_drop ? dw->second_list_cache : dw->list_cache;
2950         /* We do this as a lookup + add as we don't want to overwrite
2951            items as that would leak the old value. */
2952         if (g_hash_table_lookup(table, fd) != nullptr)
2953                 return FALSE;
2954         return g_hash_table_add(table, fd);
2955 }
2956
2957 void dupe_window_add_collection(DupeWindow *dw, CollectionData *collection)
2958 {
2959         CollectInfo *info;
2960
2961         info = collection_get_first(collection);
2962         while (info)
2963                 {
2964                 dupe_files_add(dw, collection, info, nullptr, FALSE);
2965                 info = collection_next_by_info(collection, info);
2966                 }
2967
2968         dupe_check_start(dw);
2969 }
2970
2971 void dupe_window_add_files(DupeWindow *dw, GList *list, gboolean recurse)
2972 {
2973         GList *work;
2974
2975         work = list;
2976         while (work)
2977                 {
2978                 auto fd = static_cast<FileData *>(work->data);
2979                 work = work->next;
2980                 if (isdir(fd->path) && !recurse)
2981                         {
2982                         GList *f, *d;
2983
2984                         if (filelist_read(fd, &f, &d))
2985                                 {
2986                                 GList *work_file;
2987                                 work_file = f;
2988
2989                                 while (work_file)
2990                                         {
2991                                         /* Add only the files, ignore the dirs when no recurse */
2992                                         dw->add_files_queue = g_list_prepend(dw->add_files_queue, work_file->data);
2993                                         file_data_ref((FileData *)work_file->data);
2994                                         work_file = work_file->next;
2995                                         }
2996                                 g_list_free(f);
2997                                 g_list_free(d);
2998                                 }
2999                         }
3000                 else
3001                         {
3002                         dw->add_files_queue = g_list_prepend(dw->add_files_queue, fd);
3003                         file_data_ref(fd);
3004                         }
3005                 }
3006         if (dw->add_files_queue_id == 0)
3007                 {
3008                 gtk_progress_bar_pulse(GTK_PROGRESS_BAR(dw->extra_label));
3009                 gtk_progress_bar_set_pulse_step(GTK_PROGRESS_BAR(dw->extra_label), DUPE_PROGRESS_PULSE_STEP);
3010                 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(dw->extra_label), _("Loading file list"));
3011
3012                 dupe_init_list_cache(dw);
3013                 dw->add_files_queue_id = g_idle_add(dupe_files_add_queue_cb, dw);
3014                 gtk_widget_set_sensitive(dw->controls_box, FALSE);
3015                 }
3016 }
3017
3018 static void dupe_item_update(DupeWindow *dw, DupeItem *di)
3019 {
3020         if ( (dw->match_mask & DUPE_MATCH_NAME) || (dw->match_mask & DUPE_MATCH_PATH || (dw->match_mask & DUPE_MATCH_NAME_CI)) )
3021                 {
3022                 /* only effects matches on name or path */
3023 /*
3024                 FileData *fd = file_data_ref(di->fd);
3025                 gint second;
3026
3027                 second = di->second;
3028                 dupe_item_remove(dw, di);
3029
3030                 dw->second_drop = second;
3031                 dupe_files_add(dw, NULL, NULL, fd, FALSE);
3032                 dw->second_drop = FALSE;
3033
3034                 file_data_unref(fd);
3035 */
3036                 dupe_check_start(dw);
3037                 }
3038         else
3039                 {
3040                 GtkListStore *store;
3041                 GtkTreeIter iter;
3042                 gint row;
3043                 /* update the listview(s) */
3044
3045                 store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
3046                 row = dupe_listview_find_item(store, di, &iter);
3047                 if (row >= 0)
3048                         {
3049                         gtk_list_store_set(store, &iter,
3050                                            DUPE_COLUMN_NAME, di->fd->name,
3051                                            DUPE_COLUMN_PATH, di->fd->path, -1);
3052                         }
3053
3054                 if (dw->second_listview)
3055                         {
3056                         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->second_listview)));
3057                         row = dupe_listview_find_item(store, di, &iter);
3058                         if (row >= 0)
3059                                 {
3060                                 gtk_list_store_set(store, &iter, 1, di->fd->path, -1);
3061                                 }
3062                         }
3063                 }
3064
3065 }
3066
3067 static void dupe_item_update_fd_in_list(DupeWindow *dw, FileData *fd, GList *work)
3068 {
3069         while (work)
3070                 {
3071                 auto di = static_cast<DupeItem *>(work->data);
3072
3073                 if (di->fd == fd)
3074                         dupe_item_update(dw, di);
3075
3076                 work = work->next;
3077                 }
3078 }
3079
3080 static void dupe_item_update_fd(DupeWindow *dw, FileData *fd)
3081 {
3082         dupe_item_update_fd_in_list(dw, fd, dw->list);
3083         if (dw->second_set) dupe_item_update_fd_in_list(dw, fd, dw->second_list);
3084 }
3085
3086
3087 /*
3088  * ------------------------------------------------------------------
3089  * Misc.
3090  * ------------------------------------------------------------------
3091  */
3092
3093 static GtkWidget *dupe_display_label(GtkWidget *vbox, const gchar *description, const gchar *text)
3094 {
3095         GtkWidget *hbox;
3096         GtkWidget *label;
3097
3098         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
3099
3100         label = gtk_label_new(description);
3101         gq_gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
3102         gtk_widget_show(label);
3103
3104         label = gtk_label_new(text);
3105         gq_gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
3106         gtk_widget_show(label);
3107
3108         gq_gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
3109         gtk_widget_show(hbox);
3110
3111         return label;
3112 }
3113
3114 static void dupe_display_stats(DupeWindow *dw, DupeItem *di)
3115 {
3116         GenericDialog *gd;
3117         gchar *buf;
3118
3119         if (!di) return;
3120
3121         gd = file_util_gen_dlg("Image thumbprint debug info", "thumbprint",
3122                                dw->window, TRUE,
3123                                nullptr, nullptr);
3124         generic_dialog_add_button(gd, GQ_ICON_CLOSE, _("Close"), nullptr, TRUE);
3125
3126         dupe_display_label(gd->vbox, "name:", di->fd->name);
3127         buf = text_from_size(di->fd->size);
3128         dupe_display_label(gd->vbox, "size:", buf);
3129         g_free(buf);
3130         dupe_display_label(gd->vbox, "date:", text_from_time(di->fd->date));
3131         buf = g_strdup_printf("%d x %d", di->width, di->height);
3132         dupe_display_label(gd->vbox, "dimensions:", buf);
3133         g_free(buf);
3134         dupe_display_label(gd->vbox, "md5sum:", (di->md5sum) ? di->md5sum : "not generated");
3135
3136         dupe_display_label(gd->vbox, "thumbprint:", (di->simd) ? "" : "not generated");
3137         if (di->simd)
3138                 {
3139                 GtkWidget *image;
3140                 GdkPixbuf *pixbuf;
3141                 gint x, y;
3142                 guchar *d_pix;
3143                 guchar *dp;
3144                 gint rs;
3145                 gint sp;
3146
3147                 pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, 32, 32);
3148                 rs = gdk_pixbuf_get_rowstride(pixbuf);
3149                 d_pix = gdk_pixbuf_get_pixels(pixbuf);
3150
3151                 for (y = 0; y < 32; y++)
3152                         {
3153                         dp = d_pix + (y * rs);
3154                         sp = y * 32;
3155                         for (x = 0; x < 32; x++)
3156                                 {
3157                                 *(dp++) = di->simd->avg_r[sp + x];
3158                                 *(dp++) = di->simd->avg_g[sp + x];
3159                                 *(dp++) = di->simd->avg_b[sp + x];
3160                                 }
3161                         }
3162
3163                 image = gtk_image_new_from_pixbuf(pixbuf);
3164                 gq_gtk_box_pack_start(GTK_BOX(gd->vbox), image, FALSE, FALSE, 0);
3165                 gtk_widget_show(image);
3166
3167                 g_object_unref(pixbuf);
3168                 }
3169
3170         gtk_widget_show(gd->dialog);
3171 }
3172
3173 static void dupe_window_recompare(DupeWindow *dw)
3174 {
3175         GtkListStore *store;
3176
3177         dupe_check_stop(dw);
3178
3179         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
3180         gtk_list_store_clear(store);
3181
3182         g_list_free(dw->dupes);
3183         dw->dupes = nullptr;
3184
3185         dupe_match_reset_list(dw->list);
3186         dupe_match_reset_list(dw->second_list);
3187         dw->set_count = 0;
3188
3189         dupe_check_start(dw);
3190 }
3191
3192 static void dupe_menu_view(DupeWindow *dw, DupeItem *di, GtkWidget *listview, gint new_window)
3193 {
3194         if (!di) return;
3195
3196         if (di->collection && collection_info_valid(di->collection, di->info))
3197                 {
3198                 if (new_window)
3199                         {
3200                         view_window_new_from_collection(di->collection, di->info);
3201                         }
3202                 else
3203                         {
3204                         layout_image_set_collection(nullptr, di->collection, di->info);
3205                         }
3206                 }
3207         else
3208                 {
3209                 if (new_window)
3210                         {
3211                         GList *list;
3212
3213                         list = dupe_listview_get_selection(dw, listview);
3214                         view_window_new_from_list(list);
3215                         filelist_free(list);
3216                         }
3217                 else
3218                         {
3219                         layout_set_fd(nullptr, di->fd);
3220                         }
3221                 }
3222 }
3223
3224 static void dupe_window_remove_selection(DupeWindow *dw, GtkWidget *listview)
3225 {
3226         GtkTreeSelection *selection;
3227         GtkTreeModel *store;
3228         GtkTreeIter iter;
3229         GList *slist;
3230         GList *list = nullptr;
3231         GList *work;
3232
3233         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
3234         slist = gtk_tree_selection_get_selected_rows(selection, &store);
3235         work = slist;
3236         while (work)
3237                 {
3238                 auto tpath = static_cast<GtkTreePath *>(work->data);
3239                 DupeItem *di = nullptr;
3240
3241                 gtk_tree_model_get_iter(store, &iter, tpath);
3242                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
3243                 if (di) list = g_list_prepend(list, di);
3244                 work = work->next;
3245                 }
3246         g_list_free_full(slist, reinterpret_cast<GDestroyNotify>(gtk_tree_path_free));
3247
3248         dw->color_frozen = TRUE;
3249         work = list;
3250         while (work)
3251                 {
3252                 DupeItem *di;
3253
3254                 di = static_cast<DupeItem *>(work->data);
3255                 work = work->next;
3256                 dupe_item_remove(dw, di);
3257                 }
3258         dw->color_frozen = FALSE;
3259
3260         g_list_free(list);
3261
3262         dupe_listview_realign_colors(dw);
3263 }
3264
3265 static void dupe_window_edit_selected(DupeWindow *dw, const gchar *key)
3266 {
3267         file_util_start_editor_from_filelist(key, dupe_listview_get_selection(dw, dw->listview), nullptr, dw->window);
3268 }
3269
3270 static void dupe_window_collection_from_selection(DupeWindow *dw)
3271 {
3272         CollectWindow *w;
3273         GList *list;
3274
3275         list = dupe_listview_get_selection(dw, dw->listview);
3276         w = collection_window_new(nullptr);
3277         collection_table_add_filelist(w->table, list);
3278         filelist_free(list);
3279 }
3280
3281 static void dupe_window_append_file_list(DupeWindow *dw, gint on_second)
3282 {
3283         GList *list;
3284
3285         dw->second_drop = (dw->second_set && on_second);
3286
3287         list = layout_list(nullptr);
3288         dupe_window_add_files(dw, list, FALSE);
3289         filelist_free(list);
3290 }
3291
3292 /*
3293  *-------------------------------------------------------------------
3294  * main pop-up menu callbacks
3295  *-------------------------------------------------------------------
3296  */
3297
3298 static void dupe_menu_view_cb(GtkWidget *, gpointer data)
3299 {
3300         auto dw = static_cast<DupeWindow *>(data);
3301
3302         if (dw->click_item) dupe_menu_view(dw, dw->click_item, dw->listview, FALSE);
3303 }
3304
3305 static void dupe_menu_viewnew_cb(GtkWidget *, gpointer data)
3306 {
3307         auto dw = static_cast<DupeWindow *>(data);
3308
3309         if (dw->click_item) dupe_menu_view(dw, dw->click_item, dw->listview, TRUE);
3310 }
3311
3312 static void dupe_menu_select_all_cb(GtkWidget *, gpointer data)
3313 {
3314         auto dw = static_cast<DupeWindow *>(data);
3315         GtkTreeSelection *selection;
3316
3317         options->duplicates_select_type = DUPE_SELECT_NONE;
3318         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->listview));
3319         gtk_tree_selection_select_all(selection);
3320 }
3321
3322 static void dupe_menu_select_none_cb(GtkWidget *, gpointer data)
3323 {
3324         auto dw = static_cast<DupeWindow *>(data);
3325         GtkTreeSelection *selection;
3326
3327         options->duplicates_select_type = DUPE_SELECT_NONE;
3328         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->listview));
3329         gtk_tree_selection_unselect_all(selection);
3330 }
3331
3332 static void dupe_menu_select_dupes_set1_cb(GtkWidget *, gpointer data)
3333 {
3334         auto dw = static_cast<DupeWindow *>(data);
3335
3336         options->duplicates_select_type = DUPE_SELECT_GROUP1;
3337         dupe_listview_select_dupes(dw, DUPE_SELECT_GROUP1);
3338 }
3339
3340 static void dupe_menu_select_dupes_set2_cb(GtkWidget *, gpointer data)
3341 {
3342         auto dw = static_cast<DupeWindow *>(data);
3343
3344         options->duplicates_select_type = DUPE_SELECT_GROUP2;
3345         dupe_listview_select_dupes(dw, DUPE_SELECT_GROUP2);
3346 }
3347
3348 static void dupe_menu_edit_cb(GtkWidget *widget, gpointer data)
3349 {
3350         DupeWindow *dw;
3351         auto key = static_cast<const gchar *>(data);
3352
3353         dw = static_cast<DupeWindow *>(submenu_item_get_data(widget));
3354         if (!dw) return;
3355
3356         dupe_window_edit_selected(dw, key);
3357 }
3358
3359 static void dupe_menu_print_cb(GtkWidget *, gpointer data)
3360 {
3361         auto dw = static_cast<DupeWindow *>(data);
3362         FileData *fd;
3363
3364         fd = (dw->click_item) ? dw->click_item->fd : nullptr;
3365
3366         print_window_new(fd,
3367                          dupe_listview_get_selection(dw, dw->listview),
3368                          dupe_listview_get_filelist(dw, dw->listview), dw->window);
3369 }
3370
3371 static void dupe_menu_copy_cb(GtkWidget *, gpointer data)
3372 {
3373         auto dw = static_cast<DupeWindow *>(data);
3374
3375         file_util_copy(nullptr, dupe_listview_get_selection(dw, dw->listview), nullptr, dw->window);
3376 }
3377
3378 static void dupe_menu_move_cb(GtkWidget *, gpointer data)
3379 {
3380         auto dw = static_cast<DupeWindow *>(data);
3381
3382         file_util_move(nullptr, dupe_listview_get_selection(dw, dw->listview), nullptr, dw->window);
3383 }
3384
3385 static void dupe_menu_rename_cb(GtkWidget *, gpointer data)
3386 {
3387         auto dw = static_cast<DupeWindow *>(data);
3388
3389         file_util_rename(nullptr, dupe_listview_get_selection(dw, dw->listview), dw->window);
3390 }
3391
3392 static void dupe_menu_delete_cb(GtkWidget *, gpointer data)
3393 {
3394         auto dw = static_cast<DupeWindow *>(data);
3395
3396         options->file_ops.safe_delete_enable = FALSE;
3397         file_util_delete_notify_done(nullptr, dupe_listview_get_selection(dw, dw->listview), dw->window, delete_finished_cb, dw);
3398 }
3399
3400 static void dupe_menu_move_to_trash_cb(GtkWidget *, gpointer data)
3401 {
3402         auto dw = static_cast<DupeWindow *>(data);
3403
3404         options->file_ops.safe_delete_enable = TRUE;
3405         file_util_delete_notify_done(nullptr, dupe_listview_get_selection(dw, dw->listview), dw->window, delete_finished_cb, dw);
3406 }
3407
3408 static void dupe_menu_copy_path_cb(GtkWidget *, gpointer data)
3409 {
3410         auto dw = static_cast<DupeWindow *>(data);
3411
3412         file_util_copy_path_list_to_clipboard(dupe_listview_get_selection(dw, dw->listview), TRUE);
3413 }
3414
3415 static void dupe_menu_copy_path_unquoted_cb(GtkWidget *, gpointer data)
3416 {
3417         auto dw = static_cast<DupeWindow *>(data);
3418
3419         file_util_copy_path_list_to_clipboard(dupe_listview_get_selection(dw, dw->listview), FALSE);
3420 }
3421
3422 static void dupe_menu_remove_cb(GtkWidget *, gpointer data)
3423 {
3424         auto dw = static_cast<DupeWindow *>(data);
3425
3426         dupe_window_remove_selection(dw, dw->listview);
3427 }
3428
3429 static void dupe_menu_clear_cb(GtkWidget *, gpointer data)
3430 {
3431         auto dw = static_cast<DupeWindow *>(data);
3432
3433         dupe_window_clear(dw);
3434 }
3435
3436 static void dupe_menu_close_cb(GtkWidget *, gpointer data)
3437 {
3438         auto dw = static_cast<DupeWindow *>(data);
3439
3440         dupe_window_close(dw);
3441 }
3442
3443 static void dupe_menu_popup_destroy_cb(GtkWidget *, gpointer data)
3444 {
3445         auto editmenu_fd_list = static_cast<GList *>(data);
3446
3447         filelist_free(editmenu_fd_list);
3448 }
3449
3450 static GList *dupe_window_get_fd_list(DupeWindow *dw)
3451 {
3452         GList *list;
3453
3454         if (gtk_widget_has_focus(dw->second_listview))
3455                 {
3456                 list = dupe_listview_get_selection(dw, dw->second_listview);
3457                 }
3458         else
3459                 {
3460                 list = dupe_listview_get_selection(dw, dw->listview);
3461                 }
3462
3463         return list;
3464 }
3465
3466 /**
3467  * @brief Add file selection list to a collection
3468  * @param[in] widget
3469  * @param[in] data Index to the collection list menu item selected, or -1 for new collection
3470  *
3471  *
3472  */
3473 static void dupe_pop_menu_collections_cb(GtkWidget *widget, gpointer data)
3474 {
3475         DupeWindow *dw;
3476         GList *selection_list;
3477
3478         dw = static_cast<DupeWindow *>(submenu_item_get_data(widget));
3479         selection_list = dupe_listview_get_selection(dw, dw->listview);
3480         pop_menu_collections(selection_list, data);
3481
3482         filelist_free(selection_list);
3483 }
3484
3485 static GtkWidget *dupe_menu_popup_main(DupeWindow *dw, DupeItem *di)
3486 {
3487         GtkWidget *menu;
3488         GtkWidget *item;
3489         gint on_row;
3490         GList *editmenu_fd_list;
3491         GtkAccelGroup *accel_group;
3492
3493         on_row = (di != nullptr);
3494
3495         menu = popup_menu_short_lived();
3496
3497         accel_group = gtk_accel_group_new();
3498         gtk_menu_set_accel_group(GTK_MENU(menu), accel_group);
3499
3500         g_object_set_data(G_OBJECT(menu), "window_keys", dupe_window_keys);
3501         g_object_set_data(G_OBJECT(menu), "accel_group", accel_group);
3502
3503         menu_item_add_sensitive(menu, _("_View"), on_row,
3504                                 G_CALLBACK(dupe_menu_view_cb), dw);
3505         menu_item_add_icon_sensitive(menu, _("View in _new window"), GQ_ICON_NEW, on_row,
3506                                 G_CALLBACK(dupe_menu_viewnew_cb), dw);
3507         menu_item_add_divider(menu);
3508         menu_item_add_sensitive(menu, _("Select all"), (dw->dupes != nullptr),
3509                                 G_CALLBACK(dupe_menu_select_all_cb), dw);
3510         menu_item_add_sensitive(menu, _("Select none"), (dw->dupes != nullptr),
3511                                 G_CALLBACK(dupe_menu_select_none_cb), dw);
3512         menu_item_add_sensitive(menu, _("Select group _1 duplicates"), (dw->dupes != nullptr),
3513                                 G_CALLBACK(dupe_menu_select_dupes_set1_cb), dw);
3514         menu_item_add_sensitive(menu, _("Select group _2 duplicates"), (dw->dupes != nullptr),
3515                                 G_CALLBACK(dupe_menu_select_dupes_set2_cb), dw);
3516         menu_item_add_divider(menu);
3517
3518         submenu_add_export(menu, &item, G_CALLBACK(dupe_pop_menu_export_cb), dw);
3519         gtk_widget_set_sensitive(item, on_row);
3520         menu_item_add_divider(menu);
3521
3522         editmenu_fd_list = dupe_window_get_fd_list(dw);
3523         g_signal_connect(G_OBJECT(menu), "destroy",
3524                          G_CALLBACK(dupe_menu_popup_destroy_cb), editmenu_fd_list);
3525         submenu_add_edit(menu, &item, G_CALLBACK(dupe_menu_edit_cb), dw, editmenu_fd_list);
3526         if (!on_row) gtk_widget_set_sensitive(item, FALSE);
3527
3528         submenu_add_collections(menu, &item,
3529                                                                 G_CALLBACK(dupe_pop_menu_collections_cb), dw);
3530         gtk_widget_set_sensitive(item, on_row);
3531
3532         menu_item_add_icon_sensitive(menu, _("Print..."), GQ_ICON_PRINT, on_row,
3533                                 G_CALLBACK(dupe_menu_print_cb), dw);
3534         menu_item_add_divider(menu);
3535         menu_item_add_icon_sensitive(menu, _("_Copy..."), GQ_ICON_COPY, on_row,
3536                                 G_CALLBACK(dupe_menu_copy_cb), dw);
3537         menu_item_add_sensitive(menu, _("_Move..."), on_row,
3538                                 G_CALLBACK(dupe_menu_move_cb), dw);
3539         menu_item_add_sensitive(menu, _("_Rename..."), on_row,
3540                                 G_CALLBACK(dupe_menu_rename_cb), dw);
3541         menu_item_add_sensitive(menu, _("_Copy path"), on_row,
3542                                 G_CALLBACK(dupe_menu_copy_path_cb), dw);
3543         menu_item_add_sensitive(menu, _("_Copy path unquoted"), on_row,
3544                                 G_CALLBACK(dupe_menu_copy_path_unquoted_cb), dw);
3545
3546         menu_item_add_divider(menu);
3547         menu_item_add_icon_sensitive(menu,
3548                                 options->file_ops.confirm_move_to_trash ? _("Move to Trash...") :
3549                                         _("Move to Trash"), GQ_ICON_DELETE, on_row,
3550                                 G_CALLBACK(dupe_menu_move_to_trash_cb), dw);
3551         menu_item_add_icon_sensitive(menu,
3552                                 options->file_ops.confirm_delete ? _("_Delete...") :
3553                                         _("_Delete"), GQ_ICON_DELETE_SHRED, on_row,
3554                                 G_CALLBACK(dupe_menu_delete_cb), dw);
3555
3556         menu_item_add_divider(menu);
3557         menu_item_add_icon_sensitive(menu, _("Rem_ove"), GQ_ICON_REMOVE, on_row,
3558                                 G_CALLBACK(dupe_menu_remove_cb), dw);
3559         menu_item_add_icon_sensitive(menu, _("C_lear"), GQ_ICON_CLEAR, (dw->list != nullptr),
3560                                 G_CALLBACK(dupe_menu_clear_cb), dw);
3561         menu_item_add_divider(menu);
3562         menu_item_add_icon(menu, _("Close _window"), GQ_ICON_CLOSE,
3563                             G_CALLBACK(dupe_menu_close_cb), dw);
3564
3565         return menu;
3566 }
3567
3568 static gboolean dupe_listview_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
3569 {
3570         auto dw = static_cast<DupeWindow *>(data);
3571         GtkTreeModel *store;
3572         GtkTreePath *tpath;
3573         GtkTreeIter iter;
3574         DupeItem *di = nullptr;
3575
3576         store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
3577
3578         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
3579                                           &tpath, nullptr, nullptr, nullptr))
3580                 {
3581                 gtk_tree_model_get_iter(store, &iter, tpath);
3582                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
3583                 gtk_tree_path_free(tpath);
3584                 }
3585
3586         dw->click_item = di;
3587
3588         if (bevent->button == MOUSE_BUTTON_RIGHT)
3589                 {
3590                 /* right click menu */
3591                 GtkWidget *menu;
3592
3593                 if (bevent->state & GDK_CONTROL_MASK && bevent->state & GDK_SHIFT_MASK)
3594                         {
3595                         dupe_display_stats(dw, di);
3596                         return TRUE;
3597                         }
3598                 if (widget == dw->listview)
3599                         {
3600                         menu = dupe_menu_popup_main(dw, di);
3601                         }
3602                 else
3603                         {
3604                         menu = dupe_menu_popup_second(dw, di);
3605                         }
3606                 gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
3607                 }
3608
3609         if (!di) return FALSE;
3610
3611         if (bevent->button == MOUSE_BUTTON_LEFT &&
3612             bevent->type == GDK_2BUTTON_PRESS)
3613                 {
3614                 dupe_menu_view(dw, di, widget, FALSE);
3615                 }
3616
3617         if (bevent->button == MOUSE_BUTTON_MIDDLE) return TRUE;
3618
3619         if (bevent->button == MOUSE_BUTTON_RIGHT)
3620                 {
3621                 if (!dupe_listview_item_is_selected(dw, di, widget))
3622                         {
3623                         GtkTreeSelection *selection;
3624
3625                         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
3626                         gtk_tree_selection_unselect_all(selection);
3627                         gtk_tree_selection_select_iter(selection, &iter);
3628
3629                         tpath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
3630                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, nullptr, FALSE);
3631                         gtk_tree_path_free(tpath);
3632                         }
3633
3634                 return TRUE;
3635                 }
3636
3637         if (bevent->button == MOUSE_BUTTON_LEFT &&
3638             bevent->type == GDK_BUTTON_PRESS &&
3639             !(bevent->state & GDK_SHIFT_MASK ) &&
3640             !(bevent->state & GDK_CONTROL_MASK ) &&
3641             dupe_listview_item_is_selected(dw, di, widget))
3642                 {
3643                 /* this selection handled on release_cb */
3644                 gtk_widget_grab_focus(widget);
3645                 return TRUE;
3646                 }
3647
3648         return FALSE;
3649 }
3650
3651 static gboolean dupe_listview_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
3652 {
3653         auto dw = static_cast<DupeWindow *>(data);
3654         GtkTreeModel *store;
3655         GtkTreePath *tpath;
3656         GtkTreeIter iter;
3657         DupeItem *di = nullptr;
3658
3659         if (bevent->button != MOUSE_BUTTON_LEFT && bevent->button != MOUSE_BUTTON_MIDDLE) return TRUE;
3660
3661         store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
3662
3663         if ((bevent->x != 0 || bevent->y != 0) &&
3664             gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
3665                                           &tpath, nullptr, nullptr, nullptr))
3666                 {
3667                 gtk_tree_model_get_iter(store, &iter, tpath);
3668                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
3669                 gtk_tree_path_free(tpath);
3670                 }
3671
3672         if (bevent->button == MOUSE_BUTTON_MIDDLE)
3673                 {
3674                 if (di && dw->click_item == di)
3675                         {
3676                         GtkTreeSelection *selection;
3677
3678                         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
3679                         if (dupe_listview_item_is_selected(dw, di, widget))
3680                                 {
3681                                 gtk_tree_selection_unselect_iter(selection, &iter);
3682                                 }
3683                         else
3684                                 {
3685                                 gtk_tree_selection_select_iter(selection, &iter);
3686                                 }
3687                         }
3688                 return TRUE;
3689                 }
3690
3691         if (di && dw->click_item == di &&
3692             !(bevent->state & GDK_SHIFT_MASK ) &&
3693             !(bevent->state & GDK_CONTROL_MASK ) &&
3694             dupe_listview_item_is_selected(dw, di, widget))
3695                 {
3696                 GtkTreeSelection *selection;
3697
3698                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
3699                 gtk_tree_selection_unselect_all(selection);
3700                 gtk_tree_selection_select_iter(selection, &iter);
3701
3702                 tpath = gtk_tree_model_get_path(store, &iter);
3703                 gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, nullptr, FALSE);
3704                 gtk_tree_path_free(tpath);
3705
3706                 return TRUE;
3707                 }
3708
3709         return FALSE;
3710 }
3711
3712 /*
3713  *-------------------------------------------------------------------
3714  * second set stuff
3715  *-------------------------------------------------------------------
3716  */
3717
3718 static void dupe_second_update_status(DupeWindow *dw)
3719 {
3720         gchar *buf;
3721
3722         buf = g_strdup_printf(_("%d files (set 2)"), g_list_length(dw->second_list));
3723         gtk_label_set_text(GTK_LABEL(dw->second_status_label), buf);
3724         g_free(buf);
3725 }
3726
3727 static void dupe_second_add(DupeWindow *dw, DupeItem *di)
3728 {
3729         GtkListStore *store;
3730         GtkTreeIter iter;
3731
3732         if (!di) return;
3733
3734         di->second = TRUE;
3735         dw->second_list = g_list_prepend(dw->second_list, di);
3736
3737         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->second_listview)));
3738         gtk_list_store_append(store, &iter);
3739         gtk_list_store_set(store, &iter, DUPE_COLUMN_POINTER, di, 1, di->fd->path, -1);
3740
3741         dupe_second_update_status(dw);
3742 }
3743
3744 static void dupe_second_remove(DupeWindow *dw, DupeItem *di)
3745 {
3746         GtkListStore *store;
3747         GtkTreeIter iter;
3748
3749         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->second_listview)));
3750         if (dupe_listview_find_item(store, di, &iter) >= 0)
3751                 {
3752                 tree_view_move_cursor_away(GTK_TREE_VIEW(dw->second_listview), &iter, TRUE);
3753                 gtk_list_store_remove(store, &iter);
3754                 }
3755
3756         dw->second_list = g_list_remove(dw->second_list, di);
3757
3758         dupe_second_update_status(dw);
3759 }
3760
3761 static void dupe_second_clear(DupeWindow *dw)
3762 {
3763         GtkListStore *store;
3764
3765         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->second_listview)));
3766         gtk_list_store_clear(store);
3767         gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dw->second_listview));
3768
3769         g_list_free(dw->dupes);
3770         dw->dupes = nullptr;
3771
3772         g_list_free_full(dw->second_list, reinterpret_cast<GDestroyNotify>(dupe_item_free));
3773         dw->second_list = nullptr;
3774
3775         dupe_match_reset_list(dw->list);
3776
3777         dupe_second_update_status(dw);
3778 }
3779
3780 static void dupe_second_menu_view_cb(GtkWidget *, gpointer data)
3781 {
3782         auto dw = static_cast<DupeWindow *>(data);
3783
3784         if (dw->click_item) dupe_menu_view(dw, dw->click_item, dw->second_listview, FALSE);
3785 }
3786
3787 static void dupe_second_menu_viewnew_cb(GtkWidget *, gpointer data)
3788 {
3789         auto dw = static_cast<DupeWindow *>(data);
3790
3791         if (dw->click_item) dupe_menu_view(dw, dw->click_item, dw->second_listview, TRUE);
3792 }
3793
3794 static void dupe_second_menu_select_all_cb(GtkWidget *, gpointer data)
3795 {
3796         GtkTreeSelection *selection;
3797         auto dw = static_cast<DupeWindow *>(data);
3798
3799         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->second_listview));
3800         gtk_tree_selection_select_all(selection);
3801 }
3802
3803 static void dupe_second_menu_select_none_cb(GtkWidget *, gpointer data)
3804 {
3805         GtkTreeSelection *selection;
3806         auto dw = static_cast<DupeWindow *>(data);
3807
3808         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->second_listview));
3809         gtk_tree_selection_unselect_all(selection);
3810 }
3811
3812 static void dupe_second_menu_remove_cb(GtkWidget *, gpointer data)
3813 {
3814         auto dw = static_cast<DupeWindow *>(data);
3815
3816         dupe_window_remove_selection(dw, dw->second_listview);
3817 }
3818
3819 static void dupe_second_menu_clear_cb(GtkWidget *, gpointer data)
3820 {
3821         auto dw = static_cast<DupeWindow *>(data);
3822
3823         dupe_second_clear(dw);
3824         dupe_window_recompare(dw);
3825 }
3826
3827 static GtkWidget *dupe_menu_popup_second(DupeWindow *dw, DupeItem *di)
3828 {
3829         GtkWidget *menu;
3830         gboolean notempty = (dw->second_list != nullptr);
3831         gboolean on_row = (di != nullptr);
3832         GtkAccelGroup *accel_group;
3833
3834         menu = popup_menu_short_lived();
3835         accel_group = gtk_accel_group_new();
3836         gtk_menu_set_accel_group(GTK_MENU(menu), accel_group);
3837
3838         g_object_set_data(G_OBJECT(menu), "window_keys", dupe_window_keys);
3839         g_object_set_data(G_OBJECT(menu), "accel_group", accel_group);
3840
3841         menu_item_add_sensitive(menu, _("_View"), on_row,
3842                                 G_CALLBACK(dupe_second_menu_view_cb), dw);
3843         menu_item_add_icon_sensitive(menu, _("View in _new window"), GQ_ICON_NEW, on_row,
3844                                 G_CALLBACK(dupe_second_menu_viewnew_cb), dw);
3845         menu_item_add_divider(menu);
3846         menu_item_add_sensitive(menu, _("Select all"), notempty,
3847                                 G_CALLBACK(dupe_second_menu_select_all_cb), dw);
3848         menu_item_add_sensitive(menu, _("Select none"), notempty,
3849                                 G_CALLBACK(dupe_second_menu_select_none_cb), dw);
3850         menu_item_add_divider(menu);
3851         menu_item_add_icon_sensitive(menu, _("Rem_ove"), GQ_ICON_REMOVE, on_row,
3852                                       G_CALLBACK(dupe_second_menu_remove_cb), dw);
3853         menu_item_add_icon_sensitive(menu, _("C_lear"), GQ_ICON_CLEAR, notempty,
3854                                    G_CALLBACK(dupe_second_menu_clear_cb), dw);
3855         menu_item_add_divider(menu);
3856         menu_item_add_icon(menu, _("Close _window"), GQ_ICON_CLOSE,
3857                             G_CALLBACK(dupe_menu_close_cb), dw);
3858
3859         return menu;
3860 }
3861
3862 static void dupe_second_set_toggle_cb(GtkWidget *widget, gpointer data)
3863 {
3864         auto dw = static_cast<DupeWindow *>(data);
3865
3866         dw->second_set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
3867
3868         if (dw->second_set)
3869                 {
3870                 dupe_second_update_status(dw);
3871                 gtk_grid_set_column_spacing(GTK_GRID(dw->table), PREF_PAD_GAP);
3872                 gtk_widget_show(dw->second_vbox);
3873                 }
3874         else
3875                 {
3876                 gtk_grid_set_column_spacing(GTK_GRID(dw->table), 0);
3877                 gtk_widget_hide(dw->second_vbox);
3878                 dupe_second_clear(dw);
3879                 }
3880
3881         dupe_window_recompare(dw);
3882 }
3883
3884 static void dupe_sort_totals_toggle_cb(GtkWidget *widget, gpointer data)
3885 {
3886         auto dw = static_cast<DupeWindow *>(data);
3887
3888         options->sort_totals = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
3889         dupe_window_recompare(dw);
3890
3891 }
3892
3893 /*
3894  *-------------------------------------------------------------------
3895  * match type menu
3896  *-------------------------------------------------------------------
3897  */
3898
3899 enum {
3900         DUPE_MENU_COLUMN_NAME = 0,
3901         DUPE_MENU_COLUMN_MASK
3902 };
3903
3904 static void dupe_listview_show_rank(GtkWidget *listview, gboolean rank);
3905
3906 static void dupe_menu_type_cb(GtkWidget *combo, gpointer data)
3907 {
3908         auto dw = static_cast<DupeWindow *>(data);
3909         GtkTreeModel *store;
3910         GtkTreeIter iter;
3911
3912         store = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
3913         if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter)) return;
3914         gtk_tree_model_get(store, &iter, DUPE_MENU_COLUMN_MASK, &dw->match_mask, -1);
3915
3916         options->duplicates_match = dw->match_mask;
3917
3918         if (dw->match_mask & (DUPE_MATCH_SIM_HIGH | DUPE_MATCH_SIM_MED | DUPE_MATCH_SIM_LOW | DUPE_MATCH_SIM_CUSTOM))
3919                 {
3920                 dupe_listview_show_rank(dw->listview, TRUE);
3921                 }
3922         else
3923                 {
3924                 dupe_listview_show_rank(dw->listview, FALSE);
3925                 }
3926         dupe_window_recompare(dw);
3927 }
3928
3929 static void dupe_menu_add_item(GtkListStore *store, const gchar *text, DupeMatchType type, DupeWindow *dw)
3930 {
3931         GtkTreeIter iter;
3932
3933         gtk_list_store_append(store, &iter);
3934         gtk_list_store_set(store, &iter, DUPE_MENU_COLUMN_NAME, text,
3935                                          DUPE_MENU_COLUMN_MASK, type, -1);
3936
3937         if (dw->match_mask == type) gtk_combo_box_set_active_iter(GTK_COMBO_BOX(dw->combo), &iter);
3938 }
3939
3940 static void dupe_menu_setup(DupeWindow *dw)
3941 {
3942         GtkListStore *store;
3943         GtkCellRenderer *renderer;
3944
3945         store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
3946         dw->combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
3947         g_object_unref(store);
3948
3949         renderer = gtk_cell_renderer_text_new();
3950         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(dw->combo), renderer, TRUE);
3951         gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(dw->combo), renderer,
3952                                        "text", DUPE_MENU_COLUMN_NAME, NULL);
3953
3954         dupe_menu_add_item(store, _("Name"), DUPE_MATCH_NAME, dw);
3955         dupe_menu_add_item(store, _("Name case-insensitive"), DUPE_MATCH_NAME_CI, dw);
3956         dupe_menu_add_item(store, _("Size"), DUPE_MATCH_SIZE, dw);
3957         dupe_menu_add_item(store, _("Date"), DUPE_MATCH_DATE, dw);
3958         dupe_menu_add_item(store, _("Dimensions"), DUPE_MATCH_DIM, dw);
3959         dupe_menu_add_item(store, _("Checksum"), DUPE_MATCH_SUM, dw);
3960         dupe_menu_add_item(store, _("Path"), DUPE_MATCH_PATH, dw);
3961         dupe_menu_add_item(store, _("Similarity (high - 95)"), DUPE_MATCH_SIM_HIGH, dw);
3962         dupe_menu_add_item(store, _("Similarity (med. - 90)"), DUPE_MATCH_SIM_MED, dw);
3963         dupe_menu_add_item(store, _("Similarity (low - 85)"), DUPE_MATCH_SIM_LOW, dw);
3964         dupe_menu_add_item(store, _("Similarity (custom)"), DUPE_MATCH_SIM_CUSTOM, dw);
3965         dupe_menu_add_item(store, _("Name ≠ content"), DUPE_MATCH_NAME_CONTENT, dw);
3966         dupe_menu_add_item(store, _("Name case-insensitive ≠ content"), DUPE_MATCH_NAME_CI_CONTENT, dw);
3967         dupe_menu_add_item(store, _("Show all"), DUPE_MATCH_ALL, dw);
3968
3969         g_signal_connect(G_OBJECT(dw->combo), "changed",
3970                          G_CALLBACK(dupe_menu_type_cb), dw);
3971 }
3972
3973 /*
3974  *-------------------------------------------------------------------
3975  * list view columns
3976  *-------------------------------------------------------------------
3977  */
3978
3979 /* this overrides the low default of a GtkCellRenderer from 100 to CELL_HEIGHT_OVERRIDE, something sane for our purposes */
3980
3981 #define CELL_HEIGHT_OVERRIDE 512
3982
3983 void cell_renderer_height_override(GtkCellRenderer *renderer)
3984 {
3985         GParamSpec *spec;
3986
3987         spec = g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(renderer)), "height");
3988         if (spec && G_IS_PARAM_SPEC_INT(spec))
3989                 {
3990                 GParamSpecInt *spec_int;
3991
3992                 spec_int = G_PARAM_SPEC_INT(spec);
3993                 if (spec_int->maximum < CELL_HEIGHT_OVERRIDE) spec_int->maximum = CELL_HEIGHT_OVERRIDE;
3994                 }
3995 }
3996
3997 static GdkRGBA *dupe_listview_color_shifted(GtkWidget *widget)
3998 {
3999         static GdkRGBA color;
4000         static GdkRGBA color_style;
4001         static GtkWidget *done = nullptr;
4002
4003         if (done != widget)
4004                 {
4005                 GtkStyle *style;
4006
4007                 style = gtk_widget_get_style(widget);
4008                 convert_gdkcolor_to_gdkrgba(&style->base[GTK_STATE_NORMAL], &color_style);
4009
4010                 memcpy(&color, &color_style, sizeof(color));
4011                 shift_color(&color, -1, 0);
4012                 done = widget;
4013                 }
4014
4015         return &color;
4016 }
4017
4018 static void dupe_listview_color_cb(GtkTreeViewColumn *, GtkCellRenderer *cell,
4019                                    GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
4020 {
4021         auto dw = static_cast<DupeWindow *>(data);
4022         gboolean set;
4023
4024         gtk_tree_model_get(tree_model, iter, DUPE_COLUMN_COLOR, &set, -1);
4025         g_object_set(G_OBJECT(cell),
4026                      "cell-background-gdk", dupe_listview_color_shifted(dw->listview),
4027                      "cell-background-set", set, NULL);
4028 }
4029
4030 static void dupe_listview_add_column(DupeWindow *dw, GtkWidget *listview, gint n, const gchar *title, gboolean image, gboolean right_justify)
4031 {
4032         GtkTreeViewColumn *column;
4033         GtkCellRenderer *renderer;
4034
4035         column = gtk_tree_view_column_new();
4036         gtk_tree_view_column_set_title(column, title);
4037         gtk_tree_view_column_set_min_width(column, 4);
4038         gtk_tree_view_column_set_sort_column_id(column, n);
4039
4040         if (n != DUPE_COLUMN_RANK &&
4041             n != DUPE_COLUMN_THUMB)
4042                 {
4043                 gtk_tree_view_column_set_resizable(column, TRUE);
4044                 }
4045
4046         if (!image)
4047                 {
4048                 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
4049                 renderer = gtk_cell_renderer_text_new();
4050                 if (right_justify)
4051                         {
4052                         g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
4053                         }
4054                 gtk_tree_view_column_pack_start(column, renderer, TRUE);
4055                 gtk_tree_view_column_add_attribute(column, renderer, "text", n);
4056                 }
4057         else
4058                 {
4059                 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
4060                 renderer = gtk_cell_renderer_pixbuf_new();
4061                 cell_renderer_height_override(renderer);
4062                 gtk_tree_view_column_pack_start(column, renderer, TRUE);
4063                 gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", n);
4064                 }
4065
4066         if (listview == dw->listview)
4067                 {
4068                 /* sets background before rendering */
4069                 gtk_tree_view_column_set_cell_data_func(column, renderer, dupe_listview_color_cb, dw, nullptr);
4070                 }
4071
4072         gtk_tree_view_append_column(GTK_TREE_VIEW(listview), column);
4073 }
4074
4075 static void dupe_listview_set_height(GtkWidget *listview, gboolean thumb)
4076 {
4077         GtkTreeViewColumn *column;
4078         GtkCellRenderer *cell;
4079         GList *list;
4080
4081         column = gtk_tree_view_get_column(GTK_TREE_VIEW(listview), DUPE_COLUMN_THUMB - 1);
4082         if (!column) return;
4083
4084         gtk_tree_view_column_set_fixed_width(column, (thumb) ? options->thumbnails.max_width : 4);
4085         gtk_tree_view_column_set_visible(column, thumb);
4086
4087         list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
4088         if (!list) return;
4089         cell = static_cast<GtkCellRenderer *>(list->data);
4090         g_list_free(list);
4091
4092         g_object_set(G_OBJECT(cell), "height", (thumb) ? options->thumbnails.max_height : -1, NULL);
4093         gtk_tree_view_columns_autosize(GTK_TREE_VIEW(listview));
4094 }
4095
4096 static void dupe_listview_show_rank(GtkWidget *listview, gboolean rank)
4097 {
4098         GtkTreeViewColumn *column;
4099
4100         column = gtk_tree_view_get_column(GTK_TREE_VIEW(listview), DUPE_COLUMN_RANK - 1);
4101         if (!column) return;
4102
4103         gtk_tree_view_column_set_visible(column, rank);
4104 }
4105
4106 /*
4107  *-------------------------------------------------------------------
4108  * misc cb
4109  *-------------------------------------------------------------------
4110  */
4111
4112 static void dupe_window_show_thumb_cb(GtkWidget *widget, gpointer data)
4113 {
4114         auto dw = static_cast<DupeWindow *>(data);
4115
4116         dw->show_thumbs = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
4117         options->duplicates_thumbnails = dw->show_thumbs;
4118
4119         if (dw->show_thumbs)
4120                 {
4121                 if (!dw->working) dupe_thumb_step(dw);
4122                 }
4123         else
4124                 {
4125                 GtkTreeModel *store;
4126                 GtkTreeIter iter;
4127                 gboolean valid;
4128
4129                 thumb_loader_free(dw->thumb_loader);
4130                 dw->thumb_loader = nullptr;
4131
4132                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview));
4133                 valid = gtk_tree_model_get_iter_first(store, &iter);
4134
4135                 while (valid)
4136                         {
4137                         gtk_list_store_set(GTK_LIST_STORE(store), &iter, DUPE_COLUMN_THUMB, NULL, -1);
4138                         valid = gtk_tree_model_iter_next(store, &iter);
4139                         }
4140                 dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
4141                 }
4142
4143         dupe_listview_set_height(dw->listview, dw->show_thumbs);
4144 }
4145
4146 static void dupe_window_rotation_invariant_cb(GtkWidget *widget, gpointer data)
4147 {
4148         auto dw = static_cast<DupeWindow *>(data);
4149
4150         options->rot_invariant_sim = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
4151         dupe_window_recompare(dw);
4152 }
4153
4154 static void dupe_window_custom_threshold_cb(GtkWidget *widget, gpointer data)
4155 {
4156         auto dw = static_cast<DupeWindow *>(data);
4157         DupeMatchType match_type;
4158         GtkTreeModel *store;
4159         gboolean valid;
4160         GtkTreeIter iter;
4161
4162         options->duplicates_similarity_threshold = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
4163         dw->match_mask = DUPE_MATCH_SIM_CUSTOM;
4164
4165         store = gtk_combo_box_get_model(GTK_COMBO_BOX(dw->combo));
4166         valid = gtk_tree_model_get_iter_first(store, &iter);
4167         while (valid)
4168                 {
4169                 gtk_tree_model_get(store, &iter, DUPE_MENU_COLUMN_MASK, &match_type, -1);
4170                 if (match_type == DUPE_MATCH_SIM_CUSTOM)
4171                         {
4172                         break;
4173                         }
4174                 valid = gtk_tree_model_iter_next(store, &iter);
4175                 }
4176
4177         gtk_combo_box_set_active_iter(GTK_COMBO_BOX(dw->combo), &iter);
4178         dupe_window_recompare(dw);
4179 }
4180
4181 static gboolean dupe_window_keypress_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
4182 {
4183         auto dw = static_cast<DupeWindow *>(data);
4184         gboolean stop_signal = FALSE;
4185         gboolean on_second;
4186         GtkWidget *listview;
4187         GtkTreeModel *store;
4188         GtkTreeSelection *selection;
4189         GList *slist;
4190         DupeItem *di = nullptr;
4191
4192         on_second = gtk_widget_has_focus(dw->second_listview);
4193
4194         if (on_second)
4195                 {
4196                 listview = dw->second_listview;
4197                 }
4198         else
4199                 {
4200                 listview = dw->listview;
4201                 }
4202
4203         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
4204         slist = gtk_tree_selection_get_selected_rows(selection, &store);
4205         if (slist)
4206                 {
4207                 GtkTreePath *tpath;
4208                 GtkTreeIter iter;
4209                 GList *last;
4210
4211                 last = g_list_last(slist);
4212                 tpath = static_cast<GtkTreePath *>(last->data);
4213
4214                 /* last is newest selected file */
4215                 gtk_tree_model_get_iter(store, &iter, tpath);
4216                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
4217                 }
4218         g_list_free_full(slist, reinterpret_cast<GDestroyNotify>(gtk_tree_path_free));
4219
4220         if (event->state & GDK_CONTROL_MASK)
4221                 {
4222                 if (!on_second)
4223                         {
4224                         stop_signal = TRUE;
4225                         switch (event->keyval)
4226                                 {
4227                                 case '1':
4228                                 case '2':
4229                                 case '3':
4230                                 case '4':
4231                                 case '5':
4232                                 case '6':
4233                                 case '7':
4234                                 case '8':
4235                                 case '9':
4236                                 case '0':
4237                                         break;
4238                                 case 'C': case 'c':
4239                                         file_util_copy(nullptr, dupe_listview_get_selection(dw, listview),
4240                                                        nullptr, dw->window);
4241                                         break;
4242                                 case 'M': case 'm':
4243                                         file_util_move(nullptr, dupe_listview_get_selection(dw, listview),
4244                                                        nullptr, dw->window);
4245                                         break;
4246                                 case 'R': case 'r':
4247                                         file_util_rename(nullptr, dupe_listview_get_selection(dw, listview), dw->window);
4248                                         break;
4249                                 case 'D': case 'd':
4250                                         options->file_ops.safe_delete_enable = TRUE;
4251                                         file_util_delete(nullptr, dupe_listview_get_selection(dw, listview), dw->window);
4252                                         break;
4253                                 default:
4254                                         stop_signal = FALSE;
4255                                         break;
4256                                 }
4257                         }
4258
4259                 if (!stop_signal)
4260                         {
4261                         stop_signal = TRUE;
4262                         switch (event->keyval)
4263                                 {
4264                                 case 'A': case 'a':
4265                                         if (event->state & GDK_SHIFT_MASK)
4266                                                 {
4267                                                 gtk_tree_selection_unselect_all(selection);
4268                                                 }
4269                                         else
4270                                                 {
4271                                                 gtk_tree_selection_select_all(selection);
4272                                                 }
4273                                         break;
4274                                 case GDK_KEY_Delete: case GDK_KEY_KP_Delete:
4275                                         if (on_second)
4276                                                 {
4277                                                 dupe_second_clear(dw);
4278                                                 dupe_window_recompare(dw);
4279                                                 }
4280                                         else
4281                                                 {
4282                                                 dupe_window_clear(dw);
4283                                                 }
4284                                         break;
4285                                 case 'L': case 'l':
4286                                         dupe_window_append_file_list(dw, FALSE);
4287                                         break;
4288                                 case 'T': case 't':
4289                                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dw->button_thumbs),
4290                                                 !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dw->button_thumbs)));
4291                                         break;
4292                                 case 'W': case 'w':
4293                                         dupe_window_close(dw);
4294                                         break;
4295                                 default:
4296                                         stop_signal = FALSE;
4297                                         break;
4298                                 }
4299                         }
4300                 }
4301         else if (event->state & GDK_SHIFT_MASK)
4302                 {
4303                 stop_signal = TRUE;
4304                 switch (event->keyval)
4305                         {
4306                         case GDK_KEY_Delete:
4307                         case GDK_KEY_KP_Delete:
4308                                 options->file_ops.safe_delete_enable = FALSE;
4309                                 file_util_delete_notify_done(nullptr, dupe_listview_get_selection(dw, dw->listview), dw->window, delete_finished_cb, dw);
4310                                 break;
4311                         default:
4312                                 stop_signal = FALSE;
4313                                 break;
4314                         }
4315                 }
4316         else
4317                 {
4318                 stop_signal = TRUE;
4319                 switch (event->keyval)
4320                         {
4321                         case GDK_KEY_Return: case GDK_KEY_KP_Enter:
4322                                 dupe_menu_view(dw, di, listview, FALSE);
4323                                 break;
4324                         case 'V': case 'v':
4325                                 dupe_menu_view(dw, di, listview, TRUE);
4326                                 break;
4327                         case GDK_KEY_Delete: case GDK_KEY_KP_Delete:
4328                                 dupe_window_remove_selection(dw, listview);
4329                                 break;
4330                         case 'C': case 'c':
4331                                 if (!on_second)
4332                                         {
4333                                         dupe_window_collection_from_selection(dw);
4334                                         }
4335                                 break;
4336                         case '0':
4337                                 options->duplicates_select_type = DUPE_SELECT_NONE;
4338                                 dupe_listview_select_dupes(dw, DUPE_SELECT_NONE);
4339                                 break;
4340                         case '1':
4341                                 options->duplicates_select_type = DUPE_SELECT_GROUP1;
4342                                 dupe_listview_select_dupes(dw, DUPE_SELECT_GROUP1);
4343                                 break;
4344                         case '2':
4345                                 options->duplicates_select_type = DUPE_SELECT_GROUP2;
4346                                 dupe_listview_select_dupes(dw, DUPE_SELECT_GROUP2);
4347                                 break;
4348                         case GDK_KEY_Menu:
4349                         case GDK_KEY_F10:
4350                                 if (!on_second)
4351                                         {
4352                                         GtkWidget *menu;
4353
4354                                         menu = dupe_menu_popup_main(dw, di);
4355                                         gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER, nullptr);
4356                                         }
4357                                 else
4358                                         {
4359                                         GtkWidget *menu;
4360
4361                                         menu = dupe_menu_popup_second(dw, di);
4362                                         gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER, nullptr);
4363                                         }
4364                                 break;
4365                         default:
4366                                 stop_signal = FALSE;
4367                                 break;
4368                         }
4369                 }
4370         if (!stop_signal && is_help_key(event))
4371                 {
4372                 help_window_show("GuideImageSearchFindingDuplicates.html");
4373                 stop_signal = TRUE;
4374                 }
4375
4376         return stop_signal;
4377 }
4378
4379
4380 void dupe_window_clear(DupeWindow *dw)
4381 {
4382         GtkListStore *store;
4383
4384         dupe_check_stop(dw);
4385
4386         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
4387         gtk_list_store_clear(store);
4388         gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dw->listview));
4389
4390         g_list_free(dw->dupes);
4391         dw->dupes = nullptr;
4392
4393         g_list_free_full(dw->list, reinterpret_cast<GDestroyNotify>(dupe_item_free));
4394         dw->list = nullptr;
4395         dw->set_count = 0;
4396
4397         dupe_match_reset_list(dw->second_list);
4398
4399         dupe_window_update_count(dw, FALSE);
4400         dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
4401 }
4402
4403 static void dupe_window_get_geometry(DupeWindow *dw)
4404 {
4405         GdkWindow *window;
4406         LayoutWindow *lw = nullptr;
4407
4408         layout_valid(&lw);
4409
4410         if (!dw || !lw) return;
4411
4412         window = gtk_widget_get_window(dw->window);
4413         gdk_window_get_position(window, &lw->options.dupe_window.x, &lw->options.dupe_window.y);
4414         lw->options.dupe_window.w = gdk_window_get_width(window);
4415         lw->options.dupe_window.h = gdk_window_get_height(window);
4416 }
4417
4418 void dupe_window_close(DupeWindow *dw)
4419 {
4420         dupe_check_stop(dw);
4421
4422         dupe_window_get_geometry(dw);
4423
4424         dupe_window_list = g_list_remove(dupe_window_list, dw);
4425         gq_gtk_widget_destroy(dw->window);
4426
4427         g_list_free(dw->dupes);
4428         g_list_free_full(dw->list, reinterpret_cast<GDestroyNotify>(dupe_item_free));
4429
4430         g_list_free_full(dw->second_list, reinterpret_cast<GDestroyNotify>(dupe_item_free));
4431
4432         file_data_unregister_notify_func(dupe_notify_cb, dw);
4433
4434         g_thread_pool_free(dw->dupe_comparison_thread_pool, TRUE, TRUE);
4435
4436         g_free(dw);
4437 }
4438
4439 static gint dupe_window_close_cb(GtkWidget *, gpointer data)
4440 {
4441         auto dw = static_cast<DupeWindow *>(data);
4442
4443         dupe_window_close(dw);
4444
4445         return TRUE;
4446 }
4447
4448 static gint dupe_window_delete(GtkWidget *, GdkEvent *, gpointer data)
4449 {
4450         auto dw = static_cast<DupeWindow *>(data);
4451         dupe_window_close(dw);
4452
4453         return TRUE;
4454 }
4455
4456 static void dupe_help_cb(GtkAction *, gpointer)
4457 {
4458         help_window_show("GuideImageSearchFindingDuplicates.html");
4459 }
4460
4461 static gint default_sort_cb(GtkTreeModel *, GtkTreeIter *, GtkTreeIter *, gpointer)
4462 {
4463         return 0;
4464 }
4465
4466 static gint column_sort_cb(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer data)
4467 {
4468         auto sortable = static_cast<GtkTreeSortable *>(data);
4469         gint ret = 0;
4470         gchar *rank_str_a, *rank_str_b;
4471         gint rank_int_a;
4472         gint rank_int_b;
4473         gint group_a;
4474         gint group_b;
4475         gint sort_column_id;
4476         GtkSortType sort_order;
4477         DupeItem *di_a;
4478         DupeItem *di_b;
4479
4480         gtk_tree_sortable_get_sort_column_id(sortable, &sort_column_id, &sort_order);
4481
4482         gtk_tree_model_get(model, a, DUPE_COLUMN_RANK, &rank_str_a, DUPE_COLUMN_SET, &group_a, DUPE_COLUMN_POINTER, &di_a, -1);
4483
4484         gtk_tree_model_get(model, b, DUPE_COLUMN_RANK, &rank_str_b, DUPE_COLUMN_SET, &group_b, DUPE_COLUMN_POINTER, &di_b, -1);
4485
4486         if (group_a == group_b)
4487                 {
4488                 switch (sort_column_id)
4489                         {
4490                         case DUPE_COLUMN_NAME:
4491                                 ret = utf8_compare(di_a->fd->name, di_b->fd->name, TRUE);
4492                                 break;
4493                         case DUPE_COLUMN_SIZE:
4494                                 if (di_a->fd->size == di_b->fd->size)
4495                                         {
4496                                         ret = 0;
4497                                         }
4498                                 else
4499                                         {
4500                                         ret = (di_a->fd->size > di_b->fd->size) ? 1 : -1;
4501                                         }
4502                                 break;
4503                         case DUPE_COLUMN_DATE:
4504                                 if (di_a->fd->date == di_b->fd->date)
4505                                         {
4506                                         ret = 0;
4507                                         }
4508                                 else
4509                                         {
4510                                         ret = (di_a->fd->date > di_b->fd->date) ? 1 : -1;
4511                                         }
4512                                 break;
4513                         case DUPE_COLUMN_DIMENSIONS:
4514                                 if ((di_a->width == di_b->width) && (di_a->height == di_b->height))
4515                                         {
4516                                         ret = 0;
4517                                         }
4518                                 else
4519                                         {
4520                                         ret = ((di_a->width * di_a->height) > (di_b->width * di_b->height)) ? 1 : -1;
4521                                         }
4522                                 break;
4523                         case DUPE_COLUMN_RANK:
4524                                 rank_int_a = atoi(rank_str_a);
4525                                 rank_int_b = atoi(rank_str_b);
4526                                 if (rank_int_a == 0) rank_int_a = 101;
4527                                 if (rank_int_b == 0) rank_int_b = 101;
4528
4529                                 if (rank_int_a == rank_int_b)
4530                                         {
4531                                         ret = 0;
4532                                         }
4533                                 else
4534                                         {
4535                                         ret = (rank_int_a > rank_int_b) ? 1 : -1;
4536                                         }
4537                                 break;
4538                         case DUPE_COLUMN_PATH:
4539                                 ret = utf8_compare(di_a->fd->path, di_b->fd->path, TRUE);
4540                                 break;
4541                         }
4542                 }
4543         else if (group_a < group_b)
4544                 {
4545                 ret = (sort_order == GTK_SORT_ASCENDING) ? 1 : -1;
4546                 }
4547         else
4548                 {
4549                 ret = (sort_order == GTK_SORT_ASCENDING) ? -1 : 1;
4550                 }
4551
4552         return ret;
4553 }
4554
4555 static void column_clicked_cb(GtkWidget *,  gpointer data)
4556 {
4557         auto dw = static_cast<DupeWindow *>(data);
4558
4559         options->duplicates_match = DUPE_SELECT_NONE;
4560         dupe_listview_select_dupes(dw, DUPE_SELECT_NONE);
4561 }
4562
4563 /* collection and files can be NULL */
4564 DupeWindow *dupe_window_new()
4565 {
4566         DupeWindow *dw;
4567         GtkWidget *vbox;
4568         GtkWidget *hbox;
4569         GtkWidget *scrolled;
4570         GtkWidget *frame;
4571         GtkWidget *status_box;
4572         GtkWidget *controls_box;
4573         GtkWidget *button_box;
4574         GtkWidget *label;
4575         GtkWidget *button;
4576         GtkListStore *store;
4577         GtkTreeSelection *selection;
4578         GdkGeometry geometry;
4579         LayoutWindow *lw = nullptr;
4580
4581         layout_valid(&lw);
4582
4583         dw = g_new0(DupeWindow, 1);
4584         dw->add_files_queue = nullptr;
4585         dw->add_files_queue_id = 0;
4586
4587         dw->match_mask = DUPE_MATCH_NAME;
4588         if (options->duplicates_match == DUPE_MATCH_NAME) dw->match_mask = DUPE_MATCH_NAME;
4589         if (options->duplicates_match == DUPE_MATCH_SIZE) dw->match_mask = DUPE_MATCH_SIZE;
4590         if (options->duplicates_match == DUPE_MATCH_DATE) dw->match_mask = DUPE_MATCH_DATE;
4591         if (options->duplicates_match == DUPE_MATCH_DIM) dw->match_mask = DUPE_MATCH_DIM;
4592         if (options->duplicates_match == DUPE_MATCH_SUM) dw->match_mask = DUPE_MATCH_SUM;
4593         if (options->duplicates_match == DUPE_MATCH_PATH) dw->match_mask = DUPE_MATCH_PATH;
4594         if (options->duplicates_match == DUPE_MATCH_SIM_HIGH) dw->match_mask = DUPE_MATCH_SIM_HIGH;
4595         if (options->duplicates_match == DUPE_MATCH_SIM_MED) dw->match_mask = DUPE_MATCH_SIM_MED;
4596         if (options->duplicates_match == DUPE_MATCH_SIM_LOW) dw->match_mask = DUPE_MATCH_SIM_LOW;
4597         if (options->duplicates_match == DUPE_MATCH_SIM_CUSTOM) dw->match_mask = DUPE_MATCH_SIM_CUSTOM;
4598         if (options->duplicates_match == DUPE_MATCH_NAME_CI) dw->match_mask = DUPE_MATCH_NAME_CI;
4599         if (options->duplicates_match == DUPE_MATCH_NAME_CONTENT) dw->match_mask = DUPE_MATCH_NAME_CONTENT;
4600         if (options->duplicates_match == DUPE_MATCH_NAME_CI_CONTENT) dw->match_mask = DUPE_MATCH_NAME_CI_CONTENT;
4601         if (options->duplicates_match == DUPE_MATCH_ALL) dw->match_mask = DUPE_MATCH_ALL;
4602
4603         dw->window = window_new("dupe", nullptr, nullptr, _("Find duplicates"));
4604         DEBUG_NAME(dw->window);
4605
4606         geometry.min_width = DEFAULT_MINIMAL_WINDOW_SIZE;
4607         geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
4608         geometry.base_width = DUPE_DEF_WIDTH;
4609         geometry.base_height = DUPE_DEF_HEIGHT;
4610         gtk_window_set_geometry_hints(GTK_WINDOW(dw->window), nullptr, &geometry,
4611                                       static_cast<GdkWindowHints>(GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE));
4612
4613         if (lw && options->save_window_positions)
4614                 {
4615                 gtk_window_set_default_size(GTK_WINDOW(dw->window), lw->options.dupe_window.w, lw->options.dupe_window.h);
4616                 gtk_window_move(GTK_WINDOW(dw->window), lw->options.dupe_window.x, lw->options.dupe_window.y);
4617                 }
4618         else
4619                 {
4620                 gtk_window_set_default_size(GTK_WINDOW(dw->window), DUPE_DEF_WIDTH, DUPE_DEF_HEIGHT);
4621                 }
4622
4623         gtk_window_set_resizable(GTK_WINDOW(dw->window), TRUE);
4624         gtk_container_set_border_width(GTK_CONTAINER(dw->window), 0);
4625
4626         g_signal_connect(G_OBJECT(dw->window), "delete_event",
4627                          G_CALLBACK(dupe_window_delete), dw);
4628         g_signal_connect(G_OBJECT(dw->window), "key_press_event",
4629                          G_CALLBACK(dupe_window_keypress_cb), dw);
4630
4631         vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
4632         gq_gtk_container_add(GTK_WIDGET(dw->window), vbox);
4633         gtk_widget_show(vbox);
4634
4635         dw->table = gtk_grid_new();
4636         gq_gtk_box_pack_start(GTK_BOX(vbox), dw->table, TRUE, TRUE, 0);
4637         gtk_grid_set_row_homogeneous(GTK_GRID(dw->table), TRUE);
4638         gtk_grid_set_column_homogeneous(GTK_GRID(dw->table), TRUE);
4639         gtk_widget_show(dw->table);
4640
4641         scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
4642         gq_gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
4643         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
4644         gtk_grid_attach(GTK_GRID(dw->table), scrolled, 0, 0, 2, 1);
4645         gtk_widget_show(scrolled);
4646
4647         store = gtk_list_store_new(DUPE_COLUMN_COUNT, G_TYPE_POINTER, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_INT, G_TYPE_INT);
4648         dw->listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
4649         g_object_unref(store);
4650
4651         dw->sortable = GTK_TREE_SORTABLE(store);
4652
4653         gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_RANK, column_sort_cb, dw->sortable, nullptr);
4654         gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_SET, default_sort_cb, dw->sortable, nullptr);
4655         gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_THUMB, default_sort_cb, dw->sortable, nullptr);
4656         gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_NAME, column_sort_cb, dw->sortable, nullptr);
4657         gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_SIZE, column_sort_cb, dw->sortable, nullptr);
4658         gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_DATE, column_sort_cb, dw->sortable, nullptr);
4659         gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_DIMENSIONS, column_sort_cb, dw->sortable, nullptr);
4660         gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_PATH, column_sort_cb, dw->sortable, nullptr);
4661
4662         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->listview));
4663         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_MULTIPLE);
4664         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(dw->listview), TRUE);
4665         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(dw->listview), FALSE);
4666
4667         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_RANK, _("Rank"), FALSE, TRUE);
4668         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_THUMB, _("Thumb"), TRUE, FALSE);
4669         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_NAME, _("Name"), FALSE, FALSE);
4670         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_SIZE, _("Size"), FALSE, TRUE);
4671         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_DATE, _("Date"), FALSE, TRUE);
4672         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_DIMENSIONS, _("Dimensions"), FALSE, FALSE);
4673         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_PATH, _("Path"), FALSE, FALSE);
4674         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_SET, _("Set"), FALSE, FALSE);
4675
4676         g_signal_connect(gtk_tree_view_get_column(GTK_TREE_VIEW(dw->listview), DUPE_COLUMN_RANK - 1), "clicked", (GCallback)column_clicked_cb, dw);
4677         g_signal_connect(gtk_tree_view_get_column(GTK_TREE_VIEW(dw->listview), DUPE_COLUMN_NAME - 1), "clicked", (GCallback)column_clicked_cb, dw);
4678         g_signal_connect(gtk_tree_view_get_column(GTK_TREE_VIEW(dw->listview), DUPE_COLUMN_SIZE - 1), "clicked", (GCallback)column_clicked_cb, dw);
4679         g_signal_connect(gtk_tree_view_get_column(GTK_TREE_VIEW(dw->listview), DUPE_COLUMN_DATE - 1), "clicked", (GCallback)column_clicked_cb, dw);
4680         g_signal_connect(gtk_tree_view_get_column(GTK_TREE_VIEW(dw->listview), DUPE_COLUMN_DIMENSIONS - 1), "clicked", (GCallback)column_clicked_cb, dw);
4681         g_signal_connect(gtk_tree_view_get_column(GTK_TREE_VIEW(dw->listview), DUPE_COLUMN_PATH - 1), "clicked", (GCallback)column_clicked_cb, dw);
4682
4683         gq_gtk_container_add(GTK_WIDGET(scrolled), dw->listview);
4684         gtk_widget_show(dw->listview);
4685
4686         dw->second_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
4687         gtk_grid_attach(GTK_GRID(dw->table), dw->second_vbox, 2, 0, 3, 1);
4688         if (dw->second_set)
4689                 {
4690                 gtk_grid_set_column_spacing(GTK_GRID(dw->table), PREF_PAD_GAP);
4691                 gtk_widget_show(dw->second_vbox);
4692                 }
4693         else
4694                 {
4695                 gtk_grid_set_column_spacing(GTK_GRID(dw->table), 0);
4696                 }
4697
4698         scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
4699         gq_gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
4700         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
4701         gq_gtk_box_pack_start(GTK_BOX(dw->second_vbox), scrolled, TRUE, TRUE, 0);
4702         gtk_widget_show(scrolled);
4703
4704         store = gtk_list_store_new(2, G_TYPE_POINTER, G_TYPE_STRING);
4705         dw->second_listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
4706
4707         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->second_listview));
4708         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_MULTIPLE);
4709
4710         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(dw->second_listview), TRUE);
4711         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(dw->second_listview), FALSE);
4712
4713         dupe_listview_add_column(dw, dw->second_listview, 1, _("Compare to:"), FALSE, FALSE);
4714
4715         gq_gtk_container_add(GTK_WIDGET(scrolled), dw->second_listview);
4716         gtk_widget_show(dw->second_listview);
4717
4718         dw->second_status_label = gtk_label_new("");
4719         gq_gtk_box_pack_start(GTK_BOX(dw->second_vbox), dw->second_status_label, FALSE, FALSE, 0);
4720         gtk_widget_show(dw->second_status_label);
4721
4722         pref_line(dw->second_vbox, GTK_ORIENTATION_HORIZONTAL);
4723
4724         status_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
4725         gq_gtk_box_pack_start(GTK_BOX(vbox), status_box, FALSE, FALSE, 0);
4726         gtk_widget_show(status_box);
4727
4728         frame = gtk_frame_new(nullptr);
4729         DEBUG_NAME(frame);
4730         gq_gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
4731         gq_gtk_box_pack_start(GTK_BOX(status_box), frame, TRUE, TRUE, 0);
4732         gtk_widget_show(frame);
4733
4734         dw->status_label = gtk_label_new("");
4735         gq_gtk_container_add(GTK_WIDGET(frame), dw->status_label);
4736         gtk_widget_show(dw->status_label);
4737
4738         dw->extra_label = gtk_progress_bar_new();
4739         gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dw->extra_label), 0.0);
4740         gtk_progress_bar_set_text(GTK_PROGRESS_BAR(dw->extra_label), "");
4741         gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(dw->extra_label), TRUE);
4742         gq_gtk_box_pack_start(GTK_BOX(status_box), dw->extra_label, FALSE, FALSE, PREF_PAD_SPACE);
4743         gtk_widget_show(dw->extra_label);
4744
4745         controls_box = pref_box_new(vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
4746         dw->controls_box = controls_box;
4747
4748         dw->button_thumbs = gtk_check_button_new_with_label(_("Thumbnails"));
4749         gtk_widget_set_tooltip_text(GTK_WIDGET(dw->button_thumbs), "Ctrl-T");
4750         dw->show_thumbs = options->duplicates_thumbnails;
4751         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dw->button_thumbs), dw->show_thumbs);
4752         g_signal_connect(G_OBJECT(dw->button_thumbs), "toggled",
4753                          G_CALLBACK(dupe_window_show_thumb_cb), dw);
4754         gq_gtk_box_pack_start(GTK_BOX(controls_box), dw->button_thumbs, FALSE, FALSE, PREF_PAD_SPACE);
4755         gtk_widget_show(dw->button_thumbs);
4756
4757         label = gtk_label_new(_("Compare by:"));
4758         gq_gtk_box_pack_start(GTK_BOX(controls_box), label, FALSE, FALSE, PREF_PAD_SPACE);
4759         gtk_widget_show(label);
4760
4761         dupe_menu_setup(dw);
4762         gq_gtk_box_pack_start(GTK_BOX(controls_box), dw->combo, FALSE, FALSE, 0);
4763         gtk_widget_show(dw->combo);
4764
4765         label = gtk_label_new(_("Custom Threshold"));
4766         gq_gtk_box_pack_start(GTK_BOX(controls_box), label, FALSE, FALSE, PREF_PAD_SPACE);
4767         gtk_widget_show(label);
4768         dw->custom_threshold = gtk_spin_button_new_with_range(1, 100, 1);
4769         gtk_widget_set_tooltip_text(GTK_WIDGET(dw->custom_threshold), "Custom similarity threshold\n(Use tab key to set value)");
4770         gtk_spin_button_set_value(GTK_SPIN_BUTTON(dw->custom_threshold), options->duplicates_similarity_threshold);
4771         g_signal_connect(G_OBJECT(dw->custom_threshold), "value_changed", G_CALLBACK(dupe_window_custom_threshold_cb), dw);
4772         gq_gtk_box_pack_start(GTK_BOX(controls_box), dw->custom_threshold, FALSE, FALSE, PREF_PAD_SPACE);
4773         gtk_widget_show(dw->custom_threshold);
4774
4775         button = gtk_check_button_new_with_label(_("Sort"));
4776         gtk_widget_set_tooltip_text(GTK_WIDGET(button), "Sort by group totals");
4777         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), options->sort_totals);
4778         g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(dupe_sort_totals_toggle_cb), dw);
4779         gq_gtk_box_pack_start(GTK_BOX(controls_box), button, FALSE, FALSE, PREF_PAD_SPACE);
4780         gtk_widget_show(button);
4781
4782         dw->button_rotation_invariant = gtk_check_button_new_with_label(_("Ignore Orientation"));
4783         gtk_widget_set_tooltip_text(GTK_WIDGET(dw->button_rotation_invariant), "Ignore image orientation");
4784         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dw->button_rotation_invariant), options->rot_invariant_sim);
4785         g_signal_connect(G_OBJECT(dw->button_rotation_invariant), "toggled",
4786                          G_CALLBACK(dupe_window_rotation_invariant_cb), dw);
4787         gq_gtk_box_pack_start(GTK_BOX(controls_box), dw->button_rotation_invariant, FALSE, FALSE, PREF_PAD_SPACE);
4788         gtk_widget_show(dw->button_rotation_invariant);
4789
4790         button = gtk_check_button_new_with_label(_("Compare two file sets"));
4791         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), dw->second_set);
4792         g_signal_connect(G_OBJECT(button), "toggled",
4793                          G_CALLBACK(dupe_second_set_toggle_cb), dw);
4794         gq_gtk_box_pack_start(GTK_BOX(controls_box), button, FALSE, FALSE, PREF_PAD_SPACE);
4795         gtk_widget_show(button);
4796
4797         button_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
4798         gq_gtk_box_pack_start(GTK_BOX(vbox), button_box, FALSE, FALSE, 0);
4799         gtk_widget_show(button_box);
4800
4801         hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
4802         gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
4803         gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_SPACE);
4804         gq_gtk_box_pack_end(GTK_BOX(button_box), hbox, FALSE, FALSE, 0);
4805         gtk_widget_show(hbox);
4806
4807         button = pref_button_new(nullptr, GQ_ICON_HELP, _("Help"), G_CALLBACK(dupe_help_cb), nullptr);
4808         gtk_widget_set_tooltip_text(GTK_WIDGET(button), "F1");
4809         gq_gtk_container_add(GTK_WIDGET(hbox), button);
4810         gtk_widget_set_can_default(button, TRUE);
4811         gtk_widget_show(button);
4812
4813         button = pref_button_new(nullptr, GQ_ICON_STOP, _("Stop"), G_CALLBACK(dupe_check_stop_cb), dw);
4814         gq_gtk_container_add(GTK_WIDGET(hbox), button);
4815         gtk_widget_set_can_default(button, TRUE);
4816         gtk_widget_show(button);
4817
4818         button = pref_button_new(nullptr, GQ_ICON_CLOSE, _("Close"), G_CALLBACK(dupe_window_close_cb), dw);
4819         gtk_widget_set_tooltip_text(GTK_WIDGET(button), "Ctrl-W");
4820         gq_gtk_container_add(GTK_WIDGET(hbox), button);
4821         gtk_widget_set_can_default(button, TRUE);
4822         gtk_widget_grab_default(button);
4823         gtk_widget_show(button);
4824         dupe_dnd_init(dw);
4825
4826         /* order is important here, dnd_init should be seeing mouse
4827          * presses before we possibly handle (and stop) the signal
4828          */
4829         g_signal_connect(G_OBJECT(dw->listview), "button_press_event",
4830                          G_CALLBACK(dupe_listview_press_cb), dw);
4831         g_signal_connect(G_OBJECT(dw->listview), "button_release_event",
4832                          G_CALLBACK(dupe_listview_release_cb), dw);
4833         g_signal_connect(G_OBJECT(dw->second_listview), "button_press_event",
4834                          G_CALLBACK(dupe_listview_press_cb), dw);
4835         g_signal_connect(G_OBJECT(dw->second_listview), "button_release_event",
4836                          G_CALLBACK(dupe_listview_release_cb), dw);
4837
4838         gtk_widget_show(dw->window);
4839
4840         dupe_listview_set_height(dw->listview, dw->show_thumbs);
4841         g_signal_emit_by_name(G_OBJECT(dw->combo), "changed");
4842
4843         dupe_window_update_count(dw, TRUE);
4844         dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
4845
4846         dupe_window_list = g_list_append(dupe_window_list, dw);
4847
4848         file_data_register_notify_func(dupe_notify_cb, dw, NOTIFY_PRIORITY_MEDIUM);
4849
4850         g_mutex_init(&dw->thread_count_mutex);
4851         g_mutex_init(&dw->search_matches_mutex);
4852         dw->dupe_comparison_thread_pool = g_thread_pool_new(dupe_comparison_func, dw, options->threads.duplicates, FALSE, nullptr);
4853
4854         return dw;
4855 }
4856
4857 /*
4858  *-------------------------------------------------------------------
4859  * dnd confirm dir
4860  *-------------------------------------------------------------------
4861  */
4862
4863 struct CDupeConfirmD {
4864         DupeWindow *dw;
4865         GList *list;
4866 };
4867
4868 static void confirm_dir_list_cancel(GtkWidget *, gpointer)
4869 {
4870         /* do nothing */
4871 }
4872
4873 static void confirm_dir_list_add(GtkWidget *, gpointer data)
4874 {
4875         auto d = static_cast<CDupeConfirmD *>(data);
4876         GList *work;
4877
4878         dupe_window_add_files(d->dw, d->list, FALSE);
4879
4880         work = d->list;
4881         while (work)
4882                 {
4883                 auto fd = static_cast<FileData *>(work->data);
4884                 work = work->next;
4885                 if (isdir(fd->path))
4886                         {
4887                         GList *list;
4888
4889                         filelist_read(fd, &list, nullptr);
4890                         list = filelist_filter(list, FALSE);
4891                         if (list)
4892                                 {
4893                                 dupe_window_add_files(d->dw, list, FALSE);
4894                                 filelist_free(list);
4895                                 }
4896                         }
4897                 }
4898 }
4899
4900 static void confirm_dir_list_recurse(GtkWidget *, gpointer data)
4901 {
4902         auto d = static_cast<CDupeConfirmD *>(data);
4903         dupe_window_add_files(d->dw, d->list, TRUE);
4904 }
4905
4906 static void confirm_dir_list_skip(GtkWidget *, gpointer data)
4907 {
4908         auto d = static_cast<CDupeConfirmD *>(data);
4909         dupe_window_add_files(d->dw, d->list, FALSE);
4910 }
4911
4912 static void confirm_dir_list_destroy(GtkWidget *, gpointer data)
4913 {
4914         auto d = static_cast<CDupeConfirmD *>(data);
4915         filelist_free(d->list);
4916         g_free(d);
4917 }
4918
4919 static GtkWidget *dupe_confirm_dir_list(DupeWindow *dw, GList *list)
4920 {
4921         GtkWidget *menu;
4922         CDupeConfirmD *d;
4923
4924         d = g_new0(CDupeConfirmD, 1);
4925         d->dw = dw;
4926         d->list = list;
4927
4928         menu = popup_menu_short_lived();
4929         g_signal_connect(G_OBJECT(menu), "destroy",
4930                          G_CALLBACK(confirm_dir_list_destroy), d);
4931
4932         menu_item_add_stock(menu, _("Dropped list includes folders."), GQ_ICON_DND, nullptr, nullptr);
4933         menu_item_add_divider(menu);
4934         menu_item_add_icon(menu, _("_Add contents"), GQ_ICON_OK, G_CALLBACK(confirm_dir_list_add), d);
4935         menu_item_add_icon(menu, _("Add contents _recursive"), GQ_ICON_ADD, G_CALLBACK(confirm_dir_list_recurse), d);
4936         menu_item_add_icon(menu, _("_Skip folders"), GQ_ICON_REMOVE, G_CALLBACK(confirm_dir_list_skip), d);
4937         menu_item_add_divider(menu);
4938         menu_item_add_icon(menu, _("Cancel"), GQ_ICON_CANCEL, G_CALLBACK(confirm_dir_list_cancel), d);
4939
4940         return menu;
4941 }
4942
4943 /*
4944  *-------------------------------------------------------------------
4945  * dnd
4946  *-------------------------------------------------------------------
4947  */
4948
4949 static GtkTargetEntry dupe_drag_types[] = {
4950         { const_cast<gchar *>("text/uri-list"), 0, TARGET_URI_LIST },
4951         { const_cast<gchar *>("text/plain"), 0, TARGET_TEXT_PLAIN }
4952 };
4953 static gint n_dupe_drag_types = 2;
4954
4955 static GtkTargetEntry dupe_drop_types[] = {
4956         { const_cast<gchar *>(TARGET_APP_COLLECTION_MEMBER_STRING), 0, TARGET_APP_COLLECTION_MEMBER },
4957         { const_cast<gchar *>("text/uri-list"), 0, TARGET_URI_LIST }
4958 };
4959 static gint n_dupe_drop_types = 2;
4960
4961 static void dupe_dnd_data_set(GtkWidget *widget, GdkDragContext *,
4962                               GtkSelectionData *selection_data, guint info,
4963                               guint, gpointer data)
4964 {
4965         auto dw = static_cast<DupeWindow *>(data);
4966         GList *list;
4967
4968         switch (info)
4969                 {
4970                 case TARGET_URI_LIST:
4971                 case TARGET_TEXT_PLAIN:
4972                         list = dupe_listview_get_selection(dw, widget);
4973                         if (!list) return;
4974                         uri_selection_data_set_uris_from_filelist(selection_data, list);
4975                         filelist_free(list);
4976                         break;
4977                 default:
4978                         break;
4979                 }
4980 }
4981
4982 static void dupe_dnd_data_get(GtkWidget *widget, GdkDragContext *context,
4983                               gint, gint,
4984                               GtkSelectionData *selection_data, guint info,
4985                               guint, gpointer data)
4986 {
4987         auto dw = static_cast<DupeWindow *>(data);
4988         GtkWidget *source;
4989         GList *list = nullptr;
4990         GList *work;
4991
4992         if (dw->add_files_queue_id > 0)
4993                 {
4994                 warning_dialog(_("Find duplicates"), _("Please wait for the current file selection to be loaded."), GQ_ICON_DIALOG_INFO, dw->window);
4995
4996                 return;
4997                 }
4998
4999         source = gtk_drag_get_source_widget(context);
5000         if (source == dw->listview || source == dw->second_listview) return;
5001
5002         dw->second_drop = (dw->second_set && widget == dw->second_listview);
5003
5004         switch (info)
5005                 {
5006                 case TARGET_APP_COLLECTION_MEMBER:
5007                         collection_from_dnd_data(reinterpret_cast<const gchar *>(gtk_selection_data_get_data(selection_data)), &list, nullptr);
5008                         break;
5009                 case TARGET_URI_LIST:
5010                         list = uri_filelist_from_gtk_selection_data(selection_data);
5011                         work = list;
5012                         while (work)
5013                                 {
5014                                 auto fd = static_cast<FileData *>(work->data);
5015                                 if (isdir(fd->path))
5016                                         {
5017                                         GtkWidget *menu;
5018                                         menu = dupe_confirm_dir_list(dw, list);
5019                                         gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
5020                                         return;
5021                                         }
5022                                 work = work->next;
5023                                 }
5024                         break;
5025                 default:
5026                         list = nullptr;
5027                         break;
5028                 }
5029
5030         if (list)
5031                 {
5032                 dupe_window_add_files(dw, list, FALSE);
5033                 filelist_free(list);
5034                 }
5035 }
5036
5037 static void dupe_dest_set(GtkWidget *widget, gboolean enable)
5038 {
5039         if (enable)
5040                 {
5041                 gtk_drag_dest_set(widget,
5042                         static_cast<GtkDestDefaults>(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP),
5043                         dupe_drop_types, n_dupe_drop_types,
5044                         static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_ASK));
5045
5046                 }
5047         else
5048                 {
5049                 gtk_drag_dest_unset(widget);
5050                 }
5051 }
5052
5053 static void dupe_dnd_begin(GtkWidget *widget, GdkDragContext *context, gpointer data)
5054 {
5055         auto dw = static_cast<DupeWindow *>(data);
5056         dupe_dest_set(dw->listview, FALSE);
5057         dupe_dest_set(dw->second_listview, FALSE);
5058
5059         if (dw->click_item && !dupe_listview_item_is_selected(dw, dw->click_item, widget))
5060                 {
5061                 GtkListStore *store;
5062                 GtkTreeIter iter;
5063
5064                 store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(widget)));
5065                 if (dupe_listview_find_item(store, dw->click_item, &iter) >= 0)
5066                         {
5067                         GtkTreeSelection *selection;
5068                         GtkTreePath *tpath;
5069
5070                         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
5071                         gtk_tree_selection_unselect_all(selection);
5072                         gtk_tree_selection_select_iter(selection, &iter);
5073
5074                         tpath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
5075                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, nullptr, FALSE);
5076                         gtk_tree_path_free(tpath);
5077                         }
5078                 }
5079
5080         if (dw->show_thumbs &&
5081             widget == dw->listview &&
5082             dw->click_item && dw->click_item->pixbuf)
5083                 {
5084                 GtkTreeSelection *selection;
5085                 gint items;
5086
5087                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
5088                 items = gtk_tree_selection_count_selected_rows(selection);
5089                 dnd_set_drag_icon(widget, context, dw->click_item->pixbuf, items);
5090                 }
5091 }
5092
5093 static void dupe_dnd_end(GtkWidget *, GdkDragContext *, gpointer data)
5094 {
5095         auto dw = static_cast<DupeWindow *>(data);
5096         dupe_dest_set(dw->listview, TRUE);
5097         dupe_dest_set(dw->second_listview, TRUE);
5098 }
5099
5100 static void dupe_dnd_init(DupeWindow *dw)
5101 {
5102         gtk_drag_source_set(dw->listview, static_cast<GdkModifierType>(GDK_BUTTON1_MASK | GDK_BUTTON2_MASK),
5103                             dupe_drag_types, n_dupe_drag_types,
5104                             static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK));
5105         g_signal_connect(G_OBJECT(dw->listview), "drag_data_get",
5106                          G_CALLBACK(dupe_dnd_data_set), dw);
5107         g_signal_connect(G_OBJECT(dw->listview), "drag_begin",
5108                          G_CALLBACK(dupe_dnd_begin), dw);
5109         g_signal_connect(G_OBJECT(dw->listview), "drag_end",
5110                          G_CALLBACK(dupe_dnd_end), dw);
5111
5112         dupe_dest_set(dw->listview, TRUE);
5113         g_signal_connect(G_OBJECT(dw->listview), "drag_data_received",
5114                          G_CALLBACK(dupe_dnd_data_get), dw);
5115
5116         gtk_drag_source_set(dw->second_listview, static_cast<GdkModifierType>(GDK_BUTTON1_MASK | GDK_BUTTON2_MASK),
5117                             dupe_drag_types, n_dupe_drag_types,
5118                             static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK));
5119         g_signal_connect(G_OBJECT(dw->second_listview), "drag_data_get",
5120                          G_CALLBACK(dupe_dnd_data_set), dw);
5121         g_signal_connect(G_OBJECT(dw->second_listview), "drag_begin",
5122                          G_CALLBACK(dupe_dnd_begin), dw);
5123         g_signal_connect(G_OBJECT(dw->second_listview), "drag_end",
5124                          G_CALLBACK(dupe_dnd_end), dw);
5125
5126         dupe_dest_set(dw->second_listview, TRUE);
5127         g_signal_connect(G_OBJECT(dw->second_listview), "drag_data_received",
5128                          G_CALLBACK(dupe_dnd_data_get), dw);
5129 }
5130
5131 /*
5132  *-------------------------------------------------------------------
5133  * maintenance (move, delete, etc.)
5134  *-------------------------------------------------------------------
5135  */
5136
5137 static void dupe_notify_cb(FileData *fd, NotifyType type, gpointer data)
5138 {
5139         auto dw = static_cast<DupeWindow *>(data);
5140
5141         if (!(type & NOTIFY_CHANGE) || !fd->change) return;
5142
5143         DEBUG_1("Notify dupe: %s %04x", fd->path, type);
5144
5145         switch (fd->change->type)
5146                 {
5147                 case FILEDATA_CHANGE_MOVE:
5148                 case FILEDATA_CHANGE_RENAME:
5149                         dupe_item_update_fd(dw, fd);
5150                         break;
5151                 case FILEDATA_CHANGE_COPY:
5152                         break;
5153                 case FILEDATA_CHANGE_DELETE:
5154                         /* Update the UI only once, after the operation finishes */
5155                         break;
5156                 case FILEDATA_CHANGE_UNSPECIFIED:
5157                 case FILEDATA_CHANGE_WRITE_METADATA:
5158                         break;
5159                 }
5160
5161 }
5162
5163 /**
5164  * @brief Refresh window after a file delete operation
5165  * @param success (ud->phase != UTILITY_PHASE_CANCEL) #file_util_dialog_run
5166  * @param dest_path Not used
5167  * @param data #DupeWindow
5168  *
5169  * If the window is refreshed after each file of a large set is deleted,
5170  * the UI slows to an unacceptable level. The #FileUtilDoneFunc is used
5171  * to call this function once, when the entire delete operation is completed.
5172  */
5173 static void delete_finished_cb(gboolean success, const gchar *, gpointer data)
5174 {
5175         auto dw = static_cast<DupeWindow *>(data);
5176
5177         if (!success)
5178                 {
5179                 return;
5180                 }
5181
5182         dupe_window_remove_selection(dw, dw->listview);
5183 }
5184
5185 /*
5186  *-------------------------------------------------------------------
5187  * Export duplicates data
5188  *-------------------------------------------------------------------
5189  */
5190
5191 enum SeparatorType {
5192         EXPORT_CSV = 0,
5193         EXPORT_TSV
5194 };
5195
5196 struct ExportDupesData
5197 {
5198         FileDialog *dialog;
5199         SeparatorType separator;
5200         DupeWindow *dupewindow;
5201 };
5202
5203 static void export_duplicates_close(ExportDupesData *edd)
5204 {
5205         if (edd->dialog) file_dialog_close(edd->dialog);
5206         edd->dialog = nullptr;
5207 }
5208
5209 static void export_duplicates_data_cancel_cb(FileDialog *, gpointer data)
5210 {
5211         auto edd = static_cast<ExportDupesData *>(data);
5212
5213         export_duplicates_close(edd);
5214 }
5215
5216 static void export_duplicates_data_save_cb(FileDialog *fdlg, gpointer data)
5217 {
5218         auto edd = static_cast<ExportDupesData *>(data);
5219         GError *error = nullptr;
5220         GtkTreeModel *store;
5221         GtkTreeIter iter;
5222         DupeItem *di;
5223         GFileOutputStream *gfstream;
5224         GFile *out_file;
5225         GString *output_string;
5226         gchar* rank;
5227         GList *work;
5228         GtkTreeSelection *selection;
5229         GList *slist;
5230         gchar *thumb_cache;
5231         gchar **rank_split;
5232         GtkTreePath *tpath;
5233         gboolean color_old = FALSE;
5234         gboolean color_new = FALSE;
5235         gint match_count;
5236         gchar *name;
5237
5238         history_list_add_to_key("export_duplicates", fdlg->dest_path, -1);
5239
5240         out_file = g_file_new_for_path(fdlg->dest_path);
5241
5242         gfstream = g_file_replace(out_file, nullptr, TRUE, G_FILE_CREATE_NONE, nullptr, &error);
5243         if (error)
5244                 {
5245                 log_printf(_("Error creating Export duplicates data file: Error: %s\n"), error->message);
5246                 g_error_free(error);
5247                 return;
5248                 }
5249
5250         const gchar *sep = (edd->separator == EXPORT_CSV) ?  "," : "\t";
5251         output_string = g_string_new(g_strjoin(sep, _("Match"), _("Group"), _("Similarity"), _("Set"), _("Thumbnail"), _("Name"), _("Size"), _("Date"), _("Width"), _("Height"), _("Path\n"), NULL));
5252
5253         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(edd->dupewindow->listview));
5254         slist = gtk_tree_selection_get_selected_rows(selection, &store);
5255         work = slist;
5256
5257         tpath = static_cast<GtkTreePath *>(work->data);
5258         gtk_tree_model_get_iter(store, &iter, tpath);
5259         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, DUPE_COLUMN_COLOR, &color_new, -1);
5260         color_old = !color_new;
5261         match_count = 0;
5262
5263         while (work)
5264                 {
5265                 tpath = static_cast<GtkTreePath *>(work->data);
5266                 gtk_tree_model_get_iter(store, &iter, tpath);
5267
5268                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, DUPE_COLUMN_POINTER, &di, -1);
5269
5270                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, DUPE_COLUMN_COLOR, &color_new, -1);
5271                 if (color_new != color_old)
5272                         {
5273                         match_count++;
5274                         }
5275                 color_old = color_new;
5276                 g_string_append_printf(output_string, "%d", match_count);
5277                 output_string = g_string_append(output_string, sep);
5278
5279                 if ((dupe_match_find_parent(edd->dupewindow, di) == di))
5280                         {
5281                         output_string = g_string_append(output_string, "1");
5282                         }
5283                 else
5284                         {
5285                         output_string = g_string_append(output_string, "2");
5286                         }
5287                 output_string = g_string_append(output_string, sep);
5288
5289                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, DUPE_COLUMN_RANK, &rank, -1);
5290                 rank_split = g_strsplit_set(rank, " [(", -1);
5291                 if (rank_split[0] == nullptr)
5292                         {
5293                         output_string = g_string_append(output_string, "");
5294                         }
5295                 else
5296                         {
5297                         output_string = g_string_append(output_string, rank_split[0]);
5298                         }
5299                 output_string = g_string_append(output_string, sep);
5300                 g_free(rank);
5301                 g_strfreev(rank_split);
5302
5303                 g_string_append_printf(output_string, "%d", di->second + 1);
5304                 output_string = g_string_append(output_string, sep);
5305
5306                 thumb_cache = cache_find_location(CACHE_TYPE_THUMB, di->fd->path);
5307                 if (thumb_cache)
5308                         {
5309                         output_string = g_string_append(output_string, thumb_cache);
5310                         g_free(thumb_cache);
5311                         }
5312                 else
5313                         {
5314                         output_string = g_string_append(output_string, "");
5315                         }
5316                 output_string = g_string_append(output_string, sep);
5317
5318                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, DUPE_COLUMN_NAME, &name, -1);
5319                 output_string = g_string_append(output_string, name);
5320                 output_string = g_string_append(output_string, sep);
5321                 g_free(name);
5322
5323                 g_string_append_printf(output_string, "%" PRIu64, di->fd->size);
5324                 output_string = g_string_append(output_string, sep);
5325                 output_string = g_string_append(output_string, text_from_time(di->fd->date));
5326                 output_string = g_string_append(output_string, sep);
5327                 g_string_append_printf(output_string, "%d", di->width);
5328                 output_string = g_string_append(output_string, sep);
5329                 g_string_append_printf(output_string, "%d", di->height);
5330                 output_string = g_string_append(output_string, sep);
5331                 output_string = g_string_append(output_string, di->fd->path);
5332                 output_string = g_string_append_c(output_string, '\n');
5333
5334                 work = work->next;
5335                 }
5336
5337         g_output_stream_write(G_OUTPUT_STREAM(gfstream), output_string->str, output_string->len, nullptr, &error);
5338
5339         g_string_free(output_string, TRUE);
5340         g_object_unref(gfstream);
5341         g_object_unref(out_file);
5342
5343         export_duplicates_close(edd);
5344 }
5345
5346 static void pop_menu_export(GList *, gpointer dupe_window, gpointer data)
5347 {
5348         const gint index = GPOINTER_TO_INT(data);
5349         auto dw = static_cast<DupeWindow *>(dupe_window);
5350         const gchar *title = "Export duplicates data";
5351         const gchar *default_path = "/tmp/";
5352         gchar *file_extension;
5353         ExportDupesData *edd;
5354         const gchar *previous_path;
5355
5356         edd = g_new0(ExportDupesData, 1);
5357         edd->dialog = file_util_file_dlg(title, "export_duplicates", nullptr, export_duplicates_data_cancel_cb, edd);
5358
5359         switch (index)
5360                 {
5361                 case EXPORT_CSV:
5362                         edd->separator = EXPORT_CSV;
5363                         file_extension = g_strdup(".csv");
5364                         break;
5365                 case EXPORT_TSV:
5366                         edd->separator = EXPORT_TSV;
5367                         file_extension = g_strdup(".tsv");
5368                         break;
5369                 default:
5370                         return;
5371                 }
5372
5373         generic_dialog_add_message(GENERIC_DIALOG(edd->dialog), nullptr, title, nullptr, FALSE);
5374         file_dialog_add_button(edd->dialog, GQ_ICON_SAVE, _("Save"), export_duplicates_data_save_cb, TRUE);
5375
5376         previous_path = history_list_find_last_path_by_key("export_duplicates");
5377
5378         file_dialog_add_path_widgets(edd->dialog, default_path, previous_path, "export_duplicates", file_extension, _("Export Files"));
5379
5380         edd->dupewindow = dw;
5381
5382         gtk_widget_show(GENERIC_DIALOG(edd->dialog)->dialog);
5383
5384         g_free(file_extension);
5385 }
5386
5387 static void dupe_pop_menu_export_cb(GtkWidget *widget, gpointer data)
5388 {
5389         DupeWindow *dw;
5390         GList *selection_list;
5391
5392         dw = static_cast<DupeWindow *>(submenu_item_get_data(widget));
5393         selection_list = dupe_listview_get_selection(dw, dw->listview);
5394         pop_menu_export(selection_list, dw, data);
5395
5396         filelist_free(selection_list);
5397 }
5398
5399 static GtkWidget *submenu_add_export(GtkWidget *menu, GtkWidget **menu_item, GCallback func, gpointer data)
5400 {
5401         GtkWidget *item;
5402         GtkWidget *submenu;
5403
5404         item = menu_item_add(menu, _("_Export"), nullptr, nullptr);
5405
5406         submenu = gtk_menu_new();
5407         g_object_set_data(G_OBJECT(submenu), "submenu_data", data);
5408
5409         menu_item_add_icon_sensitive(submenu, _("Export to csv"),
5410                                         GQ_ICON_EXPORT, TRUE, G_CALLBACK(func), GINT_TO_POINTER(0));
5411         menu_item_add_icon_sensitive(submenu, _("Export to tab-delimited"),
5412                                         GQ_ICON_EXPORT, TRUE, G_CALLBACK(func), GINT_TO_POINTER(1));
5413
5414         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
5415         if (menu_item) *menu_item = item;
5416
5417         return submenu;
5418 }
5419
5420 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */