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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include <ctype.h>
  25
  26 #include <gtk/gtk.h>
  27 #include <gdk/gdkkeysyms.h>
  28
  29 #include "intl.h"
  30 #include "utils.h"
  31 #include "menu.h"
  32 #include "prefs_common.h"
  33 #include "description_window.h"
  34 #include "matcher.h"
  35 #include "matcher_parser.h"
  36 #include "quicksearch.h"
  37 #include "folderview.h"
  38 #include "folder.h"
  39
  40 struct _QuickSearch
  41 {
  42         GtkWidget                       *hbox_search;
  43         GtkWidget                       *search_type;
  44         GtkWidget                       *search_type_opt;
  45         GtkWidget                       *search_string_entry;
  46         GtkWidget                       *search_description;
  47
  48         gboolean                         active;
  49         gchar                           *search_string;
  50         MatcherList                     *matcher_list;
  51
  52         QuickSearchExecuteCallback       callback;
  53         gpointer                         callback_data;
  54         gboolean                         running;
  55         gboolean                         has_focus;
  56         FolderItem                      *root_folder_item;
  57 };
  58
  59 static void quicksearch_set_running(QuickSearch *quicksearch, gboolean run);
  60 static void quicksearch_set_active(QuickSearch *quicksearch, gboolean active);
  61 static void quicksearch_reset_folder_items(QuickSearch *quicksearch, FolderItem *folder_item);
  62
  63 static void prepare_matcher(QuickSearch *quicksearch)
  64 {
  65         const gchar *search_string = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(quicksearch->search_string_entry)->entry));
  66
  67         if (quicksearch->matcher_list != NULL) {
  68                 matcherlist_free(quicksearch->matcher_list);
  69                 quicksearch->matcher_list = NULL;
  70         }
  71
  72         if (search_string == NULL || search_string[0] == '\0') {
  73                 quicksearch_set_active(quicksearch, FALSE);
  74                 return;
  75         }
  76
  77         if (prefs_common.summary_quicksearch_type == QUICK_SEARCH_EXTENDED) {
  78                 char *newstr = NULL;
  79
  80                 newstr = expand_search_string(search_string);
  81                 if (newstr && newstr[0] != '\0') {
  82                         quicksearch->matcher_list = matcher_parser_get_cond(newstr);
  83                         g_free(newstr);
  84                 } else {
  85                         quicksearch->matcher_list = NULL;
  86                         quicksearch_set_active(quicksearch, FALSE);
  87
  88                         return;
  89                 }
  90         } else {
  91                 if (quicksearch->search_string != NULL)
  92                         g_free(quicksearch->search_string);
  93                 quicksearch->search_string = g_strdup(search_string);
  94         }
  95
  96         quicksearch_set_active(quicksearch, TRUE);
  97 }
  98
  99 static void update_extended_button (QuickSearch *quicksearch)
 100 {
 101         GtkWidget *btn = quicksearch->search_description;
 102
 103         g_return_if_fail(btn != NULL);
 104
 105         if (prefs_common.summary_quicksearch_type == QUICK_SEARCH_EXTENDED) {
 106                 gtk_button_set_label(GTK_BUTTON(btn), _("Extended symbols"));
 107                 gtk_widget_show(btn);
 108         } else {
 109                 gtk_widget_hide(btn);
 110         }
 111
 112 }
 113
 114 static gboolean searchbar_focus_evt(GtkWidget *widget, GdkEventFocus *event,
 115                                   QuickSearch *quicksearch)
 116 {
 117         quicksearch->has_focus = (event && event->in);
 118         return FALSE;
 119 }
 120
 121 gboolean quicksearch_has_focus(QuickSearch *quicksearch)
 122 {
 123         return quicksearch->has_focus;
 124 }
 125
 126 static gboolean searchbar_pressed(GtkWidget *widget, GdkEventKey *event,
 127                                   QuickSearch *quicksearch)
 128 {
 129         if (event != NULL && event->keyval == GDK_Escape) {
 130                 quicksearch_set(quicksearch, prefs_common.summary_quicksearch_type, "");
 131                 gtk_widget_grab_focus(GTK_WIDGET(GTK_COMBO(quicksearch->search_string_entry)->entry));
 132                 return TRUE;
 133         }
 134
 135         if (event != NULL && event->keyval == GDK_Return) {
 136                 const gchar *search_string = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(quicksearch->search_string_entry)->entry));
 137
 138                 if (search_string && strlen(search_string) != 0) {
 139                         prefs_common.summary_quicksearch_history =
 140                                 add_history(prefs_common.summary_quicksearch_history,
 141                                             search_string);
 142                         gtk_combo_set_popdown_strings(GTK_COMBO(quicksearch->search_string_entry),
 143                                 prefs_common.summary_quicksearch_history);
 144                 }
 145
 146                 prepare_matcher(quicksearch);
 147
 148                 quicksearch_set_running(quicksearch, TRUE);
 149                 if (quicksearch->callback != NULL)
 150                         quicksearch->callback(quicksearch, quicksearch->callback_data);
 151                 quicksearch_set_running(quicksearch, FALSE);
 152                 g_signal_stop_emission_by_name(G_OBJECT(widget), "key_press_event");
 153                 gtk_widget_grab_focus(GTK_WIDGET(GTK_COMBO(
 154                         quicksearch->search_string_entry)->entry));
 155                 return TRUE;
 156         }
 157
 158         return FALSE;
 159 }
 160
 161 static gboolean searchtype_changed(GtkMenuItem *widget, gpointer data)
 162 {
 163         QuickSearch *quicksearch = (QuickSearch *)data;
 164
 165         prefs_common.summary_quicksearch_type = GPOINTER_TO_INT(g_object_get_data(
 166                                    G_OBJECT(GTK_MENU_ITEM(gtk_menu_get_active(
 167                                    GTK_MENU(quicksearch->search_type)))), MENU_VAL_ID));
 168
 169         /* Show extended search description button, only when Extended is selected */
 170         update_extended_button(quicksearch);
 171
 172         prepare_matcher(quicksearch);
 173
 174         quicksearch_set_running(quicksearch, TRUE);
 175         if (quicksearch->callback != NULL)
 176                 quicksearch->callback(quicksearch, quicksearch->callback_data);
 177         quicksearch_set_running(quicksearch, FALSE);
 178 }
 179
 180 /*
 181  * Strings describing how to use Extended Search
 182  *
 183  * When adding new lines, remember to put 2 strings for each line
 184  */
 185 static gchar *search_descr_strings[] = {
 186         "a",     N_("all messages"),
 187         "ag #",  N_("messages whose age is greater than #"),
 188         "al #",  N_("messages whose age is less than #"),
 189         "b S",   N_("messages which contain S in the message body"),
 190         "B S",   N_("messages which contain S in the whole message"),
 191         "c S",   N_("messages carbon-copied to S"),
 192         "C S",   N_("message is either to: or cc: to S"),
 193         "D",     N_("deleted messages"), /** how I can filter deleted messages **/
 194         "e S",   N_("messages which contain S in the Sender field"),
 195         "E S",   N_("true if execute \"S\" succeeds"),
 196         "f S",   N_("messages originating from user S"),
 197         "F",     N_("forwarded messages"),
 198         "h S",   N_("messages which contain header S"),
 199         "i S",   N_("messages which contain S in Message-ID header"),
 200         "I S",   N_("messages which contain S in inreplyto header"),
 201         "L",     N_("locked messages"),
 202         "n S",   N_("messages which are in newsgroup S"),
 203         "N",     N_("new messages"),
 204         "O",     N_("old messages"),
 205         "p",     N_("incomplete messages (not entirely downloaded)"),
 206         "r",     N_("messages which have been replied to"),
 207         "R",     N_("read messages"),
 208         "s S",   N_("messages which contain S in subject"),
 209         "se #",  N_("messages whose score is equal to #"),
 210         "sg #",  N_("messages whose score is greater than #"),
 211         "sl #",  N_("messages whose score is lower than #"),
 212         "Se #",  N_("messages whose size is equal to #"),
 213         "Sg #",  N_("messages whose size is greater than #"),
 214         "Ss #",  N_("messages whose size is smaller than #"),
 215         "t S",   N_("messages which have been sent to S"),
 216         "T",     N_("marked messages"),
 217         "U",     N_("unread messages"),
 218         "x S",   N_("messages which contain S in References header"),
 219         "X cmd", N_("messages returning 0 when passed to command"),
 220         "y S",   N_("messages which contain S in X-Label header"),
 221         "",      "" ,
 222         "&",     N_("logical AND operator"),
 223         "|",     N_("logical OR operator"),
 224         "! or ~",       N_("logical NOT operator"),
 225         "%",     N_("case sensitive search"),
 226         "",      "" ,
 227         " ",     N_("all filtering expressions are allowed"),
 228         NULL,    NULL
 229 };
 230
 231 static DescriptionWindow search_descr = {
 232         NULL,
 233         2,
 234         N_("Extended Search symbols"),
 235         search_descr_strings
 236 };
 237
 238 static void search_description_cb(GtkWidget *widget)
 239 {
 240         description_window_create(&search_descr);
 241 };
 242
 243 static gboolean clear_search_cb(GtkMenuItem *widget, gpointer data)
 244 {
 245         QuickSearch *quicksearch = (QuickSearch *)data;
 246
 247         quicksearch_set(quicksearch, prefs_common.summary_quicksearch_type, "");
 248
 249         return TRUE;
 250 };
 251
 252 QuickSearch *quicksearch_new()
 253 {
 254         QuickSearch *quicksearch;
 255
 256         GtkWidget *hbox_search;
 257         GtkWidget *search_type_opt;
 258         GtkWidget *search_type;
 259         GtkWidget *search_string_entry;
 260         GtkWidget *search_hbbox;
 261         GtkWidget *search_description;
 262         GtkWidget *clear_search;
 263         GtkWidget *menuitem;
 264
 265         quicksearch = g_new0(QuickSearch, 1);
 266
 267         /* quick search */
 268         hbox_search = gtk_hbox_new(FALSE, 0);
 269
 270         search_type_opt = gtk_option_menu_new();
 271         gtk_widget_show(search_type_opt);
 272         gtk_box_pack_start(GTK_BOX(hbox_search), search_type_opt, FALSE, FALSE, 0);
 273
 274         search_type = gtk_menu_new();
 275         MENUITEM_ADD (search_type, menuitem, _("Subject"), QUICK_SEARCH_SUBJECT);
 276         g_signal_connect(G_OBJECT(menuitem), "activate",
 277                          G_CALLBACK(searchtype_changed),
 278                          quicksearch);
 279         MENUITEM_ADD (search_type, menuitem, _("From"), QUICK_SEARCH_FROM);
 280         g_signal_connect(G_OBJECT(menuitem), "activate",
 281                          G_CALLBACK(searchtype_changed),
 282                          quicksearch);
 283         MENUITEM_ADD (search_type, menuitem, _("To"), QUICK_SEARCH_TO);
 284         g_signal_connect(G_OBJECT(menuitem), "activate",
 285                          G_CALLBACK(searchtype_changed),
 286                          quicksearch);
 287         MENUITEM_ADD (search_type, menuitem, _("Extended"), QUICK_SEARCH_EXTENDED);
 288         g_signal_connect(G_OBJECT(menuitem), "activate",
 289                          G_CALLBACK(searchtype_changed),
 290                          quicksearch);
 291
 292         gtk_option_menu_set_menu(GTK_OPTION_MENU(search_type_opt), search_type);
 293
 294         gtk_option_menu_set_history(GTK_OPTION_MENU(search_type_opt), prefs_common.summary_quicksearch_type);
 295
 296         gtk_widget_show(search_type);
 297
 298         search_string_entry = gtk_combo_new();
 299         gtk_box_pack_start(GTK_BOX(hbox_search), search_string_entry, FALSE, FALSE, 2);
 300         gtk_combo_set_value_in_list(GTK_COMBO(search_string_entry), FALSE, TRUE);
 301         gtk_combo_set_case_sensitive(GTK_COMBO(search_string_entry), TRUE);
 302         if (prefs_common.summary_quicksearch_history)
 303                 gtk_combo_set_popdown_strings(GTK_COMBO(search_string_entry),
 304                         prefs_common.summary_quicksearch_history);
 305         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(search_string_entry)->entry), "");
 306         gtk_widget_show(search_string_entry);
 307
 308         search_hbbox = gtk_hbutton_box_new();
 309         gtk_button_box_set_layout(GTK_BUTTON_BOX(search_hbbox),
 310                                   GTK_BUTTONBOX_START);
 311
 312         gtk_box_set_spacing(GTK_BOX(search_hbbox), 5);
 313
 314         if (prefs_common.summary_quicksearch_sticky) {
 315                 clear_search = gtk_button_new_with_label(_("Clear"));
 316                 gtk_box_pack_start(GTK_BOX(search_hbbox), clear_search,
 317                                    FALSE, FALSE, 0);
 318                 gtk_widget_set_usize(clear_search, 120, -1);
 319                 g_signal_connect(G_OBJECT(clear_search), "clicked",
 320                                  G_CALLBACK(clear_search_cb), quicksearch);
 321                 gtk_widget_show(clear_search);
 322         }
 323
 324         search_description = gtk_button_new_with_label(_("Extended Symbols"));
 325         gtk_box_pack_start(GTK_BOX(search_hbbox), search_description,
 326                            TRUE, TRUE, 0);
 327         gtk_widget_show(search_description);
 328
 329         g_signal_connect(G_OBJECT(search_description), "clicked",
 330                          G_CALLBACK(search_description_cb), NULL);
 331
 332         gtk_box_pack_start(GTK_BOX(hbox_search), search_hbbox, FALSE, FALSE, 2);
 333         gtk_widget_show(search_hbbox);
 334         if (prefs_common.summary_quicksearch_type == QUICK_SEARCH_EXTENDED)
 335                 gtk_widget_show(search_description);
 336         else
 337                 gtk_widget_hide(search_description);
 338
 339         g_signal_connect(G_OBJECT(GTK_COMBO(search_string_entry)->entry),
 340                            "key_press_event",
 341                            G_CALLBACK(searchbar_pressed),
 342                            quicksearch);
 343
 344
 345         g_signal_connect(G_OBJECT(GTK_COMBO(search_string_entry)->entry),
 346                          "focus_in_event",
 347                          G_CALLBACK(searchbar_focus_evt),
 348                          quicksearch);
 349
 350         g_signal_connect(G_OBJECT(GTK_COMBO(search_string_entry)->entry),
 351                          "focus_out_event",
 352                          G_CALLBACK(searchbar_focus_evt),
 353                          quicksearch);
 354
 355
 356         quicksearch->hbox_search = hbox_search;
 357         quicksearch->search_type = search_type;
 358         quicksearch->search_type_opt = search_type_opt;
 359         quicksearch->search_string_entry = search_string_entry;
 360         quicksearch->search_description = search_description;
 361         quicksearch->matcher_list = NULL;
 362         quicksearch->active = FALSE;
 363         quicksearch->running = FALSE;
 364
 365         update_extended_button(quicksearch);
 366
 367         return quicksearch;
 368 }
 369
 370 GtkWidget *quicksearch_get_widget(QuickSearch *quicksearch)
 371 {
 372         return quicksearch->hbox_search;
 373 }
 374
 375 void quicksearch_show(QuickSearch *quicksearch)
 376 {
 377         prepare_matcher(quicksearch);
 378         gtk_widget_show(quicksearch->hbox_search);
 379         update_extended_button(quicksearch);
 380 }
 381
 382 void quicksearch_hide(QuickSearch *quicksearch)
 383 {
 384         quicksearch_set_active(quicksearch, FALSE);
 385         gtk_widget_hide(quicksearch->hbox_search);
 386 }
 387
 388 void quicksearch_set(QuickSearch *quicksearch, QuickSearchType type,
 389                      const gchar *matchstring)
 390 {
 391         gtk_option_menu_set_history(GTK_OPTION_MENU(quicksearch->search_type_opt),
 392                                     type);
 393         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(quicksearch->search_string_entry)->entry),
 394                            matchstring);
 395         prefs_common.summary_quicksearch_type = type;
 396
 397         prepare_matcher(quicksearch);
 398
 399         quicksearch_set_running(quicksearch, TRUE);
 400         if (quicksearch->callback != NULL)
 401                 quicksearch->callback(quicksearch, quicksearch->callback_data);
 402         quicksearch_set_running(quicksearch, FALSE);
 403 }
 404
 405 gboolean quicksearch_is_active(QuickSearch *quicksearch)
 406 {
 407         return quicksearch->active;
 408 }
 409
 410 static void quicksearch_set_active(QuickSearch *quicksearch, gboolean active)
 411 {
 412         quicksearch->active = active;
 413         if (!active) {
 414                 quicksearch_reset_cur_folder_item(quicksearch);
 415         }
 416 }
 417
 418 void quicksearch_set_execute_callback(QuickSearch *quicksearch,
 419                                       QuickSearchExecuteCallback callback,
 420                                       gpointer data)
 421 {
 422         quicksearch->callback = callback;
 423         quicksearch->callback_data = data;
 424 }
 425
 426 gboolean quicksearch_match(QuickSearch *quicksearch, MsgInfo *msginfo)
 427 {
 428         gchar *searched_header = NULL;
 429
 430         if (!quicksearch->active)
 431                 return TRUE;
 432
 433         switch (prefs_common.summary_quicksearch_type) {
 434         case QUICK_SEARCH_SUBJECT:
 435                 searched_header = msginfo->subject;
 436                 break;
 437         case QUICK_SEARCH_FROM:
 438                 searched_header = msginfo->from;
 439                 break;
 440         case QUICK_SEARCH_TO:
 441                 searched_header = msginfo->to;
 442                 break;
 443         case QUICK_SEARCH_EXTENDED:
 444                 break;
 445         default:
 446                 debug_print("unknown search type (%d)\n", prefs_common.summary_quicksearch_type);
 447                 break;
 448         }
 449
 450         if (prefs_common.summary_quicksearch_type != QUICK_SEARCH_EXTENDED &&
 451             quicksearch->search_string &&
 452             searched_header && strcasestr(searched_header, quicksearch->search_string) != NULL)
 453                 return TRUE;
 454         else if ((quicksearch->matcher_list != NULL) &&
 455                  matcherlist_match(quicksearch->matcher_list, msginfo))
 456                 return TRUE;
 457
 458         return FALSE;
 459 }
 460
 461 /* allow Mutt-like patterns in quick search */
 462 gchar *expand_search_string(const gchar *search_string)
 463 {
 464         int i = 0;
 465         gchar term_char, save_char;
 466         gchar *cmd_start, *cmd_end;
 467         GString *matcherstr;
 468         gchar *returnstr = NULL;
 469         gchar *copy_str;
 470         gboolean casesens, dontmatch;
 471         /* list of allowed pattern abbreviations */
 472         struct {
 473                 gchar           *abbreviated;   /* abbreviation */
 474                 gchar           *command;       /* actual matcher command */
 475                 gint            numparams;      /* number of params for cmd */
 476                 gboolean        qualifier;      /* do we append regexpcase */
 477                 gboolean        quotes;         /* do we need quotes */
 478         }
 479         cmds[] = {
 480                 { "a",  "all",                          0,      FALSE,  FALSE },
 481                 { "ag", "age_greater",                  1,      FALSE,  FALSE },
 482                 { "al", "age_lower",                    1,      FALSE,  FALSE },
 483                 { "b",  "body_part",                    1,      TRUE,   TRUE  },
 484                 { "B",  "message",                      1,      TRUE,   TRUE  },
 485                 { "c",  "cc",                           1,      TRUE,   TRUE  },
 486                 { "C",  "to_or_cc",                     1,      TRUE,   TRUE  },
 487                 { "D",  "deleted",                      0,      FALSE,  FALSE },
 488                 { "e",  "header \"Sender\"",            1,      TRUE,   TRUE  },
 489                 { "E",  "execute",                      1,      FALSE,  TRUE  },
 490                 { "f",  "from",                         1,      TRUE,   TRUE  },
 491                 { "F",  "forwarded",                    0,      FALSE,  FALSE },
 492                 { "h",  "headers_part",                 1,      TRUE,   TRUE  },
 493                 { "i",  "header \"Message-ID\"",        1,      TRUE,   TRUE  },
 494                 { "I",  "inreplyto",                    1,      TRUE,   TRUE  },
 495                 { "L",  "locked",                       0,      FALSE,  FALSE },
 496                 { "n",  "newsgroups",                   1,      TRUE,   TRUE  },
 497                 { "N",  "new",                          0,      FALSE,  FALSE },
 498                 { "O",  "~new",                         0,      FALSE,  FALSE },
 499                 { "r",  "replied",                      0,      FALSE,  FALSE },
 500                 { "R",  "~unread",                      0,      FALSE,  FALSE },
 501                 { "s",  "subject",                      1,      TRUE,   TRUE  },
 502                 { "se", "score_equal",                  1,      FALSE,  FALSE },
 503                 { "sg", "score_greater",                1,      FALSE,  FALSE },
 504                 { "sl", "score_lower",                  1,      FALSE,  FALSE },
 505                 { "Se", "size_equal",                   1,      FALSE,  FALSE },
 506                 { "Sg", "size_greater",                 1,      FALSE,  FALSE },
 507                 { "Ss", "size_smaller",                 1,      FALSE,  FALSE },
 508                 { "t",  "to",                           1,      TRUE,   TRUE  },
 509                 { "T",  "marked",                       0,      FALSE,  FALSE },
 510                 { "U",  "unread",                       0,      FALSE,  FALSE },
 511                 { "x",  "header \"References\"",        1,      TRUE,   TRUE  },
 512                 { "X",  "test",                         1,      FALSE,  FALSE },
 513                 { "y",  "header \"X-Label\"",           1,      TRUE,   TRUE  },
 514                 { "&",  "&",                            0,      FALSE,  FALSE },
 515                 { "|",  "|",                            0,      FALSE,  FALSE },
 516                 { "p",  "partial",                      0,      FALSE,  FALSE },
 517                 { NULL, NULL,                           0,      FALSE,  FALSE }
 518         };
 519
 520         if (search_string == NULL)
 521                 return NULL;
 522
 523         copy_str = g_strdup(search_string);
 524
 525         matcherstr = g_string_sized_new(16);
 526         cmd_start = copy_str;
 527         while (cmd_start && *cmd_start) {
 528                 /* skip all white spaces */
 529                 while (*cmd_start && isspace((guchar)*cmd_start))
 530                         cmd_start++;
 531                 cmd_end = cmd_start;
 532
 533                 /* extract a command */
 534                 while (*cmd_end && !isspace((guchar)*cmd_end))
 535                         cmd_end++;
 536
 537                 /* save character */
 538                 save_char = *cmd_end;
 539                 *cmd_end = '\0';
 540
 541                 dontmatch = FALSE;
 542                 casesens = FALSE;
 543
 544                 /* ~ and ! mean logical NOT */
 545                 if (*cmd_start == '~' || *cmd_start == '!')
 546                 {
 547                         dontmatch = TRUE;
 548                         cmd_start++;
 549                 }
 550                 /* % means case sensitive match */
 551                 if (*cmd_start == '%')
 552                 {
 553                         casesens = TRUE;
 554                         cmd_start++;
 555                 }
 556
 557                 /* find matching abbreviation */
 558                 for (i = 0; cmds[i].command; i++) {
 559                         if (!strcmp(cmd_start, cmds[i].abbreviated)) {
 560                                 /* restore character */
 561                                 *cmd_end = save_char;
 562
 563                                 /* copy command */
 564                                 if (matcherstr->len > 0) {
 565                                         g_string_append(matcherstr, " ");
 566                                 }
 567                                 if (dontmatch)
 568                                         g_string_append(matcherstr, "~");
 569                                 g_string_append(matcherstr, cmds[i].command);
 570                                 g_string_append(matcherstr, " ");
 571
 572                                 /* stop if no params required */
 573                                 if (cmds[i].numparams == 0)
 574                                         break;
 575
 576                                 /* extract a parameter, allow quotes */
 577                                 while (*cmd_end && isspace((guchar)*cmd_end))
 578                                         cmd_end++;
 579
 580                                 cmd_start = cmd_end;
 581                                 if (*cmd_start == '"') {
 582                                         term_char = '"';
 583                                         cmd_end++;
 584                                 }
 585                                 else
 586                                         term_char = ' ';
 587
 588                                 /* extract actual parameter */
 589                                 while ((*cmd_end) && (*cmd_end != term_char))
 590                                         cmd_end++;
 591
 592                                 if (*cmd_end == '"')
 593                                         cmd_end++;
 594
 595                                 save_char = *cmd_end;
 596                                 *cmd_end = '\0';
 597
 598                                 if (cmds[i].qualifier) {
 599                                         if (casesens)
 600                                                 g_string_append(matcherstr, "regexp ");
 601                                         else
 602                                                 g_string_append(matcherstr, "regexpcase ");
 603                                 }
 604
 605                                 /* do we need to add quotes ? */
 606                                 if (cmds[i].quotes && term_char != '"')
 607                                         g_string_append(matcherstr, "\"");
 608
 609                                 /* copy actual parameter */
 610                                 g_string_append(matcherstr, cmd_start);
 611
 612                                 /* do we need to add quotes ? */
 613                                 if (cmds[i].quotes && term_char != '"')
 614                                         g_string_append(matcherstr, "\"");
 615
 616                                 /* restore original character */
 617                                 *cmd_end = save_char;
 618
 619                                 break;
 620                         }
 621                 }
 622
 623                 if (*cmd_end)
 624                         cmd_end++;
 625                 cmd_start = cmd_end;
 626         }
 627
 628         g_free(copy_str);
 629
 630         /* return search string if no match is found to allow
 631            all available filtering expressions in quicksearch */
 632         if (matcherstr->len > 0) returnstr = matcherstr->str;
 633         else returnstr = g_strdup(search_string);
 634
 635         g_string_free(matcherstr, FALSE);
 636         return returnstr;
 637 }
 638
 639 static void quicksearch_set_running(QuickSearch *quicksearch, gboolean run)
 640 {
 641         quicksearch->running = run;
 642 }
 643
 644 gboolean quicksearch_is_running(QuickSearch *quicksearch)
 645 {
 646         return quicksearch->running;
 647 }
 648
 649 void quicksearch_pass_key(QuickSearch *quicksearch, guint val, GdkModifierType mod)
 650 {
 651         GtkEntry *entry = GTK_ENTRY(GTK_COMBO(quicksearch->search_string_entry)->entry);
 652         gint curpos = gtk_editable_get_position(GTK_EDITABLE(entry));
 653         char *str = g_strdup(gtk_entry_get_text(entry));
 654         char *begin = str;
 655         char *end = NULL;
 656         char *new = NULL;
 657
 658         if (mod == GDK_SHIFT_MASK)
 659                 val = toupper(val);
 660
 661         if (curpos < strlen(str)-1) {
 662                 end = g_strdup(str+curpos);
 663                 *(str+curpos) = '\0';
 664                 new = g_strdup_printf("%s%c%s", begin, val, end);
 665                 gtk_entry_set_text(entry, new);
 666                 g_free(end);
 667         } else {
 668                 new = g_strdup_printf("%s%c", begin, val);
 669                 gtk_entry_set_text(entry, new);
 670         }
 671         g_free(str);
 672         g_free(new);
 673         gtk_editable_set_position(GTK_EDITABLE(entry), curpos+1);
 674
 675 }
 676
 677 static gboolean quicksearch_match_subfolder(QuickSearch *quicksearch,
 678                                  FolderItem *src)
 679 {
 680         GSList *msglist = folder_item_get_msg_list(src);
 681         GSList *cur;
 682         gboolean result = FALSE;
 683
 684         for (cur = msglist; cur != NULL; cur = cur->next) {
 685                 MsgInfo *msg = (MsgInfo *)cur->data;
 686                 if (quicksearch_match(quicksearch, msg)) {
 687                         procmsg_msginfo_free(msg);
 688                         result = TRUE;
 689                         break;
 690                 }
 691                 procmsg_msginfo_free(msg);
 692         }
 693
 694         g_slist_free(msglist);
 695         return result;
 696 }
 697
 698 void quicksearch_search_subfolders(QuickSearch *quicksearch,
 699                                    FolderView *folderview,
 700                                    FolderItem *folder_item)
 701 {
 702         FolderItem *cur = NULL;
 703         GNode *node = folder_item->node->children;
 704
 705         for (; node != NULL; node = node->next) {
 706                 cur = FOLDER_ITEM(node->data);
 707                 if (quicksearch_match_subfolder(quicksearch, cur)) {
 708                         folderview_update_search_icon(cur, TRUE);
 709                 } else {
 710                         folderview_update_search_icon(cur, FALSE);
 711                 }
 712                 if (cur->node->children)
 713                         quicksearch_search_subfolders(quicksearch,
 714                                                       folderview,
 715                                                       cur);
 716         }
 717         quicksearch->root_folder_item = folder_item;
 718 }
 719
 720 static void quicksearch_reset_folder_items(QuickSearch *quicksearch,
 721                                     FolderItem *folder_item)
 722 {
 723         FolderItem *cur = NULL;
 724         GNode *node = folder_item->node->children;
 725
 726         for (; node != NULL; node = node->next) {
 727                 cur = FOLDER_ITEM(node->data);
 728                 folderview_update_search_icon(cur, FALSE);
 729                 if (cur->node->children)
 730                         quicksearch_reset_folder_items(quicksearch,
 731                                                        cur);
 732         }
 733 }
 734
 735 void quicksearch_reset_cur_folder_item(QuickSearch *quicksearch)
 736 {
 737         if (quicksearch->root_folder_item)
 738                 quicksearch_reset_folder_items(quicksearch, quicksearch->root_folder_item);
 739
 740         quicksearch->root_folder_item = NULL;
 741 }