src/dupe.c

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