src/dupe.c

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