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