src/search.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 "search.h"
  24
  25 #include "cache.h"
  26 #include "collect.h"
  27 #include "collect-table.h"
  28 #include "dnd.h"
  29 #include "dupe.h"
  30 #include "editors.h"
  31 #include "filedata.h"
  32 #include "image-load.h"
  33 #include "img-view.h"
  34 #include "layout.h"
  35 #include "layout_util.h"
  36 #include "math.h"
  37 #include "menu.h"
  38 #include "metadata.h"
  39 #include "misc.h"
  40 #include "print.h"
  41 #include "thumb.h"
  42 #include "ui_bookmark.h"
  43 #include "ui_fileops.h"
  44 #include "ui_menu.h"
  45 #include "ui_misc.h"
  46 #include "ui_spinner.h"
  47 #include "ui_tabcomp.h"
  48 #include "ui_tree_edit.h"
  49 #include "uri_utils.h"
  50 #include "utilops.h"
  51 #include "window.h"
  52 #include "bar_keywords.h"
  53
  54 #include <gdk/gdkkeysyms.h> /* for keyboard values */
  55
  56
  57 #define DEF_SEARCH_WIDTH  700
  58 #define DEF_SEARCH_HEIGHT 650
  59
  60 #define SEARCH_BUFFER_MATCH_LOAD 20
  61 #define SEARCH_BUFFER_MATCH_HIT  5
  62 #define SEARCH_BUFFER_MATCH_MISS 1
  63 #define SEARCH_BUFFER_FLUSH_SIZE 99
  64
  65 typedef enum {
  66         SEARCH_MATCH_NONE,
  67         SEARCH_MATCH_EQUAL,
  68         SEARCH_MATCH_CONTAINS,
  69         SEARCH_MATCH_UNDER,
  70         SEARCH_MATCH_OVER,
  71         SEARCH_MATCH_BETWEEN,
  72         SEARCH_MATCH_ALL,
  73         SEARCH_MATCH_ANY
  74 } MatchType;
  75
  76 enum {
  77         SEARCH_COLUMN_POINTER = 0,
  78         SEARCH_COLUMN_RANK,
  79         SEARCH_COLUMN_THUMB,
  80         SEARCH_COLUMN_NAME,
  81         SEARCH_COLUMN_SIZE,
  82         SEARCH_COLUMN_DATE,
  83         SEARCH_COLUMN_DIMENSIONS,
  84         SEARCH_COLUMN_PATH,
  85         SEARCH_COLUMN_COUNT     /* total columns */
  86 };
  87
  88 typedef struct _SearchData SearchData;
  89 struct _SearchData
  90 {
  91         GtkWidget *window;
  92
  93         GtkWidget *button_thumbs;
  94         GtkWidget *label_status;
  95         GtkWidget *label_progress;
  96         GtkWidget *button_start;
  97         GtkWidget *button_stop;
  98         GtkWidget *spinner;
  99
 100         GtkWidget *box_search;
 101
 102         GtkWidget *menu_path;
 103         GtkWidget *path_entry;
 104         GtkWidget *check_recurse;
 105
 106         GtkWidget *result_view;
 107
 108         GtkWidget *check_name;
 109         GtkWidget *menu_name;
 110         GtkWidget *entry_name;
 111         GtkWidget *check_name_match_case;
 112
 113         GtkWidget *check_size;
 114         GtkWidget *menu_size;
 115         GtkWidget *spin_size;
 116         GtkWidget *spin_size_end;
 117
 118         GtkWidget *check_date;
 119         GtkWidget *menu_date;
 120         GtkWidget *date_sel;
 121         GtkWidget *date_sel_end;
 122         GtkWidget *date_type;
 123
 124         GtkWidget *check_dimensions;
 125         GtkWidget *menu_dimensions;
 126         GtkWidget *spin_width;
 127         GtkWidget *spin_height;
 128         GtkWidget *spin_width_end;
 129         GtkWidget *spin_height_end;
 130
 131         GtkWidget *check_similarity;
 132         GtkWidget *spin_similarity;
 133         GtkWidget *entry_similarity;
 134
 135         GtkWidget *check_keywords;
 136         GtkWidget *menu_keywords;
 137         GtkWidget *entry_keywords;
 138
 139         GtkWidget *check_comment;
 140         GtkWidget *menu_comment;
 141         GtkWidget *entry_comment;
 142
 143         GtkWidget *check_rating;
 144         GtkWidget *menu_rating;
 145         GtkWidget *spin_rating;
 146         GtkWidget *spin_rating_end;
 147
 148         GtkWidget *check_class;
 149         GtkWidget *menu_class;
 150         GtkWidget *class_type;
 151         GtkWidget *marks_type;
 152         GtkWidget *menu_marks;
 153
 154         FileData *search_dir_fd;
 155         gboolean   search_path_recurse;
 156         gchar *search_name;
 157         GRegex *search_name_regex;
 158         gboolean   search_name_match_case;
 159         gint64 search_size;
 160         gint64 search_size_end;
 161         gint   search_date_y;
 162         gint   search_date_m;
 163         gint   search_date_d;
 164         gint   search_date_end_y;
 165         gint   search_date_end_m;
 166         gint   search_date_end_d;
 167         gint   search_width;
 168         gint   search_height;
 169         gint   search_width_end;
 170         gint   search_height_end;
 171         gint   search_similarity;
 172         gchar *search_similarity_path;
 173         CacheData *search_similarity_cd;
 174         GList *search_keyword_list;
 175         gchar *search_comment;
 176         GRegex *search_comment_regex;
 177         gint   search_rating;
 178         gint   search_rating_end;
 179         gboolean   search_comment_match_case;
 180
 181         MatchType search_type;
 182
 183         MatchType match_name;
 184         MatchType match_size;
 185         MatchType match_date;
 186         MatchType match_dimensions;
 187         MatchType match_keywords;
 188         MatchType match_comment;
 189         MatchType match_rating;
 190         MatchType match_gps;
 191         MatchType match_class;
 192         MatchType match_marks;
 193
 194         gboolean match_name_enable;
 195         gboolean match_size_enable;
 196         gboolean match_date_enable;
 197         gboolean match_dimensions_enable;
 198         gboolean match_similarity_enable;
 199         gboolean match_keywords_enable;
 200         gboolean match_comment_enable;
 201         gboolean match_rating_enable;
 202         gboolean match_class_enable;
 203         gboolean match_marks_enable;
 204
 205         GList *search_folder_list;
 206         GList *search_done_list;
 207         GList *search_file_list;
 208         GList *search_buffer_list;
 209
 210         gint search_count;
 211         gint search_total;
 212         gint search_buffer_count;
 213
 214         guint search_idle_id; /* event source id */
 215         guint update_idle_id; /* event source id */
 216
 217         ImageLoader *img_loader;
 218         CacheData   *img_cd;
 219
 220         FileData *click_fd;
 221
 222         ThumbLoader *thumb_loader;
 223         gboolean thumb_enable;
 224         FileData *thumb_fd;
 225
 226         /* Used for lat/long coordinate search
 227         */
 228         gint search_gps;
 229         gdouble search_lat, search_lon;
 230         GtkWidget *entry_gps_coord;
 231         GtkWidget *check_gps;
 232         GtkWidget *spin_gps;
 233         GtkWidget *units_gps;
 234         GtkWidget *menu_gps;
 235         gboolean match_gps_enable;
 236
 237 };
 238
 239 typedef struct _MatchFileData MatchFileData;
 240 struct _MatchFileData
 241 {
 242         FileData *fd;
 243         gint width;
 244         gint height;
 245         gint rank;
 246 };
 247
 248 typedef struct _MatchList MatchList;
 249 struct _MatchList
 250 {
 251         const gchar *text;
 252         const MatchType type;
 253 };
 254
 255 static const MatchList text_search_menu_path[] = {
 256         { N_("folder"),         SEARCH_MATCH_NONE },
 257         { N_("comments"),       SEARCH_MATCH_ALL },
 258         { N_("results"),        SEARCH_MATCH_CONTAINS }
 259 };
 260
 261 static const MatchList text_search_menu_name[] = {
 262         { N_("contains"),       SEARCH_MATCH_CONTAINS },
 263         { N_("is"),             SEARCH_MATCH_EQUAL }
 264 };
 265
 266 static const MatchList text_search_menu_size[] = {
 267         { N_("equal to"),       SEARCH_MATCH_EQUAL },
 268         { N_("less than"),      SEARCH_MATCH_UNDER },
 269         { N_("greater than"),   SEARCH_MATCH_OVER },
 270         { N_("between"),        SEARCH_MATCH_BETWEEN }
 271 };
 272
 273 static const MatchList text_search_menu_date[] = {
 274         { N_("equal to"),       SEARCH_MATCH_EQUAL },
 275         { N_("before"),         SEARCH_MATCH_UNDER },
 276         { N_("after"),          SEARCH_MATCH_OVER },
 277         { N_("between"),        SEARCH_MATCH_BETWEEN }
 278 };
 279
 280 static const MatchList text_search_menu_keyword[] = {
 281         { N_("match all"),      SEARCH_MATCH_ALL },
 282         { N_("match any"),      SEARCH_MATCH_ANY },
 283         { N_("exclude"),        SEARCH_MATCH_NONE }
 284 };
 285
 286 static const MatchList text_search_menu_comment[] = {
 287         { N_("contains"),       SEARCH_MATCH_CONTAINS },
 288         { N_("miss"),           SEARCH_MATCH_NONE }
 289 };
 290
 291
 292 static const MatchList text_search_menu_rating[] = {
 293         { N_("equal to"),       SEARCH_MATCH_EQUAL },
 294         { N_("less than"),      SEARCH_MATCH_UNDER },
 295         { N_("greater than"),   SEARCH_MATCH_OVER },
 296         { N_("between"),        SEARCH_MATCH_BETWEEN }
 297 };
 298
 299 static const MatchList text_search_menu_gps[] = {
 300         { N_("not geocoded"),   SEARCH_MATCH_NONE },
 301         { N_("less than"),      SEARCH_MATCH_UNDER },
 302         { N_("greater than"),   SEARCH_MATCH_OVER }
 303 };
 304
 305 static const MatchList text_search_menu_class[] = {
 306         { N_("is"),     SEARCH_MATCH_EQUAL },
 307         { N_("is not"), SEARCH_MATCH_NONE }
 308 };
 309
 310 static const MatchList text_search_menu_marks[] = {
 311         { N_("is"),     SEARCH_MATCH_EQUAL },
 312         { N_("is not"), SEARCH_MATCH_NONE }
 313 };
 314
 315 static GList *search_window_list = NULL;
 316
 317
 318 static gint search_result_selection_count(SearchData *sd, gint64 *bytes);
 319 static gint search_result_count(SearchData *sd, gint64 *bytes);
 320
 321 static void search_window_close(SearchData *sd);
 322
 323 static void search_notify_cb(FileData *fd, NotifyType type, gpointer data);
 324
 325 /*
 326  *-------------------------------------------------------------------
 327  * utils
 328  *-------------------------------------------------------------------
 329  */
 330
 331 static time_t convert_dmy_to_time(gint day, gint month, gint year)
 332 {
 333         struct tm lt;
 334
 335         lt.tm_sec = 0;
 336         lt.tm_min = 0;
 337         lt.tm_hour = 0;
 338         lt.tm_mday = day;
 339         lt.tm_mon = month - 1;
 340         lt.tm_year = year - 1900;
 341         lt.tm_isdst = 0;
 342
 343         return mktime(&lt);
 344 }
 345
 346 static void search_status_update(SearchData *sd)
 347 {
 348         gchar *buf;
 349         gint t;
 350         gint s;
 351         gint64 t_bytes;
 352         gint64 s_bytes;
 353         gchar *tt;
 354
 355         t = search_result_count(sd, &t_bytes);
 356         s = search_result_selection_count(sd, &s_bytes);
 357
 358         tt = text_from_size_abrev(t_bytes);
 359
 360         if (s > 0)
 361                 {
 362                 gchar *ts = text_from_size_abrev(s_bytes);
 363                 buf = g_strdup_printf(_("%s, %d files (%s, %d)"), tt, t, ts, s);
 364                 g_free(ts);
 365                 }
 366         else
 367                 {
 368                 buf = g_strdup_printf(_("%s, %d files"), tt, t);
 369                 }
 370
 371         g_free(tt);
 372
 373         gtk_label_set_text(GTK_LABEL(sd->label_status), buf);
 374         g_free(buf);
 375 }
 376
 377 static void search_progress_update(SearchData *sd, gboolean search, gdouble thumbs)
 378 {
 379
 380         if (search || thumbs >= 0.0)
 381                 {
 382                 gchar *buf;
 383                 const gchar *message;
 384
 385                 if (search && (sd->search_folder_list || sd->search_file_list))
 386                         message = _("Searching...");
 387                 else if (thumbs >= 0.0)
 388                         message = _("Loading thumbs...");
 389                 else
 390                         message = "";
 391
 392                 buf = g_strdup_printf("%s(%d / %d)", message, sd->search_count, sd->search_total);
 393                 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(sd->label_progress), buf);
 394                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(sd->label_progress),
 395                                               (thumbs >= 0.0) ? thumbs : 0.0);
 396                 g_free(buf);
 397                 }
 398         else
 399                 {
 400                 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(sd->label_progress), "");
 401                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(sd->label_progress), 0.0);
 402                 }
 403 }
 404
 405 /*
 406  *-------------------------------------------------------------------
 407  * result list
 408  *-------------------------------------------------------------------
 409  */
 410
 411 static gint search_result_find_row(SearchData *sd, FileData *fd, GtkTreeIter *iter)
 412 {
 413         GtkTreeModel *store;
 414         gboolean valid;
 415         gint n = 0;
 416
 417         store = gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view));
 418         valid = gtk_tree_model_get_iter_first(store, iter);
 419         while (valid)
 420                 {
 421                 MatchFileData *mfd;
 422                 n++;
 423
 424                 gtk_tree_model_get(store, iter, SEARCH_COLUMN_POINTER, &mfd, -1);
 425                 if (mfd->fd == fd) return n;
 426                 valid = gtk_tree_model_iter_next(store, iter);
 427                 }
 428
 429         return -1;
 430 }
 431
 432 static gboolean search_result_row_selected(SearchData *sd, FileData *fd)
 433 {
 434         GtkTreeModel *store;
 435         GtkTreeSelection *selection;
 436         GList *slist;
 437         GList *work;
 438         gboolean found = FALSE;
 439
 440         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->result_view));
 441         slist = gtk_tree_selection_get_selected_rows(selection, &store);
 442         work = slist;
 443         while (!found && work)
 444                 {
 445                 GtkTreePath *tpath = work->data;
 446                 MatchFileData *mfd_n;
 447                 GtkTreeIter iter;
 448
 449                 gtk_tree_model_get_iter(store, &iter, tpath);
 450                 gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd_n, -1);
 451                 if (mfd_n->fd == fd) found = TRUE;
 452                 work = work->next;
 453                 }
 454         g_list_foreach(slist, (GFunc)gtk_tree_path_free, NULL);
 455         g_list_free(slist);
 456
 457         return found;
 458 }
 459
 460 static gint search_result_selection_util(SearchData *sd, gint64 *bytes, GList **list)
 461 {
 462         GtkTreeModel *store;
 463         GtkTreeSelection *selection;
 464         GList *slist;
 465         GList *work;
 466         gint n = 0;
 467         gint64 total = 0;
 468         GList *plist = NULL;
 469
 470         store = gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view));
 471         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->result_view));
 472         slist = gtk_tree_selection_get_selected_rows(selection, &store);
 473         work = slist;
 474         while (work)
 475                 {
 476                 n++;
 477
 478                 if (bytes || list)
 479                         {
 480                         GtkTreePath *tpath = work->data;
 481                         MatchFileData *mfd;
 482                         GtkTreeIter iter;
 483
 484                         gtk_tree_model_get_iter(store, &iter, tpath);
 485                         gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, -1);
 486                         total += mfd->fd->size;
 487
 488                         if (list) plist = g_list_prepend(plist, file_data_ref(mfd->fd));
 489                         }
 490
 491                 work = work->next;
 492                 }
 493         g_list_foreach(slist, (GFunc)gtk_tree_path_free, NULL);
 494         g_list_free(slist);
 495
 496         if (bytes) *bytes = total;
 497         if (list) *list = g_list_reverse(plist);
 498
 499         return n;
 500 }
 501
 502 static GList *search_result_selection_list(SearchData *sd)
 503 {
 504         GList *list;
 505
 506         search_result_selection_util(sd, NULL, &list);
 507         return list;
 508 }
 509
 510 static gint search_result_selection_count(SearchData *sd, gint64 *bytes)
 511 {
 512         return search_result_selection_util(sd, bytes, NULL);
 513 }
 514
 515 static gint search_result_util(SearchData *sd, gint64 *bytes, GList **list)
 516 {
 517         GtkTreeModel *store;
 518         GtkTreeIter iter;
 519         gboolean valid;
 520         gint n = 0;
 521         gint64 total = 0;
 522         GList *plist = NULL;
 523
 524         store = gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view));
 525
 526         valid = gtk_tree_model_get_iter_first(store, &iter);
 527         while (valid)
 528                 {
 529                 n++;
 530                 if (bytes || list)
 531                         {
 532                         MatchFileData *mfd;
 533
 534                         gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, -1);
 535                         total += mfd->fd->size;
 536
 537                         if (list) plist = g_list_prepend(plist, file_data_ref(mfd->fd));
 538                         }
 539                 valid = gtk_tree_model_iter_next(store, &iter);
 540                 }
 541
 542         if (bytes) *bytes = total;
 543         if (list) *list = g_list_reverse(plist);
 544
 545         return n;
 546 }
 547
 548 static GList *search_result_get_filelist(SearchData *sd)
 549 {
 550         GList *list = NULL;
 551
 552         search_result_util(sd, NULL, &list);
 553         return list;
 554 }
 555
 556 static gint search_result_count(SearchData *sd, gint64 *bytes)
 557 {
 558         return search_result_util(sd, bytes, NULL);
 559 }
 560
 561 static void search_result_append(SearchData *sd, MatchFileData *mfd)
 562 {
 563         FileData *fd;
 564         GtkListStore *store;
 565         GtkTreeIter iter;
 566         gchar *text_size;
 567         gchar *text_dim = NULL;
 568
 569         fd = mfd->fd;
 570
 571         if (!fd) return;
 572
 573         text_size = text_from_size(fd->size);
 574         if (mfd->width > 0 && mfd->height > 0) text_dim = g_strdup_printf("%d x %d", mfd->width, mfd->height);
 575
 576         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view)));
 577         gtk_list_store_append(store, &iter);
 578         gtk_list_store_set(store, &iter,
 579                                 SEARCH_COLUMN_POINTER, mfd,
 580                                 SEARCH_COLUMN_RANK, mfd->rank,
 581                                 SEARCH_COLUMN_THUMB, fd->thumb_pixbuf,
 582                                 SEARCH_COLUMN_NAME, fd->name,
 583                                 SEARCH_COLUMN_SIZE, text_size,
 584                                 SEARCH_COLUMN_DATE, text_from_time(fd->date),
 585                                 SEARCH_COLUMN_DIMENSIONS, text_dim,
 586                                 SEARCH_COLUMN_PATH, fd->path,
 587                                 -1);
 588
 589         g_free(text_size);
 590         g_free(text_dim);
 591 }
 592
 593 static GList *search_result_refine_list(SearchData *sd)
 594 {
 595         GList *list = NULL;
 596         GtkTreeModel *store;
 597         GtkTreeIter iter;
 598         gboolean valid;
 599
 600         store = gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view));
 601
 602         valid = gtk_tree_model_get_iter_first(store, &iter);
 603         while (valid)
 604                 {
 605                 MatchFileData *mfd;
 606
 607                 gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, -1);
 608                 list = g_list_prepend(list, mfd->fd);
 609
 610                 valid = gtk_tree_model_iter_next(store, &iter);
 611                 }
 612
 613         /* clear it here, so that the FileData in list is not freed */
 614         gtk_list_store_clear(GTK_LIST_STORE(store));
 615
 616         return g_list_reverse(list);
 617 }
 618
 619 static gboolean search_result_free_node(GtkTreeModel *store, GtkTreePath *tpath,
 620                                         GtkTreeIter *iter, gpointer data)
 621 {
 622         MatchFileData *mfd;
 623
 624         gtk_tree_model_get(store, iter, SEARCH_COLUMN_POINTER, &mfd, -1);
 625         file_data_unref(mfd->fd);
 626         g_free(mfd);
 627
 628         return FALSE;
 629 }
 630
 631 static void search_result_clear(SearchData *sd)
 632 {
 633         GtkListStore *store;
 634
 635         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view)));
 636
 637         gtk_tree_model_foreach(GTK_TREE_MODEL(store), search_result_free_node, sd);
 638         gtk_list_store_clear(store);
 639
 640         sd->click_fd = NULL;
 641
 642         thumb_loader_free(sd->thumb_loader);
 643         sd->thumb_loader = NULL;
 644         sd->thumb_fd = NULL;
 645
 646         search_status_update(sd);
 647 }
 648
 649 static void search_result_remove_item(SearchData *sd, MatchFileData *mfd, GtkTreeIter *iter)
 650 {
 651         GtkTreeModel *store;
 652
 653         if (!mfd || !iter) return;
 654
 655         store = gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view));
 656
 657         tree_view_move_cursor_away(GTK_TREE_VIEW(sd->result_view), iter, TRUE);
 658
 659         gtk_list_store_remove(GTK_LIST_STORE(store), iter);
 660         if (sd->click_fd == mfd->fd) sd->click_fd = NULL;
 661         if (sd->thumb_fd == mfd->fd) sd->thumb_fd = NULL;
 662         file_data_unref(mfd->fd);
 663         g_free(mfd);
 664 }
 665
 666 static void search_result_remove(SearchData *sd, FileData *fd)
 667 {
 668         GtkTreeModel *store;
 669         GtkTreeIter iter;
 670         gboolean valid;
 671
 672         store = gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view));
 673         valid = gtk_tree_model_get_iter_first(store, &iter);
 674         while (valid)
 675                 {
 676                 MatchFileData *mfd;
 677
 678                 gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, -1);
 679                 if (mfd->fd == fd)
 680                         {
 681                         search_result_remove_item(sd, mfd, &iter);
 682                         return;
 683                         }
 684
 685                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
 686                 }
 687 }
 688
 689 static void search_result_remove_selection(SearchData *sd)
 690 {
 691         GtkTreeSelection *selection;
 692         GtkTreeModel *store;
 693         GList *slist;
 694         GList *flist = NULL;
 695         GList *work;
 696
 697         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->result_view));
 698         slist = gtk_tree_selection_get_selected_rows(selection, &store);
 699         work = slist;
 700         while (work)
 701                 {
 702                 GtkTreePath *tpath = work->data;
 703                 GtkTreeIter iter;
 704                 MatchFileData *mfd;
 705
 706                 gtk_tree_model_get_iter(store, &iter, tpath);
 707                 gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, -1);
 708                 flist = g_list_prepend(flist, mfd->fd);
 709                 work = work->next;
 710                 }
 711         g_list_foreach(slist, (GFunc)gtk_tree_path_free, NULL);
 712         g_list_free(slist);
 713
 714         work = flist;
 715         while (work)
 716                 {
 717                 FileData *fd = work->data;
 718                 work = work->next;
 719
 720                 search_result_remove(sd, fd);
 721                 }
 722         g_list_free(flist);
 723
 724         search_status_update(sd);
 725 }
 726
 727 static void search_result_edit_selected(SearchData *sd, const gchar *key)
 728 {
 729         file_util_start_editor_from_filelist(key, search_result_selection_list(sd), NULL, sd->window);
 730 }
 731
 732 static void search_result_collection_from_selection(SearchData *sd)
 733 {
 734         CollectWindow *w;
 735         GList *list;
 736
 737         list = search_result_selection_list(sd);
 738         w = collection_window_new(NULL);
 739         collection_table_add_filelist(w->table, list);
 740         filelist_free(list);
 741 }
 742
 743 static gboolean search_result_update_idle_cb(gpointer data)
 744 {
 745         SearchData *sd = data;
 746
 747         search_status_update(sd);
 748
 749         sd->update_idle_id = 0;
 750         return FALSE;
 751 }
 752
 753 static void search_result_update_idle_cancel(SearchData *sd)
 754 {
 755         if (sd->update_idle_id)
 756                 {
 757                 g_source_remove(sd->update_idle_id);
 758                 sd->update_idle_id = 0;
 759                 }
 760 }
 761
 762 static gboolean search_result_select_cb(GtkTreeSelection *selection, GtkTreeModel *store,
 763                                         GtkTreePath *tpath, gboolean selected, gpointer data)
 764 {
 765         SearchData *sd = data;
 766
 767         if (!sd->update_idle_id)
 768                 {
 769                 sd->update_idle_id = g_idle_add(search_result_update_idle_cb, sd);
 770                 }
 771
 772         return TRUE;
 773 }
 774
 775 /*
 776  *-------------------------------------------------------------------
 777  * result list thumbs
 778  *-------------------------------------------------------------------
 779  */
 780
 781 static void search_result_thumb_step(SearchData *sd);
 782
 783
 784 static void search_result_thumb_set(SearchData *sd, FileData *fd, GtkTreeIter *iter)
 785 {
 786         GtkListStore *store;
 787         GtkTreeIter iter_n;
 788
 789         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view)));
 790         if (!iter)
 791                 {
 792                 if (search_result_find_row(sd, fd, &iter_n) >= 0) iter = &iter_n;
 793                 }
 794
 795         if (iter) gtk_list_store_set(store, iter, SEARCH_COLUMN_THUMB, fd->thumb_pixbuf, -1);
 796 }
 797
 798 static void search_result_thumb_do(SearchData *sd)
 799 {
 800         FileData *fd;
 801
 802         if (!sd->thumb_loader || !sd->thumb_fd) return;
 803         fd = sd->thumb_fd;
 804
 805         search_result_thumb_set(sd, fd, NULL);
 806 }
 807
 808 static void search_result_thumb_done_cb(ThumbLoader *tl, gpointer data)
 809 {
 810         SearchData *sd = data;
 811
 812         search_result_thumb_do(sd);
 813         search_result_thumb_step(sd);
 814 }
 815
 816 static void search_result_thumb_step(SearchData *sd)
 817 {
 818         GtkTreeModel *store;
 819         GtkTreeIter iter;
 820         MatchFileData *mfd = NULL;
 821         gboolean valid;
 822         gint row = 0;
 823         gint length = 0;
 824
 825         store = gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view));
 826         valid = gtk_tree_model_get_iter_first(store, &iter);
 827         if (!sd->thumb_enable)
 828                 {
 829                 while (valid)
 830                         {
 831                         gtk_list_store_set(GTK_LIST_STORE(store), &iter, SEARCH_COLUMN_THUMB, NULL, -1);
 832                         valid = gtk_tree_model_iter_next(store, &iter);
 833                         }
 834                 return;
 835                 }
 836
 837         while (!mfd && valid)
 838                 {
 839                 GdkPixbuf *pixbuf;
 840
 841                 length++;
 842                 gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, SEARCH_COLUMN_THUMB, &pixbuf, -1);
 843                 if (pixbuf || mfd->fd->thumb_pixbuf)
 844                         {
 845                         if (!pixbuf) gtk_list_store_set(GTK_LIST_STORE(store), &iter, SEARCH_COLUMN_THUMB, mfd->fd->thumb_pixbuf, -1);
 846                         row++;
 847                         mfd = NULL;
 848                         }
 849                 valid = gtk_tree_model_iter_next(store, &iter);
 850                 }
 851         if (valid)
 852                 {
 853                 while (gtk_tree_model_iter_next(store, &iter)) length++;
 854                 }
 855
 856         if (!mfd)
 857                 {
 858                 sd->thumb_fd = NULL;
 859                 thumb_loader_free(sd->thumb_loader);
 860                 sd->thumb_loader = NULL;
 861
 862                 search_progress_update(sd, TRUE, -1.0);
 863                 return;
 864                 }
 865
 866         search_progress_update(sd, FALSE, (gdouble)row/length);
 867
 868         sd->thumb_fd = mfd->fd;
 869         thumb_loader_free(sd->thumb_loader);
 870         sd->thumb_loader = thumb_loader_new(options->thumbnails.max_width, options->thumbnails.max_height);
 871
 872         thumb_loader_set_callbacks(sd->thumb_loader,
 873                                    search_result_thumb_done_cb,
 874                                    search_result_thumb_done_cb,
 875                                    NULL,
 876                                    sd);
 877         if (!thumb_loader_start(sd->thumb_loader, mfd->fd))
 878                 {
 879                 search_result_thumb_do(sd);
 880                 search_result_thumb_step(sd);
 881                 }
 882 }
 883
 884 static void search_result_thumb_height(SearchData *sd)
 885 {
 886         GtkTreeViewColumn *column;
 887         GtkCellRenderer *cell;
 888         GList *list;
 889
 890         column = gtk_tree_view_get_column(GTK_TREE_VIEW(sd->result_view), SEARCH_COLUMN_THUMB - 1);
 891         if (!column) return;
 892
 893         gtk_tree_view_column_set_fixed_width(column, (sd->thumb_enable) ? options->thumbnails.max_width : 4);
 894
 895         list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
 896         if (!list) return;
 897         cell = list->data;
 898         g_list_free(list);
 899
 900         g_object_set(G_OBJECT(cell), "height", (sd->thumb_enable) ? options->thumbnails.max_height : -1, NULL);
 901         gtk_tree_view_columns_autosize(GTK_TREE_VIEW(sd->result_view));
 902 }
 903
 904 static void search_result_thumb_enable(SearchData *sd, gboolean enable)
 905 {
 906         if (sd->thumb_enable == enable) return;
 907
 908         if (sd->thumb_enable)
 909                 {
 910                 GtkTreeModel *store;
 911                 GtkTreeIter iter;
 912                 gboolean valid;
 913
 914                 thumb_loader_free(sd->thumb_loader);
 915                 sd->thumb_loader = NULL;
 916
 917                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view));
 918                 valid = gtk_tree_model_get_iter_first(store, &iter);
 919                 while (valid)
 920                         {
 921                         gtk_list_store_set(GTK_LIST_STORE(store), &iter, SEARCH_COLUMN_THUMB, NULL, -1);
 922                         valid = gtk_tree_model_iter_next(store, &iter);
 923                         }
 924                 search_progress_update(sd, TRUE, -1.0);
 925                 }
 926
 927         sd->thumb_enable = enable;
 928
 929         search_result_thumb_height(sd);
 930         if (!sd->search_folder_list && !sd->search_file_list) search_result_thumb_step(sd);
 931 }
 932
 933 /*
 934  *-------------------------------------------------------------------
 935  * result list menu
 936  *-------------------------------------------------------------------
 937  */
 938
 939 static void sr_menu_view_cb(GtkWidget *widget, gpointer data)
 940 {
 941         SearchData *sd = data;
 942
 943         if (sd->click_fd) layout_set_fd(NULL, sd->click_fd);
 944 }
 945
 946 static void sr_menu_viewnew_cb(GtkWidget *widget, gpointer data)
 947 {
 948         SearchData *sd = data;
 949         GList *list;
 950
 951         list = search_result_selection_list(sd);
 952         view_window_new_from_list(list);
 953         filelist_free(list);
 954 }
 955
 956 static void sr_menu_select_all_cb(GtkWidget *widget, gpointer data)
 957 {
 958         SearchData *sd = data;
 959         GtkTreeSelection *selection;
 960
 961         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->result_view));
 962         gtk_tree_selection_select_all(selection);
 963 }
 964
 965 static void sr_menu_select_none_cb(GtkWidget *widget, gpointer data)
 966 {
 967         SearchData *sd = data;
 968         GtkTreeSelection *selection;
 969
 970         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->result_view));
 971         gtk_tree_selection_unselect_all(selection);
 972 }
 973
 974 static void sr_menu_edit_cb(GtkWidget *widget, gpointer data)
 975 {
 976         SearchData *sd;
 977         const gchar *key = data;
 978
 979         sd = submenu_item_get_data(widget);
 980         if (!sd) return;
 981
 982         search_result_edit_selected(sd, key);
 983 }
 984
 985 static void sr_menu_print_cb(GtkWidget *widget, gpointer data)
 986 {
 987         SearchData *sd = data;
 988
 989         print_window_new(sd->click_fd, search_result_selection_list(sd),
 990                          search_result_get_filelist(sd), sd->window);
 991 }
 992
 993 static void sr_menu_copy_cb(GtkWidget *widget, gpointer data)
 994 {
 995         SearchData *sd = data;
 996
 997         file_util_copy(NULL, search_result_selection_list(sd), NULL, sd->window);
 998 }
 999
