src/gtk/quicksearch.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 2004 Hiroyuki Yamamoto & the Sylpheed-Claws team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include <glib.h>
  25 #include <glib/gi18n.h>
  26 #include <ctype.h>
  27
  28 #include <gtk/gtk.h>
  29 #include <gdk/gdkkeysyms.h>
  30
  31 #include "utils.h"
  32 #include "menu.h"
  33 #include "prefs_common.h"
  34 #include "description_window.h"
  35 #include "matcher.h"
  36 #include "matcher_parser.h"
  37 #include "quicksearch.h"
  38 #include "folderview.h"
  39 #include "folder.h"
  40 #include "prefs_matcher.h"
  41
  42 struct _QuickSearch
  43 {
  44         GtkWidget                       *hbox_search;
  45         GtkWidget                       *search_type;
  46         GtkWidget                       *search_type_opt;
  47         GtkWidget                       *search_string_entry;
  48         GtkWidget                       *search_condition_expression;
  49         GtkWidget                       *search_description;
  50         GtkWidget                       *clear_search;
  51
  52         gboolean                         active;
  53         gchar                           *search_string;
  54         MatcherList                     *matcher_list;
  55
  56         QuickSearchExecuteCallback       callback;
  57         gpointer                         callback_data;
  58         gboolean                         running;
  59         gboolean                         has_focus;
  60         FolderItem                      *root_folder_item;
  61 };
  62
  63 static void quicksearch_set_running(QuickSearch *quicksearch, gboolean run);
  64 static void quicksearch_set_active(QuickSearch *quicksearch, gboolean active);
  65 static void quicksearch_reset_folder_items(QuickSearch *quicksearch, FolderItem *folder_item);
  66
  67 static void prepare_matcher(QuickSearch *quicksearch)
  68 {
  69         const gchar *search_string = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(quicksearch->search_string_entry)->entry));
  70
  71         if (quicksearch->matcher_list != NULL) {
  72                 matcherlist_free(quicksearch->matcher_list);
  73                 quicksearch->matcher_list = NULL;
  74         }
  75
  76         if (search_string == NULL || search_string[0] == '\0') {
  77                 quicksearch_set_active(quicksearch, FALSE);
  78                 return;
  79         }
  80
  81         if (prefs_common.summary_quicksearch_type == QUICK_SEARCH_EXTENDED) {
  82                 char *newstr = NULL;
  83
  84                 newstr = expand_search_string(search_string);
  85                 if (newstr && newstr[0] != '\0') {
  86                         quicksearch->matcher_list = matcher_parser_get_cond(newstr);
  87                         g_free(newstr);
  88                 } else {
  89                         quicksearch->matcher_list = NULL;
  90                         quicksearch_set_active(quicksearch, FALSE);
  91
  92                         return;
  93                 }
  94         } else {
  95                 if (quicksearch->search_string != NULL)
  96                         g_free(quicksearch->search_string);
  97                 quicksearch->search_string = g_strdup(search_string);
  98         }
  99
 100         quicksearch_set_active(quicksearch, TRUE);
 101 }
 102
 103 static void update_extended_buttons (QuickSearch *quicksearch)
 104 {
 105         GtkWidget *expr_btn = quicksearch->search_condition_expression;
 106         GtkWidget *ext_btn = quicksearch->search_description;
 107
 108         g_return_if_fail(expr_btn != NULL);
 109         g_return_if_fail(ext_btn != NULL);
 110
 111         if (prefs_common.summary_quicksearch_type == QUICK_SEARCH_EXTENDED) {
 112                 gtk_widget_show(expr_btn);
 113                 gtk_widget_show(ext_btn);
 114         } else {
 115                 gtk_widget_hide(expr_btn);
 116                 gtk_widget_hide(ext_btn);
 117         }
 118 }
 119
 120 static gboolean searchbar_focus_evt(GtkWidget *widget, GdkEventFocus *event,
 121                                   QuickSearch *quicksearch)
 122 {
 123         quicksearch->has_focus = (event && event->in);
 124         return FALSE;
 125 }
 126
 127 gboolean quicksearch_has_focus(QuickSearch *quicksearch)
 128 {
 129         return quicksearch->has_focus;
 130 }
 131
 132 static void searchbar_run(QuickSearch *quicksearch)
 133 {
 134         const gchar *search_string = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(quicksearch->search_string_entry)->entry));
 135
 136         if (search_string && strlen(search_string) != 0) {
 137                 prefs_common.summary_quicksearch_history =
 138                         add_history(prefs_common.summary_quicksearch_history,
 139                                         search_string);
 140                 gtk_combo_set_popdown_strings(GTK_COMBO(quicksearch->search_string_entry),
 141                         prefs_common.summary_quicksearch_history);
 142         }
 143
 144         prepare_matcher(quicksearch);
 145
 146         quicksearch_set_running(quicksearch, TRUE);
 147         if (quicksearch->callback != NULL)
 148                 quicksearch->callback(quicksearch, quicksearch->callback_data);
 149         quicksearch_set_running(quicksearch, FALSE);
 150 }
 151
 152 static gboolean searchbar_pressed(GtkWidget *widget, GdkEventKey *event,
 153                                   QuickSearch *quicksearch)
 154 {
 155         if (event != NULL && event->keyval == GDK_Escape) {
 156                 quicksearch_set(quicksearch, prefs_common.summary_quicksearch_type, "");
 157                 return TRUE;
 158         }
 159
 160         if (event != NULL && event->keyval == GDK_Return) {
 161                 /* add expression to history list and exec quicksearch */
 162                 searchbar_run(quicksearch);
 163
 164                 g_signal_stop_emission_by_name(G_OBJECT(widget), "key_press_event");
 165                 return TRUE;
 166         }
 167
 168         return FALSE;
 169 }
 170
 171 static gboolean searchtype_changed(GtkMenuItem *widget, gpointer data)
 172 {
 173         QuickSearch *quicksearch = (QuickSearch *)data;
 174
 175         prefs_common.summary_quicksearch_type = GPOINTER_TO_INT(g_object_get_data(
 176                                    G_OBJECT(GTK_MENU_ITEM(gtk_menu_get_active(
 177                                    GTK_MENU(quicksearch->search_type)))), MENU_VAL_ID));
 178
 179         /* Show extended search description button, only when Extended is selected */
 180         update_extended_buttons(quicksearch);
 181
 182         prepare_matcher(quicksearch);
 183
 184         quicksearch_set_running(quicksearch, TRUE);
 185         if (quicksearch->callback != NULL)
 186                 quicksearch->callback(quicksearch, quicksearch->callback_data);
 187         quicksearch_set_running(quicksearch, FALSE);
 188         return TRUE;
 189 }
 190
 191 static gboolean searchtype_recursive_changed(GtkMenuItem *widget, gpointer data)
 192 {
 193         QuickSearch *quicksearch = (QuickSearch *)data;
 194         gboolean checked = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
 195
 196         prefs_common.summary_quicksearch_recurse = checked;
 197
 198         /* reselect the search type */
 199         gtk_option_menu_set_history(GTK_OPTION_MENU(quicksearch->search_type_opt),
 200                                     prefs_common.summary_quicksearch_type);
 201
 202         prepare_matcher(quicksearch);
 203
 204         quicksearch_set_running(quicksearch, TRUE);
 205         if (quicksearch->callback != NULL)
 206                 quicksearch->callback(quicksearch, quicksearch->callback_data);
 207         quicksearch_set_running(quicksearch, FALSE);
 208         return TRUE;
 209 }
 210
 211 static gboolean searchtype_sticky_changed(GtkMenuItem *widget, gpointer data)
 212 {
 213         QuickSearch *quicksearch = (QuickSearch *)data;
 214         gboolean checked = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
 215
 216         prefs_common.summary_quicksearch_sticky = checked;
 217
 218         /* reselect the search type */
 219         gtk_option_menu_set_history(GTK_OPTION_MENU(quicksearch->search_type_opt),
 220                                     prefs_common.summary_quicksearch_type);
 221
 222         return TRUE;
 223 }
 224
 225 /*
 226  * Strings describing how to use Extended Search
 227  *
 228  * When adding new lines, remember to put 2 strings for each line
 229  */
 230 static gchar *search_descr_strings[] = {
 231         "a",     N_("all messages"),
 232         "ag #",  N_("messages whose age is greater than #"),
 233         "al #",  N_("messages whose age is less than #"),
 234         "b S",   N_("messages which contain S in the message body"),
 235         "B S",   N_("messages which contain S in the whole message"),
 236         "c S",   N_("messages carbon-copied to S"),
 237         "C S",   N_("message is either to: or cc: to S"),
 238         "D",     N_("deleted messages"), /** how I can filter deleted messages **/
 239         "e S",   N_("messages which contain S in the Sender field"),
 240         "E S",   N_("true if execute \"S\" succeeds"),
 241         "f S",   N_("messages originating from user S"),
 242         "F",     N_("forwarded messages"),
 243         "h S",   N_("messages which contain header S"),
 244         "i S",   N_("messages which contain S in Message-ID header"),
 245         "I S",   N_("messages which contain S in inreplyto header"),
 246         "L",     N_("locked messages"),
 247         "n S",   N_("messages which are in newsgroup S"),
 248         "N",     N_("new messages"),
 249         "O",     N_("old messages"),
 250         "p",     N_("incomplete messages (not entirely downloaded)"),
 251         "r",     N_("messages which have been replied to"),
 252         "R",     N_("read messages"),
 253         "s S",   N_("messages which contain S in subject"),
 254         "se #",  N_("messages whose score is equal to #"),
 255         "sg #",  N_("messages whose score is greater than #"),
 256         "sl #",  N_("messages whose score is lower than #"),
 257         "Se #",  N_("messages whose size is equal to #"),
 258         "Sg #",  N_("messages whose size is greater than #"),
 259         "Ss #",  N_("messages whose size is smaller than #"),
 260         "t S",   N_("messages which have been sent to S"),
 261         "T",     N_("marked messages"),
 262         "U",     N_("unread messages"),
 263         "x S",   N_("messages which contain S in References header"),
 264         "X cmd", N_("messages returning 0 when passed to command"),
 265         "y S",   N_("messages which contain S in X-Label header"),
 266         "",      "" ,
 267         "&amp;",         N_("logical AND operator"),
 268         "|",     N_("logical OR operator"),
 269         "! or ~",       N_("logical NOT operator"),
 270         "%",     N_("case sensitive search"),
 271         "",      "" ,
 272         " ",     N_("all filtering expressions are allowed"),
 273         NULL,    NULL
 274 };
 275
 276 static DescriptionWindow search_descr = {
 277         NULL,
 278         NULL,
 279         2,
 280         N_("Extended Search"),
 281         N_("Extended Search allows the user to define criteria that messages must "
 282            "have in order to match and be displayed in the message list.\n\n"
 283            "The following symbols can be used:"),
 284         search_descr_strings
 285 };
 286
 287 static void search_description_cb(GtkWidget *widget)
 288 {
 289         description_window_create(&search_descr);
 290 };
 291
 292 static gboolean clear_search_cb(GtkMenuItem *widget, gpointer data)
 293 {
 294         QuickSearch *quicksearch = (QuickSearch *)data;
 295
 296         quicksearch_set(quicksearch, prefs_common.summary_quicksearch_type, "");
 297
 298         return TRUE;
 299 };
 300
 301 static void search_condition_expr_done(MatcherList * matchers)
 302 {
 303         gchar *str;
 304
 305         g_return_if_fail(
 306                         mainwindow_get_mainwindow()->summaryview->quicksearch != NULL);
 307
 308         if (matchers == NULL)
 309                 return;
 310
 311         str = matcherlist_to_string(matchers);
 312
 313         if (str != NULL) {
 314                 quicksearch_set(mainwindow_get_mainwindow()->summaryview->quicksearch,
 315                                 prefs_common.summary_quicksearch_type, str);
 316                 g_free(str);
 317
 318                 /* add expression to history list and exec quicksearch */
 319                 searchbar_run(mainwindow_get_mainwindow()->summaryview->quicksearch);
 320         }
 321 }
 322
 323 static gboolean search_condition_expr(GtkMenuItem *widget, gpointer data)
 324 {
 325         const gchar * cond_str;
 326         MatcherList * matchers = NULL;
 327
 328         g_return_val_if_fail(
 329                         mainwindow_get_mainwindow()->summaryview->quicksearch != NULL,
 330                         FALSE);
 331
 332         /* re-use it the current quicksearch value if it's a condition expression,
 333            otherwise ignore it silently */
 334         cond_str = gtk_entry_get_text(
 335                         GTK_ENTRY(GTK_COMBO(mainwindow_get_mainwindow()->summaryview->quicksearch->
 336                         search_string_entry)->entry));
 337         if (*cond_str != '\0') {
 338                 matchers = matcher_parser_get_cond((gchar*)cond_str);
 339         }
 340
 341         prefs_matcher_open(matchers, search_condition_expr_done);
 342
 343         if (matchers != NULL)
 344                 matcherlist_free(matchers);
 345
 346         return TRUE;
 347 };
 348
 349 QuickSearch *quicksearch_new()
 350 {
 351         QuickSearch *quicksearch;
 352
 353         GtkWidget *hbox_search;
 354         GtkWidget *search_type_opt;
 355         GtkWidget *search_type;
 356         GtkWidget *search_string_entry;
 357         GtkWidget *search_hbox;
 358         GtkWidget *search_description;
 359         GtkWidget *clear_search;
 360         GtkWidget *search_condition_expression;
 361         GtkWidget *menuitem;
 362         GtkTooltips *search_cond_expr_tip;
 363
 364         quicksearch = g_new0(QuickSearch, 1);
 365
 366         /* quick search */
 367         hbox_search = gtk_hbox_new(FALSE, 0);
 368
 369         search_type_opt = gtk_option_menu_new();
 370         gtk_widget_show(search_type_opt);
 371         gtk_box_pack_start(GTK_BOX(hbox_search), search_type_opt, FALSE, FALSE, 0);
 372
 373         search_type = gtk_menu_new();
 374         MENUITEM_ADD (search_type, menuitem, _("Subject"), QUICK_SEARCH_SUBJECT);
 375         g_signal_connect(G_OBJECT(menuitem), "activate",
 376                          G_CALLBACK(searchtype_changed),
 377                          quicksearch);
 378         MENUITEM_ADD (search_type, menuitem, _("From"), QUICK_SEARCH_FROM);
 379         g_signal_connect(G_OBJECT(menuitem), "activate",
 380                          G_CALLBACK(searchtype_changed),
 381                          quicksearch);
 382         MENUITEM_ADD (search_type, menuitem, _("To"), QUICK_SEARCH_TO);
 383         g_signal_connect(G_OBJECT(menuitem), "activate",
 384                          G_CALLBACK(searchtype_changed),
 385                          quicksearch);
 386         MENUITEM_ADD (search_type, menuitem, _("Extended"), QUICK_SEARCH_EXTENDED);
 387         g_signal_connect(G_OBJECT(menuitem), "activate",
 388                          G_CALLBACK(searchtype_changed),
 389                          quicksearch);
 390
 391         gtk_menu_shell_append(GTK_MENU_SHELL(search_type), gtk_separator_menu_item_new());
 392
 393         menuitem = gtk_check_menu_item_new_with_label(_("Recursive"));
 394         gtk_menu_shell_append(GTK_MENU_SHELL(search_type), menuitem);
 395
 396         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
 397                                         prefs_common.summary_quicksearch_recurse);
 398
 399         g_signal_connect(G_OBJECT(menuitem), "activate",
 400                          G_CALLBACK(searchtype_recursive_changed),
 401                          quicksearch);
 402
 403         menuitem = gtk_check_menu_item_new_with_label(_("Sticky"));
 404         gtk_menu_shell_append(GTK_MENU_SHELL(search_type), menuitem);
 405
 406         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
 407                                         prefs_common.summary_quicksearch_sticky);
 408
 409         g_signal_connect(G_OBJECT(menuitem), "activate",
 410                          G_CALLBACK(searchtype_sticky_changed),
 411                          quicksearch);
 412
 413         gtk_option_menu_set_menu(GTK_OPTION_MENU(search_type_opt), search_type);
 414
 415         gtk_option_menu_set_history(GTK_OPTION_MENU(search_type_opt), prefs_common.summary_quicksearch_type);
 416
 417         gtk_widget_show(search_type);
 418
 419         search_string_entry = gtk_combo_new();
 420         gtk_box_pack_start(GTK_BOX(hbox_search), search_string_entry, FALSE, FALSE, 2);
 421         gtk_combo_set_value_in_list(GTK_COMBO(search_string_entry), FALSE, TRUE);
 422         gtk_combo_set_case_sensitive(GTK_COMBO(search_string_entry), TRUE);
 423         if (prefs_common.summary_quicksearch_history)
 424                 gtk_combo_set_popdown_strings(GTK_COMBO(search_string_entry),
 425                         prefs_common.summary_quicksearch_history);
 426         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(search_string_entry)->entry), "");
 427         gtk_widget_show(search_string_entry);
 428
 429         search_hbox = gtk_hbox_new(FALSE, 5);
 430
 431         clear_search = gtk_button_new_with_label(_(" Clear "));
 432         gtk_box_pack_start(GTK_BOX(search_hbox), clear_search,
 433                            FALSE, FALSE, 0);
 434         g_signal_connect(G_OBJECT(clear_search), "clicked",
 435                          G_CALLBACK(clear_search_cb), quicksearch);
 436         gtk_widget_show(clear_search);
 437
 438         search_condition_expression = gtk_button_new_with_label (_(" ... "));
 439         gtk_box_pack_start(GTK_BOX(search_hbox), search_condition_expression,
 440                            FALSE, FALSE, 0);
 441         g_signal_connect(G_OBJECT (search_condition_expression), "clicked",
 442                          G_CALLBACK(search_condition_expr),
 443                          quicksearch);
 444         search_cond_expr_tip = gtk_tooltips_new();
 445         gtk_tooltips_set_tip(GTK_TOOLTIPS(search_cond_expr_tip),
 446                              search_condition_expression,
 447                              _("Quick search: edit filtering condition"), NULL);
 448         gtk_widget_show(search_condition_expression);
 449
 450         search_description = gtk_button_new_with_label(_(" Extended Symbols... "));
 451         gtk_box_pack_start(GTK_BOX(search_hbox), search_description,
 452                            FALSE, FALSE, 0);
 453         g_signal_connect(G_OBJECT(search_description), "clicked",
 454                          G_CALLBACK(search_description_cb), NULL);
 455         gtk_widget_show(search_description);
 456
 457         gtk_box_pack_start(GTK_BOX(hbox_search), search_hbox, FALSE, FALSE, 2);
 458         gtk_widget_show(search_hbox);
 459
 460         g_signal_connect(G_OBJECT(GTK_COMBO(search_string_entry)->entry),
 461                            "key_press_event",
 462                            G_CALLBACK(searchbar_pressed),
 463                            quicksearch);
 464         g_signal_connect(G_OBJECT(GTK_COMBO(search_string_entry)->entry),
 465                          "focus_in_event",
 466                          G_CALLBACK(searchbar_focus_evt),
 467                          quicksearch);
 468         g_signal_connect(G_OBJECT(GTK_COMBO(search_string_entry)->entry),
 469                          "focus_out_event",
 470                          G_CALLBACK(searchbar_focus_evt),
 471                          quicksearch);
 472
 473         quicksearch->hbox_search = hbox_search;
 474         quicksearch->search_type = search_type;
 475         quicksearch->search_type_opt = search_type_opt;
 476         quicksearch->search_string_entry = search_string_entry;
 477         quicksearch->search_condition_expression = search_condition_expression;
 478         quicksearch->search_description = search_description;
 479         quicksearch->matcher_list = NULL;
 480         quicksearch->active = FALSE;
 481         quicksearch->running = FALSE;
 482         quicksearch->clear_search = clear_search;
 483
 484         update_extended_buttons(quicksearch);
 485
 486         return quicksearch;
 487 }
 488
 489 GtkWidget *quicksearch_get_widget(QuickSearch *quicksearch)
 490 {
 491         return quicksearch->hbox_search;
 492 }
 493
 494 void quicksearch_show(QuickSearch *quicksearch)
 495 {
 496         prepare_matcher(quicksearch);
 497         gtk_widget_show(quicksearch->hbox_search);
 498         update_extended_buttons(quicksearch);
 499         gtk_widget_grab_focus(
 500                 GTK_WIDGET(GTK_COMBO(quicksearch->search_string_entry)->entry));
 501 }
 502
 503 void quicksearch_hide(QuickSearch *quicksearch)
 504 {
 505         quicksearch_set(quicksearch, prefs_common.summary_quicksearch_type, "");
 506         quicksearch_set_active(quicksearch, FALSE);
 507         gtk_widget_hide(quicksearch->hbox_search);
 508 }
 509
 510 void quicksearch_set(QuickSearch *quicksearch, QuickSearchType type,
 511                      const gchar *matchstring)
 512 {
 513         gtk_option_menu_set_history(GTK_OPTION_MENU(quicksearch->search_type_opt),
 514                                     type);
 515         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(quicksearch->search_string_entry)->entry),
 516                            matchstring);
 517         prefs_common.summary_quicksearch_type = type;
 518
 519         prepare_matcher(quicksearch);
 520
 521         quicksearch_set_running(quicksearch, TRUE);
 522         if (quicksearch->callback != NULL)
 523                 quicksearch->callback(quicksearch, quicksearch->callback_data);
 524         quicksearch_set_running(quicksearch, FALSE);
 525 }
 526
 527 gboolean quicksearch_is_active(QuickSearch *quicksearch)
 528 {
 529         return quicksearch->active;
 530 }
 531
 532 static void quicksearch_set_active(QuickSearch *quicksearch, gboolean active)
 533 {
 534         static GdkColor yellow;
 535         static gboolean yellow_initialised = FALSE;
 536
 537         if (!yellow_initialised) {
 538                 gdk_color_parse("#f5f6be", &yellow);
 539                 yellow_initialised = gdk_colormap_alloc_color(
 540                         gdk_colormap_get_system(), &yellow, FALSE, TRUE);
 541
 542         }
 543         quicksearch->active = active;
 544
 545         if (active) {
 546                 gtk_widget_set_sensitive(quicksearch->clear_search, TRUE);
 547                 if (yellow_initialised)
 548                         gtk_widget_modify_base(
 549                                 GTK_COMBO(quicksearch->search_string_entry)->entry,
 550                                 GTK_STATE_NORMAL, &yellow);
 551         } else {
 552                 gtk_widget_set_sensitive(quicksearch->clear_search, FALSE);
 553                 if (yellow_initialised)
 554                         gtk_widget_modify_base(
 555                                 GTK_COMBO(quicksearch->search_string_entry)->entry,
 556                                 GTK_STATE_NORMAL, NULL);
 557         }
 558
 559         if (!active) {
 560                 quicksearch_reset_cur_folder_item(quicksearch);
 561         }
 562 }
 563
 564 void quicksearch_set_execute_callback(QuickSearch *quicksearch,
 565                                       QuickSearchExecuteCallback callback,
 566                                       gpointer data)
 567 {
 568         quicksearch->callback = callback;
 569         quicksearch->callback_data = data;
 570 }
 571
 572 gboolean quicksearch_match(QuickSearch *quicksearch, MsgInfo *msginfo)
 573 {
 574         gchar *searched_header = NULL;
 575
 576         if (!quicksearch->active)
 577                 return TRUE;
 578
 579         switch (prefs_common.summary_quicksearch_type) {
 580         case QUICK_SEARCH_SUBJECT:
 581                 searched_header = msginfo->subject;
 582                 break;
 583         case QUICK_SEARCH_FROM:
 584                 searched_header = msginfo->from;
 585                 break;
 586         case QUICK_SEARCH_TO:
 587                 searched_header = msginfo->to;
 588                 break;
 589         case QUICK_SEARCH_EXTENDED:
 590                 break;
 591         default:
 592                 debug_print("unknown search type (%d)\n", prefs_common.summary_quicksearch_type);
 593                 break;
 594         }
 595
 596         if (prefs_common.summary_quicksearch_type != QUICK_SEARCH_EXTENDED &&
 597             quicksearch->search_string &&
 598             searched_header && strcasestr(searched_header, quicksearch->search_string) != NULL)
 599                 return TRUE;
 600         else if ((quicksearch->matcher_list != NULL) &&
 601                  matcherlist_match(quicksearch->matcher_list, msginfo))
 602                 return TRUE;
 603
 604         return FALSE;
 605 }
 606
 607 /* allow Mutt-like patterns in quick search */
 608 gchar *expand_search_string(const gchar *search_string)
 609 {
 610         int i = 0;
 611         gchar term_char, save_char;
 612         gchar *cmd_start, *cmd_end;
 613         GString *matcherstr;
 614         gchar *returnstr = NULL;
 615         gchar *copy_str;
 616         gboolean casesens, dontmatch;
 617         /* list of allowed pattern abbreviations */
 618         struct {
 619                 gchar           *abbreviated;   /* abbreviation */
 620                 gchar           *command;       /* actual matcher command */
 621                 gint            numparams;      /* number of params for cmd */
 622                 gboolean        qualifier;      /* do we append regexpcase */
 623                 gboolean        quotes;         /* do we need quotes */
 624         }
 625         cmds[] = {
 626                 { "a",  "all",                          0,      FALSE,  FALSE },
 627                 { "ag", "age_greater",                  1,      FALSE,  FALSE },
 628                 { "al", "age_lower",                    1,      FALSE,  FALSE },
 629                 { "b",  "body_part",                    1,      TRUE,   TRUE  },
 630                 { "B",  "message",                      1,      TRUE,   TRUE  },
 631                 { "c",  "cc",                           1,      TRUE,   TRUE  },
 632                 { "C",  "to_or_cc",                     1,      TRUE,   TRUE  },
 633                 { "D",  "deleted",                      0,      FALSE,  FALSE },
 634                 { "e",  "header \"Sender\"",            1,      TRUE,   TRUE  },
 635                 { "E",  "execute",                      1,      FALSE,  TRUE  },
 636                 { "f",  "from",                         1,      TRUE,   TRUE  },
 637                 { "F",  "forwarded",                    0,      FALSE,  FALSE },
 638                 { "h",  "headers_part",                 1,      TRUE,   TRUE  },
 639                 { "i",  "header \"Message-ID\"",        1,      TRUE,   TRUE  },
 640                 { "I",  "inreplyto",                    1,      TRUE,   TRUE  },
 641                 { "L",  "locked",                       0,      FALSE,  FALSE },
 642                 { "n",  "newsgroups",                   1,      TRUE,   TRUE  },
 643                 { "N",  "new",                          0,      FALSE,  FALSE },
 644                 { "O",  "~new",                         0,      FALSE,  FALSE },
 645                 { "r",  "replied",                      0,      FALSE,  FALSE },
 646                 { "R",  "~unread",                      0,      FALSE,  FALSE },
 647                 { "s",  "subject",                      1,      TRUE,   TRUE  },
 648                 { "se", "score_equal",                  1,      FALSE,  FALSE },
 649                 { "sg", "score_greater",                1,      FALSE,  FALSE },
 650                 { "sl", "score_lower",                  1,      FALSE,  FALSE },
 651                 { "Se", "size_equal",                   1,      FALSE,  FALSE },
 652                 { "Sg", "size_greater",                 1,      FALSE,  FALSE },
 653                 { "Ss", "size_smaller",                 1,      FALSE,  FALSE },
 654                 { "t",  "to",                           1,      TRUE,   TRUE  },
 655                 { "T",  "marked",                       0,      FALSE,  FALSE },
 656                 { "U",  "unread",                       0,      FALSE,  FALSE },
 657                 { "x",  "header \"References\"",        1,      TRUE,   TRUE  },
 658                 { "X",  "test",                         1,      FALSE,  FALSE },
 659                 { "y",  "header \"X-Label\"",           1,      TRUE,   TRUE  },
 660                 { "&",  "&",                            0,      FALSE,  FALSE },
 661                 { "|",  "|",                            0,      FALSE,  FALSE },
 662                 { "p",  "partial",                      0,      FALSE,  FALSE },
 663                 { NULL, NULL,                           0,      FALSE,  FALSE }
 664         };
 665
 666         if (search_string == NULL)
 667                 return NULL;
 668
 669         copy_str = g_strdup(search_string);
 670
 671         matcherstr = g_string_sized_new(16);
 672         cmd_start = copy_str;
 673         while (cmd_start && *cmd_start) {
 674                 /* skip all white spaces */
 675                 while (*cmd_start && isspace((guchar)*cmd_start))
 676                         cmd_start++;
 677                 cmd_end = cmd_start;
 678
 679                 /* extract a command */
 680                 while (*cmd_end && !isspace((guchar)*cmd_end))
 681                         cmd_end++;
 682
 683                 /* save character */
 684                 save_char = *cmd_end;
 685                 *cmd_end = '\0';
 686
 687                 dontmatch = FALSE;
 688                 casesens = FALSE;
 689
 690                 /* ~ and ! mean logical NOT */
 691                 if (*cmd_start == '~' || *cmd_start == '!')
 692                 {
 693                         dontmatch = TRUE;
 694                         cmd_start++;
 695                 }
 696                 /* % means case sensitive match */
 697                 if (*cmd_start == '%')
 698                 {
 699                         casesens = TRUE;
 700                         cmd_start++;
 701                 }
 702
 703                 /* find matching abbreviation */
 704                 for (i = 0; cmds[i].command; i++) {
 705                         if (!strcmp(cmd_start, cmds[i].abbreviated)) {
 706                                 /* restore character */
 707                                 *cmd_end = save_char;
 708
 709                                 /* copy command */
 710                                 if (matcherstr->len > 0) {
 711                                         g_string_append(matcherstr, " ");
 712                                 }
 713                                 if (dontmatch)
 714                                         g_string_append(matcherstr, "~");
 715                                 g_string_append(matcherstr, cmds[i].command);
 716                                 g_string_append(matcherstr, " ");
 717
 718                                 /* stop if no params required */
 719                                 if (cmds[i].numparams == 0)
 720                                         break;
 721
 722                                 /* extract a parameter, allow quotes */
 723                                 while (*cmd_end && isspace((guchar)*cmd_end))
 724                                         cmd_end++;
 725
 726                                 cmd_start = cmd_end;
 727                                 if (*cmd_start == '"') {
 728                                         term_char = '"';
 729                                         cmd_end++;
 730                                 }
 731                                 else
 732                                         term_char = ' ';
 733
 734                                 /* extract actual parameter */
 735                                 while ((*cmd_end) && (*cmd_end != term_char))
 736                                         cmd_end++;
 737
 738                                 if (*cmd_end == '"')
 739                                         cmd_end++;
 740
 741                                 save_char = *cmd_end;
 742                                 *cmd_end = '\0';
 743
 744                                 if (cmds[i].qualifier) {
 745                                         if (casesens)
 746                                                 g_string_append(matcherstr, "regexp ");
 747                                         else
 748                                                 g_string_append(matcherstr, "regexpcase ");
 749                                 }
 750
 751                                 /* do we need to add quotes ? */
 752                                 if (cmds[i].quotes && term_char != '"')
 753                                         g_string_append(matcherstr, "\"");
 754
 755                                 /* copy actual parameter */
 756                                 g_string_append(matcherstr, cmd_start);
 757
 758                                 /* do we need to add quotes ? */
 759                                 if (cmds[i].quotes && term_char != '"')
 760                                         g_string_append(matcherstr, "\"");
 761
 762                                 /* restore original character */
 763                                 *cmd_end = save_char;
 764
 765                                 break;
 766                         }
 767                 }
 768
 769                 if (*cmd_end)
 770                         cmd_end++;
 771                 cmd_start = cmd_end;
 772         }
 773
 774         g_free(copy_str);
 775
 776         /* return search string if no match is found to allow
 777            all available filtering expressions in quicksearch */
 778         if (matcherstr->len > 0) returnstr = matcherstr->str;
 779         else returnstr = g_strdup(search_string);
 780
 781         g_string_free(matcherstr, FALSE);
 782         return returnstr;
 783 }
 784
 785 static void quicksearch_set_running(QuickSearch *quicksearch, gboolean run)
 786 {
 787         quicksearch->running = run;
 788 }
 789
 790 gboolean quicksearch_is_running(QuickSearch *quicksearch)
 791 {
 792         return quicksearch->running;
 793 }
 794
 795 void quicksearch_pass_key(QuickSearch *quicksearch, guint val, GdkModifierType mod)
 796 {
 797         GtkEntry *entry = GTK_ENTRY(GTK_COMBO(quicksearch->search_string_entry)->entry);
 798         gint curpos = gtk_editable_get_position(GTK_EDITABLE(entry));
 799         char *str = g_strdup(gtk_entry_get_text(entry));
 800         char *begin = str;
 801         char *end = NULL;
 802         char *new = NULL;
 803
 804         if (mod == GDK_SHIFT_MASK)
 805                 val = toupper(val);
 806
 807         if (curpos < strlen(str)-1) {
 808                 end = g_strdup(str+curpos);
 809                 *(str+curpos) = '\0';
 810                 new = g_strdup_printf("%s%c%s", begin, val, end);
 811                 gtk_entry_set_text(entry, new);
 812                 g_free(end);
 813         } else {
 814                 new = g_strdup_printf("%s%c", begin, val);
 815                 gtk_entry_set_text(entry, new);
 816         }
 817         g_free(str);
 818         g_free(new);
 819         gtk_editable_set_position(GTK_EDITABLE(entry), curpos+1);
 820
 821 }
 822
 823 static gboolean quicksearch_match_subfolder(QuickSearch *quicksearch,
 824                                  FolderItem *src)
 825 {
 826         GSList *msglist = folder_item_get_msg_list(src);
 827         GSList *cur;
 828         gboolean result = FALSE;
 829
 830         for (cur = msglist; cur != NULL; cur = cur->next) {
 831                 MsgInfo *msg = (MsgInfo *)cur->data;
 832                 if (quicksearch_match(quicksearch, msg)) {
 833                         procmsg_msginfo_free(msg);
 834                         result = TRUE;
 835                         break;
 836                 }
 837                 procmsg_msginfo_free(msg);
 838         }
 839
 840         g_slist_free(msglist);
 841         return result;
 842 }
 843
 844 void quicksearch_search_subfolders(QuickSearch *quicksearch,
 845                                    FolderView *folderview,
 846                                    FolderItem *folder_item)
 847 {
 848         FolderItem *cur = NULL;
 849         GNode *node = folder_item->node->children;
 850
 851         if (!prefs_common.summary_quicksearch_recurse)
 852                 return;
 853
 854         for (; node != NULL; node = node->next) {
 855                 cur = FOLDER_ITEM(node->data);
 856                 if (quicksearch_match_subfolder(quicksearch, cur)) {
 857                         folderview_update_search_icon(cur, TRUE);
 858                 } else {
 859                         folderview_update_search_icon(cur, FALSE);
 860                 }
 861                 if (cur->node->children)
 862                         quicksearch_search_subfolders(quicksearch,
 863                                                       folderview,
 864                                                       cur);
 865         }
 866         quicksearch->root_folder_item = folder_item;
 867 }
 868
 869 static void quicksearch_reset_folder_items(QuickSearch *quicksearch,
 870                                     FolderItem *folder_item)
 871 {
 872         FolderItem *cur = NULL;
 873         GNode *node = (folder_item && folder_item->node) ?
 874                         folder_item->node->children : NULL;
 875
 876         for (; node != NULL; node = node->next) {
 877                 cur = FOLDER_ITEM(node->data);
 878                 folderview_update_search_icon(cur, FALSE);
 879                 if (cur->node->children)
 880                         quicksearch_reset_folder_items(quicksearch,
 881                                                        cur);
 882         }
 883 }
 884
 885 void quicksearch_reset_cur_folder_item(QuickSearch *quicksearch)
 886 {
 887         if (quicksearch->root_folder_item)
 888                 quicksearch_reset_folder_items(quicksearch,
 889                                                quicksearch->root_folder_item);
 890
 891         quicksearch->root_folder_item = NULL;
 892 }