1000 static void sr_menu_move_cb(GtkWidget *widget, gpointer data)
1001 {
1002         SearchData *sd = data;
1003
1004         file_util_move(NULL, search_result_selection_list(sd), NULL, sd->window);
1005 }
1006
1007 static void sr_menu_rename_cb(GtkWidget *widget, gpointer data)
1008 {
1009         SearchData *sd = data;
1010
1011         file_util_rename(NULL, search_result_selection_list(sd), sd->window);
1012 }
1013
1014 static void sr_menu_delete_cb(GtkWidget *widget, gpointer data)
1015 {
1016         SearchData *sd = data;
1017
1018         file_util_delete(NULL, search_result_selection_list(sd), sd->window);
1019 }
1020
1021 static void sr_menu_copy_path_cb(GtkWidget *widget, gpointer data)
1022 {
1023         SearchData *sd = data;
1024
1025         file_util_copy_path_list_to_clipboard(search_result_selection_list(sd), TRUE);
1026 }
1027
1028 static void sr_menu_copy_path_unquoted_cb(GtkWidget *widget, gpointer data)
1029 {
1030         SearchData *sd = data;
1031
1032         file_util_copy_path_list_to_clipboard(search_result_selection_list(sd), FALSE);
1033 }
1034
1035 static void sr_menu_remove_cb(GtkWidget *widget, gpointer data)
1036 {
1037         SearchData *sd = data;
1038
1039         search_result_remove_selection(sd);
1040 }
1041
1042 static void sr_menu_clear_cb(GtkWidget *widget, gpointer data)
1043 {
1044         SearchData *sd = data;
1045
1046         search_result_clear(sd);
1047 }
1048
1049 static void sr_menu_play_cb(GtkWidget *widget, gpointer data)
1050 {
1051         SearchData *sd = data;
1052
1053         start_editor_from_file(options->image_l_click_video_editor, sd->click_fd);
1054 }
1055
1056 static void search_result_menu_destroy_cb(GtkWidget *widget, gpointer data)
1057 {
1058         GList *editmenu_fd_list = data;
1059
1060         filelist_free(editmenu_fd_list);
1061 }
1062
1063 /**
1064  * @brief Add file selection list to a collection
1065  * @param[in] widget
1066  * @param[in] data Index to the collection list menu item selected, or -1 for new collection
1067  *
1068  *
1069  */
1070 static void search_pop_menu_collections_cb(GtkWidget *widget, gpointer data)
1071 {
1072         SearchData *sd;
1073         GList *selection_list;
1074
1075         sd = submenu_item_get_data(widget);
1076         selection_list = search_result_selection_list(sd);
1077         pop_menu_collections(selection_list, data);
1078
1079         filelist_free(selection_list);
1080 }
1081
1082 static GtkWidget *search_result_menu(SearchData *sd, gboolean on_row, gboolean empty)
1083 {
1084         GtkWidget *menu;
1085         GtkWidget *item;
1086         GList *editmenu_fd_list;
1087         GtkWidget *submenu;
1088         gboolean video;
1089
1090         menu = popup_menu_short_lived();
1091
1092         video = (on_row && sd->click_fd && sd->click_fd->format_class == FORMAT_CLASS_VIDEO);
1093         menu_item_add_stock_sensitive(menu, _("_Play"), GTK_STOCK_MEDIA_PLAY, video,
1094                             G_CALLBACK(sr_menu_play_cb), sd);
1095         menu_item_add_divider(menu);
1096
1097         menu_item_add_sensitive(menu, _("_View"), on_row,
1098                                 G_CALLBACK(sr_menu_view_cb), sd);
1099         menu_item_add_stock_sensitive(menu, _("View in _new window"), GTK_STOCK_NEW, on_row,
1100                                       G_CALLBACK(sr_menu_viewnew_cb), sd);
1101         menu_item_add_divider(menu);
1102         menu_item_add_sensitive(menu, _("Select all"), !empty,
1103                                 G_CALLBACK(sr_menu_select_all_cb), sd);
1104         menu_item_add_sensitive(menu, _("Select none"), !empty,
1105                                 G_CALLBACK(sr_menu_select_none_cb), sd);
1106         menu_item_add_divider(menu);
1107
1108         editmenu_fd_list = search_result_selection_list(sd);
1109         g_signal_connect(G_OBJECT(menu), "destroy",
1110                          G_CALLBACK(search_result_menu_destroy_cb), editmenu_fd_list);
1111         submenu_add_edit(menu, &item, G_CALLBACK(sr_menu_edit_cb), sd, editmenu_fd_list);
1112         if (!on_row) gtk_widget_set_sensitive(item, FALSE);
1113
1114         submenu_add_collections(menu, &item,
1115                                 G_CALLBACK(search_pop_menu_collections_cb), sd);
1116         gtk_widget_set_sensitive(item, on_row);
1117
1118         menu_item_add_stock_sensitive(menu, _("Print..."), GTK_STOCK_PRINT, on_row,
1119                                       G_CALLBACK(sr_menu_print_cb), sd);
1120         menu_item_add_divider(menu);
1121         menu_item_add_stock_sensitive(menu, _("_Copy..."), GTK_STOCK_COPY, on_row,
1122                                       G_CALLBACK(sr_menu_copy_cb), sd);
1123         menu_item_add_sensitive(menu, _("_Move..."), on_row,
1124                                 G_CALLBACK(sr_menu_move_cb), sd);
1125         menu_item_add_sensitive(menu, _("_Rename..."), on_row,
1126                                 G_CALLBACK(sr_menu_rename_cb), sd);
1127         menu_item_add_sensitive(menu, _("_Copy path"), on_row,
1128                                 G_CALLBACK(sr_menu_copy_path_cb), sd);
1129         menu_item_add_sensitive(menu, _("_Copy path unquoted"), on_row,
1130                                 G_CALLBACK(sr_menu_copy_path_unquoted_cb), sd);
1131         menu_item_add_stock_sensitive(menu, _("_Delete..."), GTK_STOCK_DELETE, on_row,
1132                                       G_CALLBACK(sr_menu_delete_cb), sd);
1133         menu_item_add_divider(menu);
1134         menu_item_add_stock_sensitive(menu, _("Rem_ove"), GTK_STOCK_REMOVE, on_row,
1135                                       G_CALLBACK(sr_menu_remove_cb), sd);
1136         menu_item_add_stock_sensitive(menu, _("C_lear"), GTK_STOCK_CLEAR, !empty,
1137                                       G_CALLBACK(sr_menu_clear_cb), sd);
1138
1139         return menu;
1140 }
1141
1142 static void search_result_menu_pos_cb(GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer data)
1143 {
1144         SearchData *sd = data;
1145         GtkTreePath *tpath;
1146         gint cx, cy, cw, ch;
1147
1148         gtk_tree_view_get_cursor(GTK_TREE_VIEW(sd->result_view), &tpath, NULL);
1149         if (!tpath) return;
1150
1151         tree_view_get_cell_clamped(GTK_TREE_VIEW(sd->result_view), tpath,
1152                                    SEARCH_COLUMN_NAME - 1, TRUE, &cx, &cy, &cw, &ch);
1153         gtk_tree_path_free(tpath);
1154         cy += ch;
1155         popup_menu_position_clamp(menu, &cx, &cy, 0);
1156         *x = cx;
1157         *y = cy;
1158 }
1159
1160 /*
1161  *-------------------------------------------------------------------
1162  * result list input
1163  *-------------------------------------------------------------------
1164  */
1165
1166 static gboolean search_result_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1167 {
1168         SearchData *sd = data;
1169         GtkTreeModel *store;
1170         GtkTreePath *tpath;
1171         GtkTreeIter iter;
1172         MatchFileData *mfd = NULL;
1173
1174         store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
1175
1176         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
1177                                           &tpath, NULL, NULL, NULL))
1178                 {
1179                 gtk_tree_model_get_iter(store, &iter, tpath);
1180                 gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, -1);
1181                 gtk_tree_path_free(tpath);
1182                 }
1183
1184         sd->click_fd = mfd ? mfd->fd : NULL;
1185
1186         if (bevent->button == MOUSE_BUTTON_RIGHT)
1187                 {
1188                 GtkWidget *menu;
1189
1190                 menu = search_result_menu(sd, (mfd != NULL), (search_result_count(sd, NULL) == 0));
1191                 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, bevent->button, bevent->time);
1192                 }
1193
1194         if (!mfd) return FALSE;
1195
1196         if (bevent->button == MOUSE_BUTTON_LEFT && bevent->type == GDK_2BUTTON_PRESS)
1197                 {
1198                 layout_set_fd(NULL, mfd->fd);
1199                 }
1200
1201         if (bevent->button == MOUSE_BUTTON_MIDDLE) return TRUE;
1202
1203         if (bevent->button == MOUSE_BUTTON_RIGHT)
1204                 {
1205                 if (!search_result_row_selected(sd, mfd->fd))
1206                         {
1207                         GtkTreeSelection *selection;
1208
1209                         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
1210                         gtk_tree_selection_unselect_all(selection);
1211                         gtk_tree_selection_select_iter(selection, &iter);
1212
1213                         tpath = gtk_tree_model_get_path(store, &iter);
1214                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
1215                         gtk_tree_path_free(tpath);
1216                         }
1217                 return TRUE;
1218                 }
1219
1220         if (bevent->button == MOUSE_BUTTON_LEFT && bevent->type == GDK_BUTTON_PRESS &&
1221             !(bevent->state & GDK_SHIFT_MASK ) &&
1222             !(bevent->state & GDK_CONTROL_MASK ) &&
1223             search_result_row_selected(sd, mfd->fd))
1224                 {
1225                 /* this selection handled on release_cb */
1226                 gtk_widget_grab_focus(widget);
1227                 return TRUE;
1228                 }
1229
1230         return FALSE;
1231 }
1232
1233 static gboolean search_result_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1234 {
1235         SearchData *sd = data;
1236         GtkTreeModel *store;
1237         GtkTreePath *tpath;
1238         GtkTreeIter iter;
1239
1240         MatchFileData *mfd = NULL;
1241
1242         if (bevent->button != MOUSE_BUTTON_LEFT && bevent->button != MOUSE_BUTTON_MIDDLE) return TRUE;
1243
1244         store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
1245
1246         if ((bevent->x != 0 || bevent->y != 0) &&
1247             gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
1248                                           &tpath, NULL, NULL, NULL))
1249                 {
1250                 gtk_tree_model_get_iter(store, &iter, tpath);
1251                 gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, -1);
1252                 gtk_tree_path_free(tpath);
1253                 }
1254
1255         if (bevent->button == MOUSE_BUTTON_MIDDLE)
1256                 {
1257                 if (mfd && sd->click_fd == mfd->fd)
1258                         {
1259                         GtkTreeSelection *selection;
1260
1261                         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
1262                         if (search_result_row_selected(sd, mfd->fd))
1263                                 {
1264                                 gtk_tree_selection_unselect_iter(selection, &iter);
1265                                 }
1266                         else
1267                                 {
1268                                 gtk_tree_selection_select_iter(selection, &iter);
1269                                 }
1270                         }
1271                 return TRUE;
1272                 }
1273
1274         if (mfd && sd->click_fd == mfd->fd &&
1275             !(bevent->state & GDK_SHIFT_MASK ) &&
1276             !(bevent->state & GDK_CONTROL_MASK ) &&
1277             search_result_row_selected(sd, mfd->fd))
1278                 {
1279                 GtkTreeSelection *selection;
1280
1281                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
1282                 gtk_tree_selection_unselect_all(selection);
1283                 gtk_tree_selection_select_iter(selection, &iter);
1284
1285                 tpath = gtk_tree_model_get_path(store, &iter);
1286                 gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
1287                 gtk_tree_path_free(tpath);
1288
1289                 return TRUE;
1290                 }
1291
1292         return FALSE;
1293 }
1294
1295 static gboolean search_result_keypress_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
1296 {
1297         SearchData *sd = data;
1298         gboolean stop_signal = FALSE;
1299         GtkTreeModel *store;
1300         GtkTreeSelection *selection;
1301         GList *slist;
1302         MatchFileData *mfd = NULL;
1303
1304         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->result_view));
1305         slist = gtk_tree_selection_get_selected_rows(selection, &store);
1306         if (slist)
1307                 {
1308                 GtkTreePath *tpath;
1309                 GtkTreeIter iter;
1310                 GList *last;
1311
1312                 last = g_list_last(slist);
1313                 tpath = last->data;
1314
1315                 /* last is newest selected file */
1316                 gtk_tree_model_get_iter(store, &iter, tpath);
1317                 gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, -1);
1318                 }
1319         g_list_foreach(slist, (GFunc)gtk_tree_path_free, NULL);
1320         g_list_free(slist);
1321
1322         if (event->state & GDK_CONTROL_MASK)
1323                 {
1324                 stop_signal = TRUE;
1325                 switch (event->keyval)
1326                         {
1327                         case '1':
1328                         case '2':
1329                         case '3':
1330                         case '4':
1331                         case '5':
1332                         case '6':
1333                         case '7':
1334                         case '8':
1335                         case '9':
1336                         case '0':
1337                                 break;
1338                         case 'C': case 'c':
1339                                 file_util_copy(NULL, search_result_selection_list(sd), NULL, widget);
1340                                 break;
1341                         case 'M': case 'm':
1342                                 file_util_move(NULL, search_result_selection_list(sd), NULL, widget);
1343                                 break;
1344                         case 'R': case 'r':
1345                                 file_util_rename(NULL, search_result_selection_list(sd), widget);
1346                                 break;
1347                         case 'D': case 'd':
1348                                 file_util_delete(NULL, search_result_selection_list(sd), widget);
1349                                 break;
1350                         case 'A': case 'a':
1351                                 if (event->state & GDK_SHIFT_MASK)
1352                                         {
1353                                         gtk_tree_selection_unselect_all(selection);
1354                                         }
1355                                 else
1356                                         {
1357                                         gtk_tree_selection_select_all(selection);
1358                                         }
1359                                 break;
1360                         case GDK_KEY_Delete: case GDK_KEY_KP_Delete:
1361                                 search_result_clear(sd);
1362                                 break;
1363                         default:
1364                                 stop_signal = FALSE;
1365                                 break;
1366                         }
1367                 }
1368         else
1369                 {
1370                 stop_signal = TRUE;
1371                 switch (event->keyval)
1372                         {
1373                         case GDK_KEY_Return: case GDK_KEY_KP_Enter:
1374                                 if (mfd) layout_set_fd(NULL, mfd->fd);
1375                                 break;
1376                         case 'V': case 'v':
1377                                 {
1378                                 GList *list;
1379
1380                                 list = search_result_selection_list(sd);
1381                                 view_window_new_from_list(list);
1382                                 filelist_free(list);
1383                                 }
1384                                 break;
1385                         case GDK_KEY_Delete: case GDK_KEY_KP_Delete:
1386                                 search_result_remove_selection(sd);
1387                                 break;
1388                         case 'C': case 'c':
1389                                 search_result_collection_from_selection(sd);
1390                                 break;
1391                         case GDK_KEY_Menu:
1392                         case GDK_KEY_F10:
1393                                 {
1394                                 GtkWidget *menu;
1395
1396                                 if (mfd)
1397                                         sd->click_fd = mfd->fd;
1398                                 else
1399                                         sd->click_fd = NULL;
1400
1401                                 menu = search_result_menu(sd, (mfd != NULL), (search_result_count(sd, NULL) > 0));
1402                                 gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
1403                                                search_result_menu_pos_cb, sd, 0, GDK_CURRENT_TIME);
1404                                 }
1405                                 break;
1406                         default:
1407                                 stop_signal = FALSE;
1408                                 break;
1409                         }
1410                 }
1411
1412         return stop_signal;
1413 }
1414
1415 static gboolean search_window_keypress_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
1416 {
1417         SearchData *sd = data;
1418         gboolean stop_signal = FALSE;
1419
1420         if (event->state & GDK_CONTROL_MASK)
1421                 {
1422                 stop_signal = TRUE;
1423                 switch (event->keyval)
1424                         {
1425                         case 'T': case 't':
1426                                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sd->button_thumbs),
1427                                         !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sd->button_thumbs)));
1428                                 break;
1429                         case 'W': case 'w':
1430                                 search_window_close(sd);
1431                                 break;
1432                         default:
1433                                 stop_signal = FALSE;
1434                                 break;
1435                         }
1436                 }
1437         if (!stop_signal && is_help_key(event))
1438                 {
1439                 help_window_show("GuideImageSearchSearch.html");
1440                 stop_signal = TRUE;
1441                 }
1442
1443         return stop_signal;
1444 }
1445
1446 /*
1447  *-------------------------------------------------------------------
1448  * dnd
1449  *-------------------------------------------------------------------
1450  */
1451
1452 static GtkTargetEntry result_drag_types[] = {
1453         { "text/uri-list", 0, TARGET_URI_LIST },
1454         { "text/plain", 0, TARGET_TEXT_PLAIN }
1455 };
1456 static gint n_result_drag_types = 2;
1457
1458 static GtkTargetEntry result_drop_types[] = {
1459         { "text/uri-list", 0, TARGET_URI_LIST },
1460         { "text/plain", 0, TARGET_TEXT_PLAIN }
1461 };
1462 static gint n_result_drop_types = 2;
1463
1464 static void search_dnd_data_set(GtkWidget *widget, GdkDragContext *context,
1465                                 GtkSelectionData *selection_data, guint info,
1466                                 guint time, gpointer data)
1467 {
1468         SearchData *sd = data;
1469         GList *list;
1470
1471         list = search_result_selection_list(sd);
1472         if (!list) return;
1473
1474         uri_selection_data_set_uris_from_filelist(selection_data, list);
1475         filelist_free(list);
1476 }
1477
1478 static void search_dnd_begin(GtkWidget *widget, GdkDragContext *context, gpointer data)
1479 {
1480         SearchData *sd = data;
1481
1482         if (sd->click_fd && !search_result_row_selected(sd, sd->click_fd))
1483                 {
1484                 GtkListStore *store;
1485                 GtkTreeIter iter;
1486
1487                 store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(widget)));
1488                 if (search_result_find_row(sd, sd->click_fd, &iter) >= 0)
1489                         {
1490                         GtkTreeSelection *selection;
1491                         GtkTreePath *tpath;
1492
1493                         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
1494                         gtk_tree_selection_unselect_all(selection);
1495                         gtk_tree_selection_select_iter(selection, &iter);
1496
1497                         tpath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
1498                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
1499                         gtk_tree_path_free(tpath);
1500                         }
1501                 }
1502
1503         if (sd->thumb_enable &&
1504             sd->click_fd && sd->click_fd->thumb_pixbuf)
1505                 {
1506                 dnd_set_drag_icon(widget, context, sd->click_fd->thumb_pixbuf, search_result_selection_count(sd, NULL));
1507                 }
1508 }
1509
1510 static void search_gps_dnd_received_cb(GtkWidget *pane, GdkDragContext *context,
1511                                                                                 gint x, gint y,
1512                                                                                 GtkSelectionData *selection_data, guint info,
1513                                                                                 guint time, gpointer data)
1514 {
1515         SearchData *sd = data;
1516         GList *list;
1517         gdouble latitude, longitude;
1518         FileData *fd;
1519
1520         if (info == TARGET_URI_LIST)
1521                 {
1522                 list = uri_filelist_from_gtk_selection_data(selection_data);
1523
1524                 /* If more than one file, use only the first file in a list.
1525                 */
1526                 if (list != NULL)
1527                         {
1528                         fd = list->data;
1529                         latitude = metadata_read_GPS_coord(fd, "Xmp.exif.GPSLatitude", 1000);
1530                         longitude = metadata_read_GPS_coord(fd, "Xmp.exif.GPSLongitude", 1000);
1531                         if (latitude != 1000 && longitude != 1000)
1532                                 {
1533                                 gtk_entry_set_text(GTK_ENTRY(sd->entry_gps_coord),
1534                                                         g_strdup_printf("%lf %lf", latitude, longitude));
1535                                 }
1536                         else
1537                                 {
1538                                 gtk_entry_set_text(GTK_ENTRY(sd->entry_gps_coord), "Image is not geocoded");
1539                                 }
1540                         }
1541                 }
1542
1543         if (info == TARGET_TEXT_PLAIN)
1544                 {
1545                 gtk_entry_set_text(GTK_ENTRY(sd->entry_gps_coord),"");
1546                 }
1547 }
1548
1549 static void search_path_entry_dnd_received_cb(GtkWidget *pane, GdkDragContext *context,
1550                                                                                 gint x, gint y,
1551                                                                                 GtkSelectionData *selection_data, guint info,
1552                                                                                 guint time, gpointer data)
1553 {
1554         SearchData *sd = data;
1555         GList *list;
1556         FileData *fd;
1557
1558         if (info == TARGET_URI_LIST)
1559                 {
1560                 list = uri_filelist_from_gtk_selection_data(selection_data);
1561                 /* If more than one file, use only the first file in a list.
1562                 */
1563                 if (list != NULL)
1564                         {
1565                         fd = list->data;
1566                         gtk_entry_set_text(GTK_ENTRY(sd->path_entry),
1567                                                 g_strdup_printf("%s", fd->path));
1568                         gtk_widget_set_tooltip_text(GTK_WIDGET(sd->path_entry),g_strdup_printf("%s", fd->path));
1569                         }
1570                 }
1571
1572         if (info == TARGET_TEXT_PLAIN)
1573                 {
1574                 gtk_entry_set_text(GTK_ENTRY(sd->path_entry),"");
1575                 }
1576 }
1577
1578 static void search_image_content_dnd_received_cb(GtkWidget *pane, GdkDragContext *context,
1579                                                                                 gint x, gint y,
1580                                                                                 GtkSelectionData *selection_data, guint info,
1581                                                                                 guint time, gpointer data)
1582 {
1583         SearchData *sd = data;
1584         GList *list;
1585         FileData *fd;
1586
1587         if (info == TARGET_URI_LIST)
1588                 {
1589                 list = uri_filelist_from_gtk_selection_data(selection_data);
1590                 /* If more than one file, use only the first file in a list.
1591                 */
1592                 if (list != NULL)
1593                         {
1594                         fd = list->data;
1595                         gtk_entry_set_text(GTK_ENTRY(sd->entry_similarity),
1596                                                 g_strdup_printf("%s", fd->path));
1597                         gtk_widget_set_tooltip_text(GTK_WIDGET(sd->entry_similarity),g_strdup_printf("%s", fd->path));
1598                         }
1599                 }
1600
1601         if (info == TARGET_TEXT_PLAIN)
1602                 {
1603                 gtk_entry_set_text(GTK_ENTRY(sd->entry_similarity),"");
1604                 }
1605 }
1606
1607 static void search_dnd_init(SearchData *sd)
1608 {
1609         gtk_drag_source_set(sd->result_view, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
1610                             result_drag_types, n_result_drag_types,
1611                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
1612         g_signal_connect(G_OBJECT(sd->result_view), "drag_data_get",
1613                          G_CALLBACK(search_dnd_data_set), sd);
1614         g_signal_connect(G_OBJECT(sd->result_view), "drag_begin",
1615                          G_CALLBACK(search_dnd_begin), sd);
1616
1617         gtk_drag_dest_set(GTK_WIDGET(sd->entry_gps_coord),
1618                                          GTK_DEST_DEFAULT_ALL,
1619                                           result_drop_types, n_result_drop_types,
1620                                          GDK_ACTION_COPY);
1621
1622         g_signal_connect(G_OBJECT(sd->entry_gps_coord), "drag_data_received",
1623                                         G_CALLBACK(search_gps_dnd_received_cb), sd);
1624
1625         gtk_drag_dest_set(GTK_WIDGET(sd->path_entry),
1626                                         GTK_DEST_DEFAULT_ALL,
1627                                         result_drop_types, n_result_drop_types,
1628                                         GDK_ACTION_COPY);
1629
1630         g_signal_connect(G_OBJECT(sd->path_entry), "drag_data_received",
1631                                         G_CALLBACK(search_path_entry_dnd_received_cb), sd);
1632
1633         gtk_drag_dest_set(GTK_WIDGET(sd->entry_similarity),
1634                                         GTK_DEST_DEFAULT_ALL,
1635                                         result_drop_types, n_result_drop_types,
1636                                         GDK_ACTION_COPY);
1637
1638         g_signal_connect(G_OBJECT(sd->entry_similarity), "drag_data_received",
1639                                         G_CALLBACK(search_image_content_dnd_received_cb), sd);
1640 }
1641
1642 /*
1643  *-------------------------------------------------------------------
1644  * search core
1645  *-------------------------------------------------------------------
1646  */
1647
1648 #define MATCH_IS_BETWEEN(val, a, b)  (b > a ? (val >= a && val <= b) : (val >= b && val <= a))
1649
1650 static gboolean search_step_cb(gpointer data);
1651
1652
1653 static void search_buffer_flush(SearchData *sd)
1654 {
1655         GList *work;
1656
1657         work = g_list_last(sd->search_buffer_list);
1658         while (work)
1659                 {
1660                 MatchFileData *mfd = work->data;
1661                 work = work->prev;
1662
1663                 search_result_append(sd, mfd);
1664                 }
1665
1666         g_list_free(sd->search_buffer_list);
1667         sd->search_buffer_list = NULL;
1668         sd->search_buffer_count = 0;
1669 }
1670
1671 static void search_stop(SearchData *sd)
1672 {
1673         if (sd->search_idle_id)
1674                 {
1675                 g_source_remove(sd->search_idle_id);
1676                 sd->search_idle_id = 0;
1677                 }
1678
1679         image_loader_free(sd->img_loader);
1680         sd->img_loader = NULL;
1681         cache_sim_data_free(sd->img_cd);
1682         sd->img_cd = NULL;
1683
1684         cache_sim_data_free(sd->search_similarity_cd);
1685         sd->search_similarity_cd = NULL;
1686
1687         search_buffer_flush(sd);
1688
1689         filelist_free(sd->search_folder_list);
1690         sd->search_folder_list = NULL;
1691
1692         g_list_free(sd->search_done_list);
1693         sd->search_done_list = NULL;
1694
1695         filelist_free(sd->search_file_list);
1696         sd->search_file_list = NULL;
1697
1698         gtk_widget_set_sensitive(sd->box_search, TRUE);
1699         spinner_set_interval(sd->spinner, -1);
1700         gtk_widget_set_sensitive(sd->button_start, TRUE);
1701         gtk_widget_set_sensitive(sd->button_stop, FALSE);
1702         search_progress_update(sd, TRUE, -1.0);
1703         search_status_update(sd);
1704 }
1705
1706 static void search_file_load_process(SearchData *sd, CacheData *cd)
1707 {
1708         GdkPixbuf *pixbuf;
1709
1710         pixbuf = image_loader_get_pixbuf(sd->img_loader);
1711
1712         if (cd && pixbuf)
1713                 {
1714                 if (!cd->dimensions)
1715                         {
1716                         cache_sim_data_set_dimensions(cd, gdk_pixbuf_get_width(pixbuf),
1717                                                           gdk_pixbuf_get_height(pixbuf));
1718                         }
1719
1720                 if (sd->match_similarity_enable && !cd->similarity)
1721                         {
1722                         ImageSimilarityData *sim;
1723
1724                         sim = image_sim_new_from_pixbuf(pixbuf);
1725                         cache_sim_data_set_similarity(cd, sim);
1726                         image_sim_free(sim);
1727                         }
1728
1729                 if (options->thumbnails.enable_caching &&
1730                     sd->img_loader && image_loader_get_fd(sd->img_loader))
1731                         {
1732                         gchar *base;
1733                         const gchar *path;
1734                         mode_t mode = 0755;
1735
1736                         path = image_loader_get_fd(sd->img_loader)->path;
1737                         base = cache_get_location(CACHE_TYPE_SIM, path, FALSE, &mode);
1738                         if (recursive_mkdir_if_not_exists(base, mode))
1739                                 {
1740                                 g_free(cd->path);
1741                                 cd->path = cache_get_location(CACHE_TYPE_SIM, path, TRUE, NULL);
1742                                 if (cache_sim_data_save(cd))
1743                                         {
1744                                         filetime_set(cd->path, filetime(image_loader_get_fd(sd->img_loader)->path));
1745                                         }
1746                                 }
1747                         g_free(base);
1748                         }
1749                 }
1750
1751         image_loader_free(sd->img_loader);
1752         sd->img_loader = NULL;
1753
1754         sd->search_idle_id = g_idle_add(search_step_cb, sd);
1755 }
1756
1757 static void search_file_load_done_cb(ImageLoader *il, gpointer data)
1758 {
1759         SearchData *sd = data;
1760         search_file_load_process(sd, sd->img_cd);
1761 }
1762
1763 static gboolean search_file_do_extra(SearchData *sd, FileData *fd, gint *match,
1764                                      gint *width, gint *height, gint *simval)
1765 {
1766         gboolean new_data = FALSE;
1767         gboolean tmatch = TRUE;
1768         gboolean tested = FALSE;
1769
1770         if (!sd->img_cd)
1771                 {
1772                 gchar *cd_path;
1773
1774                 new_data = TRUE;
1775
1776                 cd_path = cache_find_location(CACHE_TYPE_SIM, fd->path);
1777                 if (cd_path && filetime(fd->path) == filetime(cd_path))
1778                         {
1779                         sd->img_cd = cache_sim_data_load(cd_path);
1780                         }
1781                 g_free(cd_path);
1782                 }
1783
1784         if (!sd->img_cd)
1785                 {
1786                 sd->img_cd = cache_sim_data_new();
1787                 }
1788
1789         if (new_data)
1790                 {
1791                 if ((sd->match_dimensions_enable && !sd->img_cd->dimensions) ||
1792                     (sd->match_similarity_enable && !sd->img_cd->similarity))
1793                         {
1794                         sd->img_loader = image_loader_new(fd);
1795                         g_signal_connect(G_OBJECT(sd->img_loader), "error", (GCallback)search_file_load_done_cb, sd);
1796                         g_signal_connect(G_OBJECT(sd->img_loader), "done", (GCallback)search_file_load_done_cb, sd);
1797                         if (image_loader_start(sd->img_loader))
1798                                 {
1799                                 return TRUE;
1800                                 }
1801                         else
1802                                 {
1803                                 image_loader_free(sd->img_loader);
1804                                 sd->img_loader = NULL;
1805                                 }
1806                         }
1807                 }
1808
1809         if (tmatch && sd->match_dimensions_enable && sd->img_cd->dimensions)
1810                 {
1811                 CacheData *cd = sd->img_cd;
1812
1813                 tmatch = FALSE;
1814                 tested = TRUE;
1815
1816                 if (sd->match_dimensions == SEARCH_MATCH_EQUAL)
1817                         {
1818                         tmatch = (cd->width == sd->search_width && cd->height == sd->search_height);
1819                         }
1820                 else if (sd->match_dimensions == SEARCH_MATCH_UNDER)
1821                         {
1822                         tmatch = (cd->width < sd->search_width && cd->height < sd->search_height);
1823                         }
1824                 else if (sd->match_dimensions == SEARCH_MATCH_OVER)
1825                         {
1826                         tmatch = (cd->width > sd->search_width && cd->height > sd->search_height);
1827                         }
1828                 else if (sd->match_dimensions == SEARCH_MATCH_BETWEEN)
1829                         {
1830                         tmatch = (MATCH_IS_BETWEEN(cd->width, sd->search_width, sd->search_width_end) &&
1831                                   MATCH_IS_BETWEEN(cd->height, sd->search_height, sd->search_height_end));
1832                         }
1833                 }
1834
1835         if (tmatch && sd->match_similarity_enable && sd->img_cd->similarity)
1836                 {
1837                 gdouble value = 0.0;
1838
1839                 tmatch = FALSE;
1840                 tested = TRUE;
1841
1842                 /* fixme: implement similarity checking */
1843                 if (sd->search_similarity_cd && sd->search_similarity_cd->similarity)
1844                         {
1845                         gdouble result;
1846
1847                         result = image_sim_compare_fast(sd->search_similarity_cd->sim, sd->img_cd->sim,
1848                                                         (gdouble)sd->search_similarity / 100.0);
1849                         result *= 100.0;
1850                         if (result >= (gdouble)sd->search_similarity)
1851                                 {
1852                                 tmatch = TRUE;
1853                                 value = (gint)result;
1854                                 }
1855                         }
1856
1857                 if (simval) *simval = value;
1858                 }
1859
1860         if (sd->img_cd->dimensions)
1861                 {
1862                 if (width) *width = sd->img_cd->width;
1863                 if (height) *height = sd->img_cd->height;
1864                 }
1865
1866         cache_sim_data_free(sd->img_cd);
1867         sd->img_cd = NULL;
1868
1869         *match = (tmatch && tested);
1870
1871         return FALSE;
1872 }
1873
1874 static gboolean search_file_next(SearchData *sd)
1875 {
1876         FileData *fd;
1877         gboolean match = TRUE;
1878         gboolean tested = FALSE;
1879         gboolean extra_only = FALSE;
1880         gint width = 0;
1881         gint height = 0;
1882         gint sim = 0;
1883         time_t file_date;
1884
1885         if (!sd->search_file_list) return FALSE;
1886
1887         if (sd->img_cd)
1888                 {
1889                 /* on end of a CacheData load, skip recomparing non-extra match types */
1890                 extra_only = TRUE;
1891                 match = FALSE;
1892                 }
1893         else
1894                 {
1895                 sd->search_total++;
1896                 }
1897
1898         fd = sd->search_file_list->data;
1899
1900         if (match && sd->match_name_enable && sd->search_name)
1901                 {
1902                 tested = TRUE;
1903                 match = FALSE;
1904
1905                 if (sd->match_name == SEARCH_MATCH_EQUAL)
1906                         {
1907                         if (sd->search_name_match_case)
1908                                 {
1909                                 match = (strcmp(fd->name, sd->search_name) == 0);
1910                                 }
1911                         else
1912                                 {
1913                                 match = (g_ascii_strcasecmp(fd->name, sd->search_name) == 0);
1914                                 }
1915                         }
1916                 else if (sd->match_name == SEARCH_MATCH_CONTAINS)
1917                         {
1918                         if (sd->search_name_match_case)
1919                                 {
1920                                 match = g_regex_match(sd->search_name_regex, fd->name, 0, NULL);
1921                                 }
1922                         else
1923                                 {
1924                                 /* sd->search_name is converted in search_start() */
1925                                 gchar *haystack = g_utf8_strdown(fd->name, -1);
1926                                 match = g_regex_match(sd->search_name_regex, haystack, 0, NULL);
1927                                 g_free(haystack);
1928                                 }
1929                         }
1930                 }
1931
1932         if (match && sd->match_size_enable)
1933                 {
1934                 tested = TRUE;
1935                 match = FALSE;
1936
1937                 if (sd->match_size == SEARCH_MATCH_EQUAL)
1938                         {
1939                         match = (fd->size == sd->search_size);
1940                         }
1941                 else if (sd->match_size == SEARCH_MATCH_UNDER)
1942                         {
1943                         match = (fd->size < sd->search_size);
1944                         }
1945                 else if (sd->match_size == SEARCH_MATCH_OVER)
1946                         {
1947                         match = (fd->size > sd->search_size);
1948                         }
1949                 else if (sd->match_size == SEARCH_MATCH_BETWEEN)
1950                         {
1951                         match = MATCH_IS_BETWEEN(fd->size, sd->search_size, sd->search_size_end);
1952                         }
1953                 }
1954
1955         if (match && sd->match_date_enable)
1956                 {
1957                 tested = TRUE;
1958                 match = FALSE;
1959
1960                 if (g_strcmp0(gtk_combo_box_text_get_active_text(
1961                                                 GTK_COMBO_BOX_TEXT(sd->date_type)), _("Changed")) == 0)
1962                         {
1963                         file_date = fd->cdate;
1964                         }
1965                 else if (g_strcmp0(gtk_combo_box_text_get_active_text(
1966                                                 GTK_COMBO_BOX_TEXT(sd->date_type)), _("Original")) == 0)
1967                         {
1968                         read_exif_time_data(fd);
1969                         file_date = fd->exifdate;
1970                         }
1971                 else if (g_strcmp0(gtk_combo_box_text_get_active_text(
1972                                                 GTK_COMBO_BOX_TEXT(sd->date_type)), _("Digitized")) == 0)
1973                         {
1974                         read_exif_time_digitized_data(fd);
1975                         file_date = fd->exifdate_digitized;
1976                         }
1977                 else
1978                         {
1979                         file_date = fd->date;
1980                         }
1981
1982                 if (sd->match_date == SEARCH_MATCH_EQUAL)
1983                         {
1984                         struct tm *lt;
1985
1986                         lt = localtime(&file_date);
1987                         match = (lt &&
1988                                  lt->tm_year == sd->search_date_y - 1900 &&
1989                                  lt->tm_mon == sd->search_date_m - 1 &&
1990                                  lt->tm_mday == sd->search_date_d);
1991                         }
1992                 else if (sd->match_date == SEARCH_MATCH_UNDER)
1993                         {
1994                         match = (file_date < convert_dmy_to_time(sd->search_date_d, sd->search_date_m, sd->search_date_y));
1995                         }
1996                 else if (sd->match_date == SEARCH_MATCH_OVER)
1997                         {
1998                         match = (file_date > convert_dmy_to_time(sd->search_date_d, sd->search_date_m, sd->search_date_y) + 60 * 60 * 24 - 1);
1999                         }
2000                 else if (sd->match_date == SEARCH_MATCH_BETWEEN)
2001                         {
2002                         time_t a = convert_dmy_to_time(sd->search_date_d, sd->search_date_m, sd->search_date_y);
2003                         time_t b = convert_dmy_to_time(sd->search_date_end_d, sd->search_date_end_m, sd->search_date_end_y);
2004
2005                         if (b >= a)
2006                                 {
2007                                 b += 60 * 60 * 24 - 1;
2008                                 }
2009                         else
2010                                 {
2011                                 a += 60 * 60 * 24 - 1;
2012                                 }
2013                         match = MATCH_IS_BETWEEN(file_date, a, b);
2014                         }
2015                 }
2016
2017         if (match && sd->match_keywords_enable && sd->search_keyword_list)
2018                 {
2019                 GList *list;
2020
2021                 tested = TRUE;
2022                 match = FALSE;
2023
2024                 list = metadata_read_list(fd, KEYWORD_KEY, METADATA_PLAIN);
2025
2026                 if (list)
2027                         {
2028                         GList *needle;
2029                         GList *haystack;
2030
2031                         if (sd->match_keywords == SEARCH_MATCH_ALL)
2032                                 {
2033                                 gboolean found = TRUE;
2034
2035                                 needle = sd->search_keyword_list;
2036                                 while (needle && found)
2037                                         {
2038                                         found = FALSE;
2039                                         haystack = list;
2040                                         while (haystack && !found)
2041                                                 {
2042                                                 found = (g_ascii_strcasecmp((gchar *)needle->data,
2043                                                                     (gchar *)haystack->data) == 0);
2044                                                 haystack = haystack->next;
2045                                                 }
2046                                         needle = needle->next;
2047                                         }
2048
2049                                 match = found;
2050                                 }
2051                         else if (sd->match_keywords == SEARCH_MATCH_ANY)
2052                                 {
2053                                 gboolean found = FALSE;
2054
2055                                 needle = sd->search_keyword_list;
2056                                 while (needle && !found)
2057                                         {
2058                                         haystack = list;
2059                                         while (haystack && !found)
2060                                                 {
2061                                                 found = (g_ascii_strcasecmp((gchar *)needle->data,
2062                                                                     (gchar *)haystack->data) == 0);
2063                                                 haystack = haystack->next;
2064                                                 }
2065                                         needle = needle->next;
2066                                         }
2067
2068                                 match = found;
2069                                 }
2070                         else if (sd->match_keywords == SEARCH_MATCH_NONE)
2071                                 {
2072                                 gboolean found = FALSE;
2073
2074                                 needle = sd->search_keyword_list;
2075                                 while (needle && !found)
2076                                         {
2077                                         haystack = list;
2078                                         while (haystack && !found)
2079                                                 {
2080                                                 found = (g_ascii_strcasecmp((gchar *)needle->data,
2081                                                                     (gchar *)haystack->data) == 0);
2082                                                 haystack = haystack->next;
2083                                                 }
2084                                         needle = needle->next;
2085                                         }
2086
2087                                 match = !found;
2088                                 }
2089                         string_list_free(list);
2090                         }
2091                 else
2092                         {
2093                         match = (sd->match_keywords == SEARCH_MATCH_NONE);
2094                         }
2095                 }
2096
2097         if (match && sd->match_comment_enable && sd->search_comment && strlen(sd->search_comment))
2098                 {
2099                 gchar *comment;
2100
2101                 tested = TRUE;
2102                 match = FALSE;
2103
2104                 comment = metadata_read_string(fd, COMMENT_KEY, METADATA_PLAIN);
2105
2106                 if (comment)
2107                         {
2108                         if (!sd->search_comment_match_case)
2109                                 {
2110                                 gchar *tmp = g_utf8_strdown(comment, -1);
2111                                 g_free(comment);
2112                                 comment = tmp;
2113                                 }
2114
2115                         if (sd->match_comment == SEARCH_MATCH_CONTAINS)
2116                                 {
2117                                 match = g_regex_match(sd->search_comment_regex, comment, 0, NULL);
2118                                 }
2119                         else if (sd->match_comment == SEARCH_MATCH_NONE)
2120                                 {
2121                                 match = !g_regex_match(sd->search_comment_regex, comment, 0, NULL);
2122                                 }
2123                         g_free(comment);
2124                         }
2125                 else
2126                         {
2127                         match = (sd->match_comment == SEARCH_MATCH_NONE);
2128                         }
2129                 }
2130
2131         if (match && sd->match_rating_enable)
2132                 {
2133                 tested = TRUE;
2134                 match = FALSE;
2135                 gint rating;
2136
2137                 rating = metadata_read_int(fd, RATING_KEY, 0);
2138                 if (sd->match_rating == SEARCH_MATCH_EQUAL)
2139                         {
2140                         match = (rating == sd->search_rating);
2141                         }
2142                 else if (sd->match_rating == SEARCH_MATCH_UNDER)
2143                         {
2144                         match = (rating < sd->search_rating);
2145                         }
2146                 else if (sd->match_rating == SEARCH_MATCH_OVER)
2147                         {
2148                         match = (rating > sd->search_rating);
2149                         }
2150                 else if (sd->match_rating == SEARCH_MATCH_BETWEEN)
2151                         {
2152                         match = MATCH_IS_BETWEEN(rating, sd->search_rating, sd->search_rating_end);
2153                         }
2154                 }
2155
2156         if (match && sd->match_class_enable)
2157                 {
2158                 tested = TRUE;
2159                 match = FALSE;
2160                 gint class;
2161                 FileFormatClass search_class;
2162
2163                 if (g_strcmp0(gtk_combo_box_text_get_active_text(
2164                                                 GTK_COMBO_BOX_TEXT(sd->class_type)), _("Image")) == 0)
2165                         {
2166                         search_class = FORMAT_CLASS_IMAGE;
2167                         }
2168                 else if (g_strcmp0(gtk_combo_box_text_get_active_text(
2169                                                 GTK_COMBO_BOX_TEXT(sd->class_type)), _("Raw Image")) == 0)
2170                         {
2171                         search_class = FORMAT_CLASS_RAWIMAGE;
2172                         }
2173                 else if (g_strcmp0(gtk_combo_box_text_get_active_text(
2174                                                 GTK_COMBO_BOX_TEXT(sd->class_type)), _("Video")) == 0)
2175                         {
2176                         search_class = FORMAT_CLASS_VIDEO;
2177                         }
2178                 else if (g_strcmp0(gtk_combo_box_text_get_active_text(
2179                                                 GTK_COMBO_BOX_TEXT(sd->class_type)), _("Metadata")) == 0)
2180                         {
2181                         search_class = FORMAT_CLASS_META;
2182                         }
2183                 else
2184                         {
2185                         search_class = FORMAT_CLASS_UNKNOWN;
2186                         }
2187
2188                 class = fd->format_class;
2189                 if (sd->match_class == SEARCH_MATCH_EQUAL)
2190                         {
2191                         match = (class == search_class);
2192                         }
2193                 else if (sd->match_class == SEARCH_MATCH_NONE)
2194                         {
2195                         match = (class != search_class);
2196                         }
2197                 }
2198
2199         if (match && sd->match_marks_enable)
2200                 {
2201                 tested = TRUE;
2202                 match = FALSE;
2203                 gint search_marks;
2204                 gint i;
2205                 gchar *marks_string;
2206
2207                 if (g_strcmp0(gtk_combo_box_text_get_active_text(
2208                                                 GTK_COMBO_BOX_TEXT(sd->marks_type)), _("Any mark")) == 0)
2209                         {
2210                         search_marks = -1;
2211                         }
2212                 else
2213                         {
2214                         for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
2215                                 {
2216                                 marks_string = g_strdup_printf("%s%d", _("Mark "), i + 1);
2217                                 if (g_strcmp0(marks_string, options->marks_tooltips[i]) != 0)
2218                                         {
2219                                         g_free(marks_string);
2220                                         marks_string = g_strdup_printf("%s%d %s", _("Mark "), i + 1,
2221                                                                                                         options->marks_tooltips[i]);
2222                                         }
2223
2224                                 if (g_strcmp0(gtk_combo_box_text_get_active_text(
2225                                                                 GTK_COMBO_BOX_TEXT(sd->marks_type)),
2226                                                                 marks_string) == 0)
2227                                         {
2228                                         search_marks = 1 << i;
2229                                         }
2230                                 g_free(marks_string);
2231                                 }
2232                         }
2233
2234                 if (sd->match_marks == SEARCH_MATCH_EQUAL)
2235                         {
2236                         match = (fd->marks & search_marks);
2237                         }
2238                 else
2239                         {
2240                         if (search_marks == -1)
2241                                 {
2242                                 match = fd->marks ? FALSE : TRUE;
2243                                 }
2244                         else
2245                                 {
2246                                 match = (fd->marks & search_marks) ? FALSE : TRUE;
2247                                 }
2248                         }
2249                 }
2250
2251         if (match && sd->match_gps_enable)
2252                 {
2253                 /* Calculate the distance the image is from the specified origin.
2254                 * This is a standard algorithm. A simplified one may be faster.
2255                 */
2256                 #define RADIANS  0.0174532925
2257                 #define KM_EARTH_RADIUS 6371
2258                 #define MILES_EARTH_RADIUS 3959
2259                 #define NAUTICAL_MILES_EARTH_RADIUS 3440
2260
2261                 gdouble latitude, longitude, range, conversion;
2262
2263                 if (g_strcmp0(gtk_combo_box_text_get_active_text(
2264                                                 GTK_COMBO_BOX_TEXT(sd->units_gps)), _("km")) == 0)
2265                         {
2266                         conversion = KM_EARTH_RADIUS;
2267                         }
2268                 else if (g_strcmp0(gtk_combo_box_text_get_active_text(
2269                                                 GTK_COMBO_BOX_TEXT(sd->units_gps)), _("miles")) == 0)
2270                         {
2271                         conversion = MILES_EARTH_RADIUS;
2272                         }
2273                 else
2274                         {
2275                         conversion = NAUTICAL_MILES_EARTH_RADIUS;
2276                         }
2277
2278                 tested = TRUE;
2279                 match = FALSE;
2280
2281                 latitude = metadata_read_GPS_coord(fd, "Xmp.exif.GPSLatitude", 1000);
2282                 longitude = metadata_read_GPS_coord(fd, "Xmp.exif.GPSLongitude", 1000);
2283                 if (latitude != 1000 && longitude != 1000)
2284                         {
2285                         range = conversion * acos(sin(latitude * RADIANS) *
2286                                                 sin(sd->search_lat * RADIANS) + cos(latitude * RADIANS) *
2287                                                 cos(sd->search_lat * RADIANS) * cos((sd->search_lon -
2288                                                 longitude) * RADIANS));
2289                         if (sd->match_gps == SEARCH_MATCH_UNDER)
2290                                 {
2291                                 if (sd->search_gps >= range)
2292                                         match = TRUE;
2293                                 }
2294                         else if (sd->match_gps == SEARCH_MATCH_OVER)
2295                                 {
2296                                 if (sd->search_gps < range)
2297                                         match = TRUE;
2298                                 }
2299                         }
2300                 else if (sd->match_gps == SEARCH_MATCH_NONE)
2301                         {
2302                         match = TRUE;
2303                         }
2304                 }
2305
2306         if ((match || extra_only) && (sd->match_dimensions_enable ||
2307                                                                 sd ->match_similarity_enable))
2308                 {
2309                 tested = TRUE;
2310
2311                 if (search_file_do_extra(sd, fd, &match, &width, &height, &sim))
2312                         {
2313                         sd->search_buffer_count += SEARCH_BUFFER_MATCH_LOAD;
2314                         return TRUE;
2315                         }
2316                 }
2317
2318         sd->search_file_list = g_list_remove(sd->search_file_list, fd);
2319
2320         if (tested && match)
2321                 {
2322                 MatchFileData *mfd;
2323
2324                 mfd = g_new(MatchFileData, 1);
2325                 mfd->fd = fd;
2326
2327                 mfd->width = width;
2328                 mfd->height = height;
2329                 mfd->rank = sim;
2330
2331                 sd->search_buffer_list = g_list_prepend(sd->search_buffer_list, mfd);
2332                 sd->search_buffer_count += SEARCH_BUFFER_MATCH_HIT;
2333                 sd->search_count++;
2334                 search_progress_update(sd, TRUE, -1.0);
2335                 }
2336         else
2337                 {
2338                 file_data_unref(fd);
2339                 sd->search_buffer_count += SEARCH_BUFFER_MATCH_MISS;
2340                 }
2341
2342         return FALSE;
2343 }
2344
2345 static gboolean search_step_cb(gpointer data)
2346 {
2347         SearchData *sd = data;
2348         FileData *fd;
2349
2350         if (sd->search_buffer_count > SEARCH_BUFFER_FLUSH_SIZE)
2351                 {
2352                 search_buffer_flush(sd);
2353                 search_progress_update(sd, TRUE, -1.0);
2354                 }
2355
2356         if (sd->search_file_list)
2357                 {
2358                 if (search_file_next(sd))
2359                         {
2360                         sd->search_idle_id = 0;
2361                         return FALSE;
2362                         }
2363                 return TRUE;
2364                 }
2365
2366         if (!sd->search_file_list && !sd->search_folder_list)
2367                 {
2368                 sd->search_idle_id = 0;
2369
2370                 search_stop(sd);
2371                 search_result_thumb_step(sd);
2372
2373                 return FALSE;
2374                 }
2375
2376         fd = sd->search_folder_list->data;
2377
2378         if (g_list_find(sd->search_done_list, fd) == NULL)
2379                 {
2380                 GList *list = NULL;
2381                 GList *dlist = NULL;
2382                 gboolean success = FALSE;
2383
2384                 sd->search_done_list = g_list_prepend(sd->search_done_list, fd);
2385
2386                 if (sd->search_type == SEARCH_MATCH_NONE)
2387                         {
2388                         success = filelist_read(fd, &list, &dlist);
2389                         }
2390                 else if (sd->search_type == SEARCH_MATCH_ALL &&
2391                          sd->search_dir_fd &&
2392                          strlen(fd->path) >= strlen(sd->search_dir_fd->path))
2393                         {
2394                         const gchar *path;
2395
2396                         path = fd->path + strlen(sd->search_dir_fd->path);
2397                         if (path != fd->path)
2398                                 {
2399                                 FileData *dir_fd = file_data_new_dir(path);
2400                                 success = filelist_read(dir_fd, &list, NULL);
2401                                 file_data_unref(dir_fd);
2402                                 }
2403                         success |= filelist_read(fd, NULL, &dlist);
2404                         if (success)
2405                                 {
2406                                 GList *work;
2407
2408                                 work = list;
2409                                 while (work)
2410                                         {
2411                                         FileData *fdp;
2412                                         GList *link;
2413                                         gchar *meta_path;
2414
2415                                         fdp = work->data;
2416                                         link = work;
2417                                         work = work->next;
2418
2419                                         meta_path = cache_find_location(CACHE_TYPE_METADATA, fdp->path);
2420                                         if (!meta_path)
2421                                                 {
2422                                                 list = g_list_delete_link(list, link);
2423                                                 file_data_unref(fdp);
2424                                                 }
2425                                         g_free(meta_path);
2426                                         }
2427                                 }
2428                         }
2429
2430                 if (success)
2431                         {
2432                         list = filelist_sort(list, SORT_NAME, TRUE);
2433                         sd->search_file_list = list;
2434
2435                         if (sd->search_path_recurse)
2436                                 {
2437                                 dlist = filelist_sort(dlist, SORT_NAME, TRUE);
2438                                 sd->search_folder_list = g_list_concat(dlist, sd->search_folder_list);
2439                                 }
2440                         else
2441                                 {
2442                                 filelist_free(dlist);
2443                                 }
2444                         }
2445                 }
2446         else
2447                 {
2448                 sd->search_folder_list = g_list_remove(sd->search_folder_list, fd);
2449                 sd->search_done_list = g_list_remove(sd->search_done_list, fd);
2450                 file_data_unref(fd);
2451                 }
2452
2453         return TRUE;
2454 }
2455
2456 static void search_similarity_load_done_cb(ImageLoader *il, gpointer data)
2457 {
2458         SearchData *sd = data;
2459         search_file_load_process(sd, sd->search_similarity_cd);
2460 }
2461
2462 static void search_start(SearchData *sd)
2463 {
2464         GError *error = NULL;
2465
2466         search_stop(sd);
2467         search_result_clear(sd);
2468
2469         if (sd->search_dir_fd)
2470                 {
2471                 sd->search_folder_list = g_list_prepend(sd->search_folder_list, file_data_ref(sd->search_dir_fd));
2472                 }
2473
2474         if (!sd->search_name_match_case)
2475                 {
2476                 /* convert to lowercase here, so that this is only done once per search */
2477                 gchar *tmp = g_utf8_strdown(sd->search_name, -1);
2478                 g_free(sd->search_name);
2479                 sd->search_name = tmp;
2480                 }
2481
2482         if(sd->search_name_regex)
2483                 {
2484                 g_regex_unref(sd->search_name_regex);
2485                 }
2486
2487         sd->search_name_regex = g_regex_new(sd->search_name, 0, 0, &error);
2488         if (error)
2489                 {
2490                 log_printf("Error: could not compile regular expression %s\n%s\n", sd->search_name, error->message);
2491                 g_error_free(error);
2492                 error = NULL;
2493                 sd->search_name_regex = g_regex_new("", 0, 0, NULL);
2494                 }
2495
2496         if (!sd->search_comment_match_case)
2497                 {
2498                 /* convert to lowercase here, so that this is only done once per search */
2499                 gchar *tmp = g_utf8_strdown(sd->search_comment, -1);
2500                 g_free(sd->search_comment);
2501                 sd->search_comment = tmp;
2502                 }
2503
2504         if(sd->search_comment_regex)
2505                 {
2506                 g_regex_unref(sd->search_comment_regex);
2507                 }
2508
2509         sd->search_comment_regex = g_regex_new(sd->search_comment, 0, 0, &error);
2510         if (error)
2511                 {
2512                 log_printf("Error: could not compile regular expression %s\n%s\n", sd->search_comment, error->message);
2513                 g_error_free(error);
2514                 error = NULL;
2515                 sd->search_comment_regex = g_regex_new("", 0, 0, NULL);
2516                 }
2517
2518         sd->search_count = 0;
2519         sd->search_total = 0;
2520
2521         gtk_widget_set_sensitive(sd->box_search, FALSE);
2522         spinner_set_interval(sd->spinner, SPINNER_SPEED);
2523         gtk_widget_set_sensitive(sd->button_start, FALSE);
2524         gtk_widget_set_sensitive(sd->button_stop, TRUE);
2525         search_progress_update(sd, TRUE, -1.0);
2526
2527         if (sd->match_similarity_enable &&
2528             !sd->search_similarity_cd &&
2529             isfile(sd->search_similarity_path))
2530                 {
2531                 gchar *cd_path;
2532
2533                 cd_path = cache_find_location(CACHE_TYPE_SIM, sd->search_similarity_path);
2534                 if (cd_path && filetime(sd->search_similarity_path) == filetime(cd_path))
2535                         {
2536                         sd->search_similarity_cd = cache_sim_data_load(cd_path);
2537                         }
2538                 g_free(cd_path);
2539
2540                 if (!sd->search_similarity_cd || !sd->search_similarity_cd->similarity)
2541                         {
2542                         if (!sd->search_similarity_cd)
2543                                 {
2544                                 sd->search_similarity_cd = cache_sim_data_new();
2545                                 }
2546
2547                         sd->img_loader = image_loader_new(file_data_new_group(sd->search_similarity_path));
2548                         g_signal_connect(G_OBJECT(sd->img_loader), "error", (GCallback)search_similarity_load_done_cb, sd);
2549                         g_signal_connect(G_OBJECT(sd->img_loader), "done", (GCallback)search_similarity_load_done_cb, sd);
2550                         if (image_loader_start(sd->img_loader))
2551                                 {
2552                                 return;
2553                                 }
2554                         image_loader_free(sd->img_loader);
2555                         sd->img_loader = NULL;
2556                         }
2557
2558                 }
2559
2560         sd->search_idle_id = g_idle_add(search_step_cb, sd);
2561 }
2562
2563 static void search_start_cb(GtkWidget *widget, gpointer data)
2564 {
2565         SearchData *sd = data;
2566         GtkTreeViewColumn *column;
2567         gchar *path;
2568         gchar *entry_text;
2569
2570         if (sd->search_folder_list)
2571                 {
2572                 search_stop(sd);
2573                 search_result_thumb_step(sd);
2574                 return;
2575                 }
2576
2577         if (sd->match_name_enable) history_combo_append_history(sd->entry_name, NULL);
2578         g_free(sd->search_name);
2579         sd->search_name = g_strdup(gtk_entry_get_text(GTK_ENTRY(sd->entry_name)));
2580
2581         /* XXX */
2582         g_free(sd->search_comment);
2583         sd->search_comment = g_strdup(gtk_entry_get_text(GTK_ENTRY(sd->entry_comment)));
2584
2585         g_free(sd->search_similarity_path);
2586         sd->search_similarity_path = g_strdup(gtk_entry_get_text(GTK_ENTRY(sd->entry_similarity)));
2587         if (sd->match_similarity_enable)
2588                 {
2589                 if (!isfile(sd->search_similarity_path))
2590                         {
2591                         file_util_warning_dialog(_("File not found"),
2592                                                  _("Please enter an existing file for image content."),
2593                                                  GTK_STOCK_DIALOG_WARNING, sd->window);
2594                         return;
2595                         }
2596                 tab_completion_append_to_history(sd->entry_similarity, sd->search_similarity_path);
2597                 }
2598
2599         /* Check the coordinate entry.
2600         * If the result is not sensible, it should get blocked.
2601         */
2602         if (sd->match_gps_enable)
2603                 {
2604                 if (sd->match_gps != SEARCH_MATCH_NONE)
2605                         {
2606                         entry_text = decode_geo_parameters(gtk_entry_get_text(
2607                                                                                 GTK_ENTRY(sd->entry_gps_coord)));
2608
2609                         sd->search_lat = 1000;
2610                         sd->search_lon = 1000;
2611                         sscanf(entry_text," %lf  %lf ", &sd->search_lat, &sd->search_lon );
2612                         if (!(entry_text != NULL && !g_strstr_len(entry_text, -1, "Error") &&
2613                                                 sd->search_lat >= -90 && sd->search_lat <= 90 &&
2614                                                 sd->search_lon >= -180 && sd->search_lon <= 180))
2615                                 {
2616                                 file_util_warning_dialog(_(
2617                                                 "Entry does not contain a valid lat/long value"),
2618                                                         entry_text, GTK_STOCK_DIALOG_WARNING, sd->window);
2619                                 return;
2620                                 }
2621                         g_free(entry_text);
2622                         }
2623                 }
2624
2625         string_list_free(sd->search_keyword_list);
2626         sd->search_keyword_list = keyword_list_pull(sd->entry_keywords);
2627
2628         date_selection_get(sd->date_sel, &sd->search_date_d, &sd->search_date_m, &sd->search_date_y);
2629         date_selection_get(sd->date_sel_end, &sd->search_date_end_d, &sd->search_date_end_m, &sd->search_date_end_y);
2630
2631         column = gtk_tree_view_get_column(GTK_TREE_VIEW(sd->result_view), SEARCH_COLUMN_DIMENSIONS - 1);
2632         gtk_tree_view_column_set_visible(column, sd->match_dimensions_enable);
2633
2634         column = gtk_tree_view_get_column(GTK_TREE_VIEW(sd->result_view), SEARCH_COLUMN_RANK - 1);
2635         gtk_tree_view_column_set_visible(column, sd->match_similarity_enable);
2636         if (!sd->match_similarity_enable)
2637                 {
2638                 GtkTreeSortable *sortable;
2639                 gint id;
2640                 GtkSortType order;
2641
2642                 sortable = GTK_TREE_SORTABLE(gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view)));
2643                 if (gtk_tree_sortable_get_sort_column_id(sortable, &id, &order) &&
2644                     id == SEARCH_COLUMN_RANK)
2645                         {
2646                         gtk_tree_sortable_set_sort_column_id(sortable, SEARCH_COLUMN_PATH, GTK_SORT_ASCENDING);
2647                         }
2648                 }
2649
2650         if (sd->search_type == SEARCH_MATCH_NONE)
2651                 {
2652                 /* search path */
2653
2654                 path = remove_trailing_slash(gtk_entry_get_text(GTK_ENTRY(sd->path_entry)));
2655                 if (isdir(path))
2656                         {
2657                         file_data_unref(sd->search_dir_fd);
2658                         sd->search_dir_fd = file_data_new_dir(path);
2659
2660                         tab_completion_append_to_history(sd->path_entry, sd->search_dir_fd->path);
2661
2662                         search_start(sd);
2663                         }
2664                 else
2665                         {
2666                         file_util_warning_dialog(_("Folder not found"),
2667                                                  _("Please enter an existing folder to search."),
2668                                                  GTK_STOCK_DIALOG_WARNING, sd->window);
2669                         }
2670
2671                 g_free(path);
2672                 }
2673         else if (sd->search_type == SEARCH_MATCH_ALL)
2674                 {
2675                 /* search metadata */
2676                 file_data_unref(sd->search_dir_fd);
2677                 sd->search_dir_fd = file_data_new_dir(get_metadata_cache_dir());
2678                 search_start(sd);
2679                 }
2680         else if (sd->search_type == SEARCH_MATCH_CONTAINS)
2681                 {
2682                 /* search current result list */
2683                 GList *list;
2684
2685                 list = search_result_refine_list(sd);
2686
2687                 file_data_unref(sd->search_dir_fd);
2688                 sd->search_dir_fd = NULL;
2689
2690                 search_start(sd);
2691
2692                 sd->search_file_list = g_list_concat(sd->search_file_list, list);
2693                 }
2694 }
2695
2696 /*
2697  *-------------------------------------------------------------------
2698  * window construct
2699  *-------------------------------------------------------------------
2700  */
2701
2702 enum {
2703         MENU_CHOICE_COLUMN_NAME = 0,
2704         MENU_CHOICE_COLUMN_VALUE
2705 };
2706
2707 static void search_thumb_toggle_cb(GtkWidget *button, gpointer data)
2708 {
2709         SearchData *sd = data;
2710
2711         search_result_thumb_enable(sd, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)));
2712 }
2713
2714 static gint sort_matchdata_dimensions(MatchFileData *a, MatchFileData *b)
2715 {
2716         gint sa;
2717         gint sb;
2718
2719         sa = a->width * a->height;
2720         sb = b->width * b->height;
2721
2722         if (sa > sb) return 1;
2723         if (sa < sb) return -1;
2724         return 0;
2725 }
2726
2727 static gint search_result_sort_cb(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer data)
2728 {
2729         gint n = GPOINTER_TO_INT(data);
2730         MatchFileData *fda;
2731         MatchFileData *fdb;
2732
2733         gtk_tree_model_get(model, a, SEARCH_COLUMN_POINTER, &fda, -1);
2734         gtk_tree_model_get(model, b, SEARCH_COLUMN_POINTER, &fdb, -1);
2735
2736         if (!fda || !fdb) return 0;
2737
2738         switch (n)
2739                 {
2740                 case SEARCH_COLUMN_RANK:
2741                         if (((MatchFileData *)fda)->rank > (fdb)->rank) return 1;
2742                         if (((MatchFileData *)fda)->rank < (fdb)->rank) return -1;
2743                         return 0;
2744                         break;
2745                 case SEARCH_COLUMN_NAME:
2746                         if (options->file_sort.case_sensitive)
2747                                 return strcmp(fda->fd->collate_key_name, fdb->fd->collate_key_name);
2748                         else
2749                                 return strcmp(fda->fd->collate_key_name_nocase, fdb->fd->collate_key_name_nocase);
2750                         break;
2751                 case SEARCH_COLUMN_SIZE:
2752                         if (fda->fd->size > fdb->fd->size) return 1;
2753                         if (fda->fd->size < fdb->fd->size) return -1;
2754                         return 0;
2755                         break;
2756                 case SEARCH_COLUMN_DATE:
2757                         if (fda->fd->date > fdb->fd->date) return 1;
2758                         if (fda->fd->date < fdb->fd->date) return -1;
2759                         return 0;
2760                         break;
2761                 case SEARCH_COLUMN_DIMENSIONS:
2762                         return sort_matchdata_dimensions(fda, fdb);
2763                         break;
2764                 case SEARCH_COLUMN_PATH:
2765                         return utf8_compare(fda->fd->path, fdb->fd->path, options->file_sort.case_sensitive);
2766                         break;
2767                 default:
2768                         break;
2769                 }
2770
2771         return 0;
2772 }
2773
2774 static void search_result_add_column(SearchData * sd, gint n, const gchar *title, gboolean image, gboolean right_justify)
2775 {
2776         GtkTreeViewColumn *column;
2777         GtkCellRenderer *renderer;
2778
2779         column = gtk_tree_view_column_new();
2780         gtk_tree_view_column_set_title(column, title);
2781         gtk_tree_view_column_set_min_width(column, 4);
2782
2783         if (n != SEARCH_COLUMN_THUMB) gtk_tree_view_column_set_resizable(column, TRUE);
2784
2785         if (!image)
2786                 {
2787                 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
2788                 renderer = gtk_cell_renderer_text_new();
2789                 if (right_justify) g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
2790                 gtk_tree_view_column_pack_start(column, renderer, TRUE);
2791                 gtk_tree_view_column_add_attribute(column, renderer, "text", n);
2792
2793                 gtk_tree_view_column_set_sort_column_id(column, n);
2794                 }
2795         else
2796                 {
2797                 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
2798                 renderer = gtk_cell_renderer_pixbuf_new();
2799                 cell_renderer_height_override(renderer);
2800                 gtk_tree_view_column_pack_start(column, renderer, TRUE);
2801                 gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", n);
2802                 }
2803
2804         gtk_tree_view_append_column(GTK_TREE_VIEW(sd->result_view), column);
2805 }
2806
2807 static void menu_choice_set_visible(GtkWidget *widget, gboolean visible)
2808 {
2809         if (visible)
2810                 {
2811                 if (!gtk_widget_get_visible(widget)) gtk_widget_show(widget);
2812                 }
2813         else
2814                 {
2815                 if (gtk_widget_get_visible(widget)) gtk_widget_hide(widget);
2816                 }
2817 }
2818
2819 static gboolean menu_choice_get_match_type(GtkWidget *combo, MatchType *type)
2820 {
2821         GtkTreeModel *store;
2822         GtkTreeIter iter;
2823
2824         store = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
2825         if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter)) return FALSE;
2826         gtk_tree_model_get(store, &iter, MENU_CHOICE_COLUMN_VALUE, type, -1);
2827         return TRUE;
2828 }
2829
2830 static void menu_choice_path_cb(GtkWidget *combo, gpointer data)
2831 {
2832         SearchData *sd = data;
2833
2834         if (!menu_choice_get_match_type(combo, &sd->search_type)) return;
2835
2836         menu_choice_set_visible(gtk_widget_get_parent(sd->check_recurse),
2837                                 (sd->search_type == SEARCH_MATCH_NONE));
2838 }
2839
2840 static void menu_choice_name_cb(GtkWidget *combo, gpointer data)
2841 {
2842         SearchData *sd = data;
2843
2844         if (!menu_choice_get_match_type(combo, &sd->match_name)) return;
2845 }
2846
2847 static void menu_choice_size_cb(GtkWidget *combo, gpointer data)
2848 {
2849         SearchData *sd = data;
2850
2851         if (!menu_choice_get_match_type(combo, &sd->match_size)) return;
2852
2853         menu_choice_set_visible(gtk_widget_get_parent(sd->spin_size_end),
2854                                 (sd->match_size == SEARCH_MATCH_BETWEEN));
2855 }
2856
2857 static void menu_choice_rating_cb(GtkWidget *combo, gpointer data)
2858 {
2859         SearchData *sd = data;
2860
2861         if (!menu_choice_get_match_type(combo, &sd->match_rating)) return;
2862
2863         menu_choice_set_visible(gtk_widget_get_parent(sd->spin_rating_end),
2864                                 (sd->match_rating == SEARCH_MATCH_BETWEEN));
2865 }
2866
2867 static void menu_choice_class_cb(GtkWidget *combo, gpointer data)
2868 {
2869         SearchData *sd = data;
2870
2871         if (!menu_choice_get_match_type(combo, &sd->match_class)) return;
2872 }
2873
2874 static void menu_choice_marks_cb(GtkWidget *combo, gpointer data)
2875 {
2876         SearchData *sd = data;
2877
2878         if (!menu_choice_get_match_type(combo, &sd->match_marks)) return;
2879 }
2880
2881 static void menu_choice_date_cb(GtkWidget *combo, gpointer data)
2882 {
2883         SearchData *sd = data;
2884
2885         if (!menu_choice_get_match_type(combo, &sd->match_date)) return;
2886
2887         menu_choice_set_visible(gtk_widget_get_parent(sd->date_sel_end),
2888                                 (sd->match_date == SEARCH_MATCH_BETWEEN));
2889 }
2890
2891 static void menu_choice_dimensions_cb(GtkWidget *combo, gpointer data)
2892 {
2893         SearchData *sd = data;
2894
2895         if (!menu_choice_get_match_type(combo, &sd->match_dimensions)) return;
2896
2897         menu_choice_set_visible(gtk_widget_get_parent(sd->spin_width_end),
2898                                 (sd->match_dimensions == SEARCH_MATCH_BETWEEN));
2899 }
2900
2901 static void menu_choice_keyword_cb(GtkWidget *combo, gpointer data)
2902 {
2903         SearchData *sd = data;
2904
2905         if (!menu_choice_get_match_type(combo, &sd->match_keywords)) return;
2906 }
2907
2908 static void menu_choice_comment_cb(GtkWidget *combo, gpointer data)
2909 {
2910         SearchData *sd = data;
2911
2912         if (!menu_choice_get_match_type(combo, &sd->match_comment)) return;
2913 }
2914
2915 static void menu_choice_spin_cb(GtkAdjustment *adjustment, gpointer data)
2916 {
2917         gint *value = data;
2918
2919         *value = (gint)gtk_adjustment_get_value(adjustment);
2920 }
2921
2922 static void menu_choice_gps_cb(GtkWidget *combo, gpointer data)
2923 {
2924         SearchData *sd = data;
2925
2926         if (!menu_choice_get_match_type(combo, &sd->match_gps)) return;
2927
2928         menu_choice_set_visible(gtk_widget_get_parent(sd->spin_gps),
2929                                         (sd->match_gps != SEARCH_MATCH_NONE));
2930 }
2931
2932 static GtkWidget *menu_spin(GtkWidget *box, gdouble min, gdouble max, gint value,
2933                             GCallback func, gpointer data)
2934 {
2935         GtkWidget *spin;
2936         GtkAdjustment *adj;
2937
2938         spin = gtk_spin_button_new_with_range(min, max, 1);
2939         gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), (gdouble)value);
2940         adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(spin));
2941         if (func) g_signal_connect(G_OBJECT(adj), "value_changed",
2942                                    G_CALLBACK(func), data);
2943         gtk_box_pack_start(GTK_BOX(box), spin, FALSE, FALSE, 0);
2944         gtk_widget_show(spin);
2945
2946         return spin;
2947 }
2948
2949 static void menu_choice_check_cb(GtkWidget *button, gpointer data)
2950 {
2951         GtkWidget *widget = data;
2952         gboolean active;
2953         gboolean *value;
2954
2955         active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
2956         gtk_widget_set_sensitive(widget, active);
2957
2958         value = g_object_get_data(G_OBJECT(button), "check_var");
2959         if (value) *value = active;
2960 }
2961
2962 static GtkWidget *menu_choice_menu(const MatchList *items, gint item_count,
2963                                    GCallback func, gpointer data)
2964 {
2965         GtkWidget *combo;
2966         GtkCellRenderer *renderer;
2967         GtkListStore *store;
2968         gint i;
2969
2970         store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
2971         combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
2972         g_object_unref(store);
2973
2974         renderer = gtk_cell_renderer_text_new();
2975         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE);
2976         gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer,
2977                                        "text", MENU_CHOICE_COLUMN_NAME, NULL);
2978
2979         for (i = 0; i < item_count; i++)
2980                 {
2981                 GtkTreeIter iter;
2982
2983                 gtk_list_store_append(store, &iter);
2984                 gtk_list_store_set(store, &iter, MENU_CHOICE_COLUMN_NAME, _(items[i].text),
2985                                                  MENU_CHOICE_COLUMN_VALUE, items[i].type, -1);
2986                 }
2987
2988         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
2989
2990         if (func) g_signal_connect(G_OBJECT(combo), "changed",
2991                                    G_CALLBACK(func), data);
2992
2993         return combo;
2994 }
2995
2996 static GtkWidget *menu_choice(GtkWidget *box, GtkWidget **check, GtkWidget **menu,
2997                               const gchar *text, gboolean *value,
2998                               const MatchList *items, gint item_count,
2999                               GCallback func, gpointer data)
3000 {
3001         GtkWidget *base_box;
3002         GtkWidget *hbox;
3003         GtkWidget *button;
3004         GtkWidget *option;
3005
3006         base_box = gtk_hbox_new(FALSE, PREF_PAD_GAP);
3007         gtk_box_pack_start(GTK_BOX(box), base_box, FALSE, FALSE, 0);
3008         gtk_widget_show(base_box);
3009
3010         button = gtk_check_button_new();
3011         if (value) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), *value);
3012         gtk_box_pack_start(GTK_BOX(base_box), button, FALSE, FALSE, 0);
3013         gtk_widget_show(button);
3014         if (check) *check = button;
3015         if (value) g_object_set_data(G_OBJECT(button), "check_var", value);
3016
3017         hbox = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
3018         gtk_box_pack_start(GTK_BOX(base_box), hbox, TRUE, TRUE, 0);
3019         gtk_widget_show(hbox);
3020
3021         g_signal_connect(G_OBJECT(button), "toggled",
3022                          G_CALLBACK(menu_choice_check_cb), hbox);
3023         gtk_widget_set_sensitive(hbox, (value) ? *value : FALSE);
3024
3025         pref_label_new(hbox, text);
3026
3027         if (!items && !menu) return hbox;
3028
3029         option = menu_choice_menu(items, item_count, func, data);
3030         gtk_box_pack_start(GTK_BOX(hbox), option, FALSE, FALSE, 0);
3031         gtk_widget_show(option);
3032         if (menu) *menu = option;
3033
3034         return hbox;
3035 }
3036
3037 static void search_window_close(SearchData *sd)
3038 {
3039         gtk_widget_destroy(sd->window);
3040 }
3041
3042 static gboolean search_window_delete_cb(GtkWidget *widget, GdkEventAny *event, gpointer data)
3043 {
3044         SearchData *sd = data;
3045
3046         search_window_close(sd);
3047         return TRUE;
3048 }
3049
3050 static void search_window_destroy_cb(GtkWidget *widget, gpointer data)
3051 {
3052         SearchData *sd = data;
3053
3054         search_window_list = g_list_remove(search_window_list, sd);
3055
3056         search_result_update_idle_cancel(sd);
3057
3058         filelist_free(sd->search_buffer_list);
3059         sd->search_buffer_list = NULL;
3060
3061         search_stop(sd);
3062         search_result_clear(sd);
3063
3064         file_data_unref(sd->search_dir_fd);
3065
3066         g_free(sd->search_name);
3067         g_regex_unref(sd->search_name_regex);
3068         g_free(sd->search_comment);
3069         g_regex_unref(sd->search_comment_regex);
3070         g_free(sd->search_similarity_path);
3071         string_list_free(sd->search_keyword_list);
3072
3073         file_data_unregister_notify_func(search_notify_cb, sd);
3074
3075         g_free(sd);
3076 }
3077
3078 void search_new(FileData *dir_fd, FileData *example_file)
3079 {
3080         SearchData *sd;
3081         GtkWidget *vbox;
3082         GtkWidget *hbox;
3083         GtkWidget *hbox2;
3084         GtkWidget *pad_box;
3085         GtkWidget *frame;
3086         GtkWidget *scrolled;
3087         GtkListStore *store;
3088         GtkTreeSortable *sortable;
3089         GtkTreeSelection *selection;
3090         GtkWidget *combo;
3091         GdkGeometry geometry;
3092         gint i;
3093         gchar *marks_string;
3094
3095         sd = g_new0(SearchData, 1);
3096
3097         sd->search_dir_fd = file_data_ref(dir_fd);
3098         sd->search_path_recurse = TRUE;
3099         sd->search_size = 0;
3100         sd->search_width = 640;
3101         sd->search_height = 480;
3102         sd->search_width_end = 1024;
3103         sd->search_height_end = 768;
3104
3105         sd->search_type = SEARCH_MATCH_NONE;
3106
3107         sd->match_name = SEARCH_MATCH_CONTAINS;
3108         sd->match_size = SEARCH_MATCH_EQUAL;
3109         sd->match_date = SEARCH_MATCH_EQUAL;
3110         sd->match_dimensions = SEARCH_MATCH_EQUAL;
3111         sd->match_keywords = SEARCH_MATCH_ALL;
3112         sd->match_comment = SEARCH_MATCH_CONTAINS;
3113         sd->match_rating = SEARCH_MATCH_EQUAL;
3114         sd->match_class = SEARCH_MATCH_EQUAL;
3115         sd->match_marks = SEARCH_MATCH_EQUAL;
3116
3117         sd->match_name_enable = TRUE;
3118
3119         sd->search_similarity = 95;
3120
3121         sd->search_gps = 1;
3122         sd->match_gps = SEARCH_MATCH_NONE;
3123
3124         if (example_file)
3125                 {
3126                 sd->search_similarity_path = g_strdup(example_file->path);
3127                 }
3128
3129         sd->window = window_new(GTK_WINDOW_TOPLEVEL, "search", NULL, NULL, _("Image search"));
3130
3131         gtk_window_set_resizable(GTK_WINDOW(sd->window), TRUE);
3132
3133         geometry.min_width = DEFAULT_MINIMAL_WINDOW_SIZE;
3134         geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
3135         geometry.base_width = DEF_SEARCH_WIDTH;
3136         geometry.base_height = DEF_SEARCH_HEIGHT;
3137         gtk_window_set_geometry_hints(GTK_WINDOW(sd->window), NULL, &geometry,
3138                                       GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE);
3139
3140         gtk_window_set_default_size(GTK_WINDOW(sd->window), DEF_SEARCH_WIDTH, DEF_SEARCH_HEIGHT);
3141
3142         g_signal_connect(G_OBJECT(sd->window), "delete_event",
3143                          G_CALLBACK(search_window_delete_cb), sd);
3144         g_signal_connect(G_OBJECT(sd->window), "destroy",
3145                          G_CALLBACK(search_window_destroy_cb), sd);
3146
3147         g_signal_connect(G_OBJECT(sd->window), "key_press_event",
3148                          G_CALLBACK(search_window_keypress_cb), sd);
3149
3150         vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
3151         gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_GAP);
3152         gtk_container_add(GTK_CONTAINER(sd->window), vbox);
3153         gtk_widget_show(vbox);
3154
3155         sd->box_search = pref_box_new(vbox, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
3156
3157         hbox = pref_box_new(sd->box_search, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
3158
3159         pref_label_new(hbox, _("Search:"));
3160
3161         sd->menu_path = menu_choice_menu(text_search_menu_path, sizeof(text_search_menu_path) / sizeof(MatchList),
3162                                          G_CALLBACK(menu_choice_path_cb), sd);
3163         gtk_box_pack_start(GTK_BOX(hbox), sd->menu_path, FALSE, FALSE, 0);
3164         gtk_widget_show(sd->menu_path);
3165
3166         hbox2 = pref_box_new(hbox, TRUE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
3167         combo = tab_completion_new_with_history(&sd->path_entry, sd->search_dir_fd->path,
3168                                                 "search_path", -1,
3169                                                 NULL, NULL);
3170         tab_completion_add_select_button(sd->path_entry, NULL, TRUE);
3171         gtk_box_pack_start(GTK_BOX(hbox2), combo, TRUE, TRUE, 0);
3172         gtk_widget_show(combo);
3173         sd->check_recurse = pref_checkbox_new_int(hbox2, _("Recurse"),
3174                                                   sd->search_path_recurse, &sd->search_path_recurse);
3175
3176         /* Search for file name */
3177         hbox = menu_choice(sd->box_search, &sd->check_name, &sd->menu_name,
3178                            _("File name"), &sd->match_name_enable,
3179                            text_search_menu_name, sizeof(text_search_menu_name) / sizeof(MatchList),
3180                            G_CALLBACK(menu_choice_name_cb), sd);
3181         combo = history_combo_new(&sd->entry_name, "", "search_name", -1);
3182         gtk_box_pack_start(GTK_BOX(hbox), combo, TRUE, TRUE, 0);
3183         gtk_widget_show(combo);
3184         pref_checkbox_new_int(hbox, _("Match case"),
3185                               sd->search_name_match_case, &sd->search_name_match_case);
3186         gtk_widget_set_tooltip_text(GTK_WIDGET(combo), "When set to \"contains\", this field uses Perl Compatible Regular Expressions.\ne.g. use \n.*\\.jpg\n and not \n*.jpg\n\nSee the Help file.");
3187
3188         /* Search for file size */
3189         hbox = menu_choice(sd->box_search, &sd->check_size, &sd->menu_size,
3190                            _("File size is"), &sd->match_size_enable,
3191                            text_search_menu_size, sizeof(text_search_menu_size) / sizeof(MatchList),
3192                            G_CALLBACK(menu_choice_size_cb), sd);
3193         sd->spin_size = menu_spin(hbox, 0, 1024*1024*1024, sd->search_size,
3194                                   G_CALLBACK(menu_choice_spin_cb), &sd->search_size);
3195         hbox2 = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
3196         gtk_box_pack_start(GTK_BOX(hbox), hbox2, FALSE, FALSE, 0);
3197         pref_label_new(hbox2, _("and"));
3198         sd->spin_size_end = menu_spin(hbox2, 0, 1024*1024*1024, sd->search_size_end,
3199                                       G_CALLBACK(menu_choice_spin_cb), &sd->search_size_end);
3200
3201         /* Search for file date */
3202         hbox = menu_choice(sd->box_search, &sd->check_date, &sd->menu_date,
3203                            _("File date is"), &sd->match_date_enable,
3204                            text_search_menu_date, sizeof(text_search_menu_date) / sizeof(MatchList),
3205                            G_CALLBACK(menu_choice_date_cb), sd);
3206
3207         sd->date_sel = date_selection_new();
3208         date_selection_time_set(sd->date_sel, time(NULL));
3209         gtk_box_pack_start(GTK_BOX(hbox), sd->date_sel, FALSE, FALSE, 0);
3210         gtk_widget_show(sd->date_sel);
3211
3212         hbox2 = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
3213         gtk_box_pack_start(GTK_BOX(hbox), hbox2, FALSE, FALSE, 0);
3214         pref_label_new(hbox2, _("and"));
3215         sd->date_sel_end = date_selection_new();
3216         date_selection_time_set(sd->date_sel_end, time(NULL));
3217         gtk_box_pack_start(GTK_BOX(hbox2), sd->date_sel_end, FALSE, FALSE, 0);
3218         gtk_widget_show(sd->date_sel_end);
3219
3220         sd->date_type = gtk_combo_box_text_new();
3221         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->date_type), _("Modified"));
3222         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->date_type), _("Status Changed"));
3223         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->date_type), _("Original"));
3224         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->date_type), _("Digitized"));
3225         gtk_box_pack_start(GTK_BOX(hbox), sd->date_type, FALSE, FALSE, 0);
3226         gtk_combo_box_set_active(GTK_COMBO_BOX(sd->date_type), 0);
3227         gtk_widget_set_tooltip_text(sd->date_type, "Modified (mtime)\nStatus Changed (ctime)\nOriginal (Exif.Photo.DateTimeOriginal)\nDigitized (Exif.Photo.DateTimeDigitized)");
3228         gtk_widget_show(sd->date_type);
3229
3230         /* Search for image dimensions */
3231         hbox = menu_choice(sd->box_search, &sd->check_dimensions, &sd->menu_dimensions,
3232                            _("Image dimensions are"), &sd->match_dimensions_enable,
3233                            text_search_menu_size, sizeof(text_search_menu_size) / sizeof(MatchList),
3234                            G_CALLBACK(menu_choice_dimensions_cb), sd);
3235         pad_box = pref_box_new(hbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 2);
3236         sd->spin_width = menu_spin(pad_box, 0, 1000000, sd->search_width,
3237                                    G_CALLBACK(menu_choice_spin_cb), &sd->search_width);
3238         pref_label_new(pad_box, "x");
3239         sd->spin_height = menu_spin(pad_box, 0, 1000000, sd->search_height,
3240                                     G_CALLBACK(menu_choice_spin_cb), &sd->search_height);
3241         hbox2 = gtk_hbox_new(FALSE, 2);
3242         gtk_box_pack_start(GTK_BOX(hbox), hbox2, FALSE, FALSE, 0);
3243         pref_label_new(hbox2, _("and"));
3244         pref_spacer(hbox2, PREF_PAD_SPACE - 2*2);
3245         sd->spin_width_end = menu_spin(hbox2, 0, 1000000, sd->search_width_end,
3246                                        G_CALLBACK(menu_choice_spin_cb), &sd->search_width_end);
3247         pref_label_new(hbox2, "x");
3248         sd->spin_height_end = menu_spin(hbox2, 0, 1000000, sd->search_height_end,
3249                                         G_CALLBACK(menu_choice_spin_cb), &sd->search_height_end);
3250
3251         /* Search for image similarity */
3252         hbox = menu_choice(sd->box_search, &sd->check_similarity, NULL,
3253                            _("Image content is"), &sd->match_similarity_enable,
3254                            NULL, 0, NULL, sd);
3255         sd->spin_similarity = menu_spin(hbox, 80, 100, sd->search_similarity,
3256                                         G_CALLBACK(menu_choice_spin_cb), &sd->search_similarity);
3257
3258         /* xgettext:no-c-format */
3259         pref_label_new(hbox, _("% similar to"));
3260
3261         combo = tab_completion_new_with_history(&sd->entry_similarity,
3262                                                 (sd->search_similarity_path) ? sd->search_similarity_path : "",
3263                                                 "search_similarity_path", -1, NULL, NULL);
3264         tab_completion_add_select_button(sd->entry_similarity, NULL, FALSE);
3265         gtk_box_pack_start(GTK_BOX(hbox), combo, TRUE, TRUE, 0);
3266         gtk_widget_show(combo);
3267         pref_checkbox_new_int(hbox, _("Ignore rotation"),
3268                                 options->rot_invariant_sim, &options->rot_invariant_sim);
3269
3270         /* Search for image keywords */
3271         hbox = menu_choice(sd->box_search, &sd->check_keywords, &sd->menu_keywords,
3272                            _("Keywords"), &sd->match_keywords_enable,
3273                            text_search_menu_keyword, sizeof(text_search_menu_keyword) / sizeof(MatchList),
3274                            G_CALLBACK(menu_choice_keyword_cb), sd);
3275         sd->entry_keywords = gtk_entry_new();
3276         gtk_box_pack_start(GTK_BOX(hbox), sd->entry_keywords, TRUE, TRUE, 0);
3277         gtk_widget_set_sensitive(sd->entry_keywords, sd->match_keywords_enable);
3278         g_signal_connect(G_OBJECT(sd->check_keywords), "toggled",
3279                          G_CALLBACK(menu_choice_check_cb), sd->entry_keywords);
3280         gtk_widget_show(sd->entry_keywords);
3281
3282         /* Search for image comment */
3283         hbox = menu_choice(sd->box_search, &sd->check_comment, &sd->menu_comment,
3284                         _("Comment"), &sd->match_comment_enable,
3285                         text_search_menu_comment, sizeof(text_search_menu_comment) / sizeof(MatchList),
3286                         G_CALLBACK(menu_choice_comment_cb), sd);
3287         sd->entry_comment = gtk_entry_new();
3288         gtk_box_pack_start(GTK_BOX(hbox), sd->entry_comment, TRUE, TRUE, 0);
3289         gtk_widget_set_sensitive(sd->entry_comment, sd->match_comment_enable);
3290         g_signal_connect(G_OBJECT(sd->check_comment), "toggled",
3291                         G_CALLBACK(menu_choice_check_cb), sd->entry_comment);
3292         gtk_widget_show(sd->entry_comment);
3293         pref_checkbox_new_int(hbox, _("Match case"),
3294                               sd->search_comment_match_case, &sd->search_comment_match_case);
3295         gtk_widget_set_tooltip_text(GTK_WIDGET(sd->entry_comment), "This field uses Perl Compatible Regular Expressions.\ne.g. use \nabc.*ghk\n and not \nabc*ghk\n\nSee the Help file.");
3296
3297         /* Search for image rating */
3298         hbox = menu_choice(sd->box_search, &sd->check_rating, &sd->menu_rating,
3299                            _("Image rating is"), &sd->match_rating_enable,
3300                            text_search_menu_rating, sizeof(text_search_menu_rating) / sizeof(MatchList),
3301                            G_CALLBACK(menu_choice_rating_cb), sd);
3302         sd->spin_size = menu_spin(hbox, -1, 5, sd->search_rating,
3303                                   G_CALLBACK(menu_choice_spin_cb), &sd->search_rating);
3304         hbox2 = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
3305         gtk_box_pack_start(GTK_BOX(hbox), hbox2, FALSE, FALSE, 0);
3306         pref_label_new(hbox2, _("and"));
3307         sd->spin_rating_end = menu_spin(hbox2, -1, 5, sd->search_rating_end,
3308                                       G_CALLBACK(menu_choice_spin_cb), &sd->search_rating_end);
3309
3310         /* Search for images within a specified range of a lat/long coordinate
3311         */
3312         hbox = menu_choice(sd->box_search, &sd->check_gps, &sd->menu_gps,
3313                            _("Image is"), &sd->match_gps_enable,
3314                            text_search_menu_gps, sizeof(text_search_menu_gps) / sizeof(MatchList),
3315                            G_CALLBACK(menu_choice_gps_cb), sd);
3316
3317         hbox2 = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
3318         gtk_box_pack_start(GTK_BOX(hbox), hbox2, FALSE, FALSE, 0);
3319         sd->spin_gps = menu_spin(hbox2, 1, 9999, sd->search_gps,
3320                                                                    G_CALLBACK(menu_choice_spin_cb), &sd->search_gps);
3321
3322         sd->units_gps = gtk_combo_box_text_new();
3323         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->units_gps), _("km"));
3324         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->units_gps), _("miles"));
3325         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->units_gps), _("n.m."));
3326         gtk_box_pack_start(GTK_BOX(hbox2), sd->units_gps, FALSE, FALSE, 0);
3327         gtk_combo_box_set_active(GTK_COMBO_BOX(sd->units_gps), 0);
3328         gtk_widget_set_tooltip_text(sd->units_gps, "kilometres, miles or nautical miles");
3329         gtk_widget_show(sd->units_gps);
3330
3331         pref_label_new(hbox2, _("from"));
3332
3333         sd->entry_gps_coord = gtk_entry_new();
3334         gtk_editable_set_editable(GTK_EDITABLE(sd->entry_gps_coord), TRUE);
3335         gtk_widget_set_has_tooltip(sd->entry_gps_coord, TRUE);
3336         gtk_widget_set_tooltip_text(sd->entry_gps_coord, _("Enter a coordinate in the form:\n89.123 179.456\nor drag-and-drop a geo-coded image\nor left-click on the map and paste\nor cut-and-paste or drag-and-drop\nan internet search URL\nSee the Help file"));
3337         gtk_box_pack_start(GTK_BOX(hbox2), sd->entry_gps_coord, TRUE, TRUE, 0);
3338         gtk_widget_set_sensitive(sd->entry_gps_coord, TRUE);
3339
3340         gtk_widget_show(sd->entry_gps_coord);
3341
3342         /* Search for image class */
3343         hbox = menu_choice(sd->box_search, &sd->check_class, &sd->menu_class,
3344                            _("Image class"), &sd->match_class_enable,
3345                            text_search_menu_class, sizeof(text_search_menu_class) / sizeof(MatchList),
3346                            G_CALLBACK(menu_choice_class_cb), sd);
3347
3348         sd->class_type = gtk_combo_box_text_new();
3349         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->class_type), _("Image"));
3350         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->class_type), _("Raw Image"));
3351         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->class_type), _("Video"));
3352         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->class_type), _("Metadata"));
3353         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->class_type), _("Unknown"));
3354         gtk_box_pack_start(GTK_BOX(hbox), sd->class_type, FALSE, FALSE, 0);
3355         gtk_combo_box_set_active(GTK_COMBO_BOX(sd->class_type), 0);
3356         gtk_widget_show(sd->class_type);
3357
3358         /* Search for image marks */
3359         hbox = menu_choice(sd->box_search, &sd->check_class, &sd->menu_marks,
3360                            _("Marks"), &sd->match_marks_enable,
3361                            text_search_menu_marks, sizeof(text_search_menu_marks) / sizeof(MatchList),
3362                            G_CALLBACK(menu_choice_marks_cb), sd);
3363
3364         sd->marks_type = gtk_combo_box_text_new();
3365         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->marks_type), _("Any mark"));
3366         for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
3367                 {
3368                 marks_string = g_strdup_printf("%s%d", _("Mark "), i + 1);
3369                 if (g_strcmp0(marks_string, options->marks_tooltips[i]) != 0)
3370                         {
3371                         g_free(marks_string);
3372                         marks_string = g_strdup_printf("%s%d %s", _("Mark "), i + 1,
3373                                                                                         options->marks_tooltips[i]);
3374                         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->marks_type), marks_string);
3375                         }
3376                 else
3377                         {
3378                         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sd->marks_type), marks_string);
3379                         }
3380                 g_free(marks_string);
3381                 }
3382         gtk_box_pack_start(GTK_BOX(hbox), sd->marks_type, FALSE, FALSE, 0);
3383         gtk_combo_box_set_active(GTK_COMBO_BOX(sd->marks_type), 0);
3384         gtk_widget_show(sd->marks_type);
3385
3386         /* Done the types of searches */
3387
3388         scrolled = gtk_scrolled_window_new(NULL, NULL);
3389         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
3390         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
3391                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3392         gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0);
3393         gtk_widget_show(scrolled);
3394
3395         store = gtk_list_store_new(8, G_TYPE_POINTER, G_TYPE_INT, GDK_TYPE_PIXBUF,
3396                                    G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
3397                                    G_TYPE_STRING, G_TYPE_STRING);
3398
3399         /* set up sorting */
3400         sortable = GTK_TREE_SORTABLE(store);
3401         gtk_tree_sortable_set_sort_func(sortable, SEARCH_COLUMN_RANK, search_result_sort_cb,
3402                                   GINT_TO_POINTER(SEARCH_COLUMN_RANK), NULL);
3403         gtk_tree_sortable_set_sort_func(sortable, SEARCH_COLUMN_NAME, search_result_sort_cb,
3404                                   GINT_TO_POINTER(SEARCH_COLUMN_NAME), NULL);
3405         gtk_tree_sortable_set_sort_func(sortable, SEARCH_COLUMN_SIZE, search_result_sort_cb,
3406                                   GINT_TO_POINTER(SEARCH_COLUMN_SIZE), NULL);
3407         gtk_tree_sortable_set_sort_func(sortable, SEARCH_COLUMN_DATE, search_result_sort_cb,
3408                                   GINT_TO_POINTER(SEARCH_COLUMN_DATE), NULL);
3409         gtk_tree_sortable_set_sort_func(sortable, SEARCH_COLUMN_DIMENSIONS, search_result_sort_cb,
3410                                   GINT_TO_POINTER(SEARCH_COLUMN_DIMENSIONS), NULL);
3411         gtk_tree_sortable_set_sort_func(sortable, SEARCH_COLUMN_PATH, search_result_sort_cb,
3412                                   GINT_TO_POINTER(SEARCH_COLUMN_PATH), NULL);
3413
3414 #if 0
3415         /* by default, search results are unsorted until user selects a sort column - for speed,
3416          * using sort slows search speed by an order of magnitude with 1000's of results :-/
3417          */
3418         gtk_tree_sortable_set_sort_column_id(sortable, SEARCH_COLUMN_PATH, GTK_SORT_ASCENDING);
3419 #endif
3420
3421         sd->result_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
3422         g_object_unref(store);
3423         gtk_container_add(GTK_CONTAINER(scrolled), sd->result_view);
3424         gtk_widget_show(sd->result_view);
3425
3426         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->result_view));
3427         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_MULTIPLE);
3428         gtk_tree_selection_set_select_function(selection, search_result_select_cb, sd, NULL);
3429
3430         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(sd->result_view), TRUE);
3431         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(sd->result_view), FALSE);
3432
3433         search_result_add_column(sd, SEARCH_COLUMN_RANK, _("Rank"), FALSE, FALSE);
3434         search_result_add_column(sd, SEARCH_COLUMN_THUMB, "", TRUE, FALSE);
3435         search_result_add_column(sd, SEARCH_COLUMN_NAME, _("Name"), FALSE, FALSE);
3436         search_result_add_column(sd, SEARCH_COLUMN_SIZE, _("Size"), FALSE, TRUE);
3437         search_result_add_column(sd, SEARCH_COLUMN_DATE, _("Date"), FALSE, TRUE);
3438         search_result_add_column(sd, SEARCH_COLUMN_DIMENSIONS, _("Dimensions"), FALSE, FALSE);
3439         search_result_add_column(sd, SEARCH_COLUMN_PATH, _("Path"), FALSE, FALSE);
3440
3441         search_dnd_init(sd);
3442
3443         g_signal_connect(G_OBJECT(sd->result_view), "button_press_event",
3444                          G_CALLBACK(search_result_press_cb), sd);
3445         g_signal_connect(G_OBJECT(sd->result_view), "button_release_event",
3446                          G_CALLBACK(search_result_release_cb), sd);
3447         g_signal_connect(G_OBJECT(sd->result_view), "key_press_event",
3448                          G_CALLBACK(search_result_keypress_cb), sd);
3449
3450         hbox = pref_box_new(vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
3451
3452         sd->button_thumbs = pref_checkbox_new(hbox, _("Thumbnails"), FALSE,
3453                                               G_CALLBACK(search_thumb_toggle_cb), sd);
3454
3455         frame = gtk_frame_new(NULL);
3456         gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
3457         gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, PREF_PAD_SPACE);
3458         gtk_widget_show(frame);
3459
3460         sd->label_status = gtk_label_new("");
3461         gtk_widget_set_size_request(sd->label_status, 50, -1);
3462         gtk_container_add(GTK_CONTAINER(frame), sd->label_status);
3463         gtk_widget_show(sd->label_status);
3464
3465         sd->label_progress = gtk_progress_bar_new();
3466         gtk_widget_set_size_request(sd->label_progress, 50, -1);
3467 #if GTK_CHECK_VERSION(3,0,0)
3468         gtk_progress_bar_set_text(GTK_PROGRESS_BAR(sd->label_progress), "");
3469         gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(sd->label_progress), TRUE);
3470 #endif
3471         gtk_box_pack_start(GTK_BOX(hbox), sd->label_progress, TRUE, TRUE, 0);
3472         gtk_widget_show(sd->label_progress);
3473
3474         sd->spinner = spinner_new(NULL, -1);
3475         gtk_box_pack_start(GTK_BOX(hbox), sd->spinner, FALSE, FALSE, 0);
3476         gtk_widget_show(sd->spinner);
3477
3478         sd->button_start = pref_button_new(hbox, GTK_STOCK_FIND, NULL, FALSE,
3479                                            G_CALLBACK(search_start_cb), sd);
3480         pref_spacer(hbox, PREF_PAD_BUTTON_GAP);
3481         sd->button_stop = pref_button_new(hbox, GTK_STOCK_STOP, NULL, FALSE,
3482                                           G_CALLBACK(search_start_cb), sd);
3483         gtk_widget_set_sensitive(sd->button_stop, FALSE);
3484
3485         search_status_update(sd);
3486         search_progress_update(sd, FALSE, -1.0);
3487
3488         search_window_list = g_list_append(search_window_list, sd);
3489
3490         file_data_register_notify_func(search_notify_cb, sd, NOTIFY_PRIORITY_MEDIUM);
3491
3492         gtk_widget_show(sd->window);
3493 }
3494
3495 /*
3496  *-------------------------------------------------------------------
3497  * maintenance (move, delete, etc.)
3498  *-------------------------------------------------------------------
3499  */
3500
3501 static void search_result_change_path(SearchData *sd, FileData *fd)
3502 {
3503         GtkTreeModel *store;
3504         GtkTreeIter iter;
3505         gboolean valid;
3506
3507         store = gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view));
3508         valid = gtk_tree_model_get_iter_first(store, &iter);
3509         while (valid)
3510                 {
3511                 GtkTreeIter current;
3512                 MatchFileData *mfd;
3513
3514                 current = iter;
3515                 valid = gtk_tree_model_iter_next(store, &iter);
3516
3517                 gtk_tree_model_get(store, &current, SEARCH_COLUMN_POINTER, &mfd, -1);
3518                 if (mfd->fd == fd)
3519                         {
3520                         if (fd->change && fd->change->dest)
3521                                 {
3522                                 gtk_list_store_set(GTK_LIST_STORE(store), &current,
3523                                                    SEARCH_COLUMN_NAME, mfd->fd->name,
3524                                                    SEARCH_COLUMN_PATH, mfd->fd->path, -1);
3525                                 }
3526                         else
3527                                 {
3528                                 search_result_remove_item(sd, mfd, &current);
3529                                 }
3530                         }
3531                 }
3532 }
3533
3534 static void search_notify_cb(FileData *fd, NotifyType type, gpointer data)
3535 {
3536         SearchData *sd = data;
3537
3538         if (!(type & NOTIFY_CHANGE) || !fd->change) return;
3539
3540         DEBUG_1("Notify search: %s %04x", fd->path, type);
3541
3542         switch (fd->change->type)
3543                 {
3544                 case FILEDATA_CHANGE_MOVE:
3545                 case FILEDATA_CHANGE_RENAME:
3546                 case FILEDATA_CHANGE_DELETE:
3547                         search_result_change_path(sd, fd);
3548                         break;
3549                 case FILEDATA_CHANGE_COPY:
3550                 case FILEDATA_CHANGE_UNSPECIFIED:
3551                 case FILEDATA_CHANGE_WRITE_METADATA:
3552                         break;
3553                 }
3554 }
3555 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */