src/prefs_matcher.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2007 Hiroyuki Yamamoto and the Claws Mail 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 3 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, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include "defs.h"
  25
  26 #include <glib.h>
  27 #include <glib/gi18n.h>
  28 #include <gtk/gtk.h>
  29 #include <gdk/gdkkeysyms.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <errno.h>
  34
  35 #include "main.h"
  36 #include "prefs_gtk.h"
  37 #include "prefs_matcher.h"
  38 #include "prefs_common.h"
  39 #include "mainwindow.h"
  40 #include "foldersel.h"
  41 #include "manage_window.h"
  42 #include "inc.h"
  43 #include "matcher.h"
  44 #include "utils.h"
  45 #include "gtkutils.h"
  46 #include "alertpanel.h"
  47 #include "folder.h"
  48 #include "description_window.h"
  49
  50 #include "matcher_parser.h"
  51 #include "colorlabel.h"
  52
  53 static void prefs_matcher_addressbook_select(void);
  54 static void prefs_matcher_test_info(void);
  55
  56 enum {
  57         PREFS_MATCHER_COND,
  58         PREFS_MATCHER_COND_VALID,
  59         N_PREFS_MATCHER_COLUMNS
  60 };
  61
  62 /*!
  63  *\brief        UI data for matcher dialog
  64  */
  65 static struct Matcher {
  66         GtkWidget *window;
  67
  68         GtkWidget *ok_btn;
  69
  70         GtkWidget *predicate_combo;
  71         GtkWidget *predicate_flag_combo;
  72         GtkWidget *header_combo;
  73         GtkWidget *header_addr_combo;
  74
  75         GtkWidget *criteria_list;
  76
  77         GtkWidget *predicate_list;
  78         GtkWidget *predicate_label;
  79         GtkWidget *predicate_flag_list;
  80
  81         GtkWidget *bool_op_list;
  82
  83         GtkWidget *header_entry;
  84         GtkWidget *header_label;
  85         GtkWidget *header_addr_entry;
  86         GtkWidget *header_addr_label;
  87         GtkWidget *value_entry;
  88         GtkWidget *value_label;
  89         GtkWidget *addressbook_folder_label;
  90         GtkWidget *addressbook_folder_combo;
  91         GtkWidget *case_checkbtn;
  92         GtkWidget *regexp_checkbtn;
  93         GtkWidget *color_optmenu;
  94
  95         GtkWidget *test_btn;
  96         GtkWidget *addressbook_select_btn;
  97
  98         GtkWidget *cond_list_view;
  99
 100         GtkWidget *criteria_table;
 101
 102         gint selected_criteria; /*!< selected criteria in combobox */
 103 } matcher;
 104
 105 /*!
 106  *\brief        Conditions with a negate counterpart (like unread and ~unread)
 107  *              have the same CRITERIA_XXX id). I.e. both unread and ~unread
 108  *              have criteria id CRITERIA_UNREAD. This id is passed as the
 109  *              first parameter to #matcherprop_new and #matcherprop_unquote_new.
 110  *
 111  *\warning      Currently the enum constants should have the same order as the
 112  *              #criteria_text
 113  */
 114 enum {
 115         CRITERIA_ALL = 0,
 116
 117         CRITERIA_SUBJECT = 1,
 118         CRITERIA_FROM = 2,
 119         CRITERIA_TO = 3,
 120         CRITERIA_CC = 4,
 121         CRITERIA_TO_OR_CC = 5,
 122         CRITERIA_NEWSGROUPS = 6,
 123         CRITERIA_INREPLYTO = 7,
 124         CRITERIA_REFERENCES = 8,
 125         CRITERIA_AGE_GREATER = 9,
 126         CRITERIA_AGE_LOWER = 10,
 127         CRITERIA_HEADER = 11,
 128         CRITERIA_HEADERS_PART = 12,
 129         CRITERIA_BODY_PART = 13,
 130         CRITERIA_MESSAGE = 14,
 131
 132         CRITERIA_UNREAD = 15,
 133         CRITERIA_NEW = 16,
 134         CRITERIA_MARKED = 17,
 135         CRITERIA_DELETED = 18,
 136         CRITERIA_REPLIED = 19,
 137         CRITERIA_FORWARDED = 20,
 138         CRITERIA_LOCKED = 21,
 139         CRITERIA_SPAM = 22,
 140         CRITERIA_COLORLABEL = 23,
 141         CRITERIA_IGNORE_THREAD = 24,
 142         CRITERIA_WATCH_THREAD = 25,
 143
 144         CRITERIA_SCORE_GREATER = 26,
 145         CRITERIA_SCORE_LOWER = 27,
 146         CRITERIA_SCORE_EQUAL = 28,
 147
 148         CRITERIA_TEST = 29,
 149
 150         CRITERIA_SIZE_GREATER = 30,
 151         CRITERIA_SIZE_SMALLER = 31,
 152         CRITERIA_SIZE_EQUAL   = 32,
 153
 154         CRITERIA_PARTIAL = 33,
 155
 156         CRITERIA_FOUND_IN_ADDRESSBOOK = 34,
 157
 158         CRITERIA_TAG = 35,
 159         CRITERIA_TAGGED = 36
 160 };
 161
 162 /*!
 163  *\brief        Descriptive text for conditions
 164  */
 165 typedef struct _struct_criteria_text struct_criteria_text;
 166 struct _struct_criteria_text {
 167         const gchar     *text;
 168         gboolean         contains_header_name;
 169         /* if contains_header_name is TRUE, prefs_common_translated_headername(text)
 170            will be used
 171         */
 172 };
 173
 174 static struct_criteria_text criteria_text [] = {
 175         { N_("All messages"), FALSE },
 176         { N_("Subject"), TRUE },
 177         { N_("From"), TRUE },
 178         { N_("To"), TRUE },
 179         { N_("Cc"), TRUE },
 180         { N_("To or Cc"), TRUE },
 181         { N_("Newsgroups"), TRUE },
 182         { N_("In reply to"), TRUE },
 183         { N_("References"), TRUE },
 184         { N_("Age greater than (days)"), FALSE },
 185         { N_("Age less than (days)"), FALSE },
 186         { N_("Header"), FALSE },
 187         { N_("Headers part"), FALSE },
 188         { N_("Body part"), FALSE },
 189         { N_("Whole message"), FALSE },
 190         { N_("Unread flag"), FALSE },
 191         { N_("New flag"), FALSE },
 192         { N_("Marked flag"), FALSE },
 193         { N_("Deleted flag"), FALSE },
 194         { N_("Replied flag"), FALSE },
 195         { N_("Forwarded flag"), FALSE },
 196         { N_("Locked flag"), FALSE },
 197         { N_("Spam flag"), FALSE },
 198         { N_("Color label"), FALSE },
 199         { N_("Ignored thread"), FALSE },
 200         { N_("Watched thread"), FALSE },
 201         { N_("Score greater than"), FALSE },
 202         { N_("Score lower than"), FALSE },
 203         { N_("Score equal to"), FALSE },
 204         { N_("Test"), FALSE },
 205         { N_("Size greater than (bytes)"), FALSE },
 206         { N_("Size smaller than (bytes)"), FALSE },
 207         { N_("Size exactly (bytes)"), FALSE },
 208         { N_("Partially downloaded"), FALSE },
 209         { N_("Found in addressbook"), FALSE },
 210         { N_("Tags"), FALSE },
 211         { N_("Tagged"), FALSE },
 212         { NULL, FALSE }
 213 };
 214
 215 /*!
 216  *\brief        Boolean / predicate constants
 217  *
 218  *\warning      Same order as #bool_op_text!
 219  */
 220 enum {
 221         BOOL_OP_OR = 0,
 222         BOOL_OP_AND = 1
 223 };
 224
 225 /*!
 226  *\brief        Descriptive text in UI
 227  */
 228 static const gchar *bool_op_text [] = {
 229         N_("or"), N_("and")
 230 };
 231
 232 /*!
 233  *\brief        Contains predicate
 234  *
 235  *\warning      Same order as in #predicate_text
 236  */
 237 enum {
 238         PREDICATE_CONTAINS = 0,
 239         PREDICATE_DOES_NOT_CONTAIN = 1
 240 };
 241
 242 /*!
 243  *\brief        Descriptive text in UI for predicate
 244  */
 245 static const gchar *predicate_text [] = {
 246         N_("contains"), N_("does not contain")
 247 };
 248
 249 /*!
 250  *\brief        Preset addressbook book/folder items
 251  */
 252 static const gchar *addressbook_folder_text [] = {
 253         N_("Any")
 254 };
 255
 256 /*!
 257  *\brief        Enabled predicate
 258  *
 259  *\warning      Same order as in #predicate_flag_text
 260  */
 261 enum {
 262         PREDICATE_FLAG_ENABLED = 0,
 263         PREDICATE_FLAG_DISABLED = 1
 264 };
 265
 266 /*!
 267  *\brief        Descriptive text in UI for enabled flag
 268  */
 269 static const gchar *predicate_flag_text [] = {
 270         N_("yes"), N_("no")
 271 };
 272
 273 /*!
 274  *\brief        Hooks
 275  */
 276 static PrefsMatcherSignal *matchers_callback;
 277
 278 /* widget creating functions */
 279 static void prefs_matcher_create        (void);
 280
 281 static void prefs_matcher_set_dialog    (MatcherList *matchers);
 282 static void prefs_matcher_list_view_set_row     (GtkTreeIter *row,
 283                                                  MatcherProp *prop);
 284
 285 /* callback functions */
 286
 287 static void prefs_matcher_register_cb   (void);
 288 static void prefs_matcher_substitute_cb (void);
 289 static void prefs_matcher_delete_cb     (void);
 290 static void prefs_matcher_up            (void);
 291 static void prefs_matcher_down          (void);
 292 static gboolean prefs_matcher_key_pressed(GtkWidget     *widget,
 293                                          GdkEventKey    *event,
 294                                          gpointer        data);
 295 static void prefs_matcher_ok            (void);
 296 static void prefs_matcher_cancel        (void);
 297 static gint prefs_matcher_deleted       (GtkWidget *widget, GdkEventAny *event,
 298                                          gpointer data);
 299 static void prefs_matcher_criteria_select       (GtkList   *list,
 300                                                  GtkWidget *widget,
 301                                                  gpointer   user_data);
 302 static MatcherList *prefs_matcher_get_list      (void);
 303
 304 static GtkListStore* prefs_matcher_create_data_store    (void);
 305
 306 static void prefs_matcher_list_view_insert_matcher      (GtkWidget *list_view,
 307                                                          GtkTreeIter *row_iter,
 308                                                          const gchar *matcher,
 309                                                          gboolean is_valid);
 310
 311 static GtkWidget *prefs_matcher_list_view_create        (void);
 312
 313 static void prefs_matcher_create_list_view_columns      (GtkWidget *list_view);
 314
 315 static gboolean prefs_matcher_selected                  (GtkTreeSelection *selector,
 316                                                          GtkTreeModel *model,
 317                                                          GtkTreePath *path,
 318                                                          gboolean currently_selected,
 319                                                          gpointer data);
 320
 321 /*!
 322  *\brief        Find index of list selection
 323  *
 324  *\param        list GTK list widget
 325  *
 326  *\return       gint Selection index
 327  */
 328 static gint get_sel_from_list(GtkList *list)
 329 {
 330         gint row = 0;
 331         void * sel;
 332         GList * child;
 333
 334         sel = list->selection->data;
 335         for (child = list->children; child != NULL; child = g_list_next(child)) {
 336                 if (child->data == sel)
 337                         return row;
 338                 row ++;
 339         }
 340
 341         return row;
 342 }
 343
 344 /*!
 345  *\brief        Opens the matcher dialog with a list of conditions
 346  *
 347  *\param        matchers List of conditions
 348  *\param        cb Callback
 349  *
 350  */
 351 void prefs_matcher_open(MatcherList *matchers, PrefsMatcherSignal *cb)
 352 {
 353         inc_lock();
 354
 355         if (!matcher.window) {
 356                 prefs_matcher_create();
 357         } else {
 358                 /* update color label menu */
 359                 gtk_option_menu_set_menu(GTK_OPTION_MENU(matcher.color_optmenu),
 360                                 colorlabel_create_color_menu());
 361         }
 362
 363         manage_window_set_transient(GTK_WINDOW(matcher.window));
 364         gtk_widget_grab_focus(matcher.ok_btn);
 365
 366         matchers_callback = cb;
 367
 368         prefs_matcher_set_dialog(matchers);
 369
 370         gtk_widget_show(matcher.window);
 371 }
 372
 373 /*!
 374  *\brief        Save Gtk object size to prefs dataset
 375  */
 376 static void prefs_matcher_size_allocate_cb(GtkWidget *widget,
 377                                          GtkAllocation *allocation)
 378 {
 379         g_return_if_fail(allocation != NULL);
 380
 381         prefs_common.matcherwin_width = allocation->width;
 382         prefs_common.matcherwin_height = allocation->height;
 383 }
 384
 385 /*!
 386  *\brief        Create the matcher dialog
 387  */
 388 static void prefs_matcher_create(void)
 389 {
 390         GtkWidget *window;
 391         GtkWidget *vbox;
 392         GtkWidget *ok_btn;
 393         GtkWidget *cancel_btn;
 394         GtkWidget *confirm_area;
 395
 396         GtkWidget *vbox1;
 397         GtkWidget *vbox2;
 398         GtkWidget *vbox3;
 399         GtkWidget *criteria_table;
 400
 401         GtkWidget *hbox1;
 402
 403         GtkWidget *header_combo;
 404         GtkWidget *header_entry;
 405         GtkWidget *header_label;
 406         GtkWidget *header_addr_combo;
 407         GtkWidget *header_addr_entry;
 408         GtkWidget *header_addr_label;
 409         GtkWidget *criteria_combo;
 410         GtkWidget *criteria_list;
 411         GtkWidget *criteria_label;
 412         GtkWidget *value_label;
 413         GtkWidget *value_entry;
 414         GtkWidget *addressbook_folder_label;
 415         GtkWidget *addressbook_folder_combo;
 416         GtkWidget *predicate_combo;
 417         GtkWidget *predicate_list;
 418         GtkWidget *predicate_flag_combo;
 419         GtkWidget *predicate_flag_list;
 420         GtkWidget *predicate_label;
 421         GtkWidget *bool_op_combo;
 422         GtkWidget *bool_op_list;
 423         GtkWidget *bool_op_label;
 424
 425         GtkWidget *regexp_checkbtn;
 426         GtkWidget *case_checkbtn;
 427
 428         GtkWidget *reg_hbox;
 429         GtkWidget *btn_hbox;
 430         GtkWidget *arrow;
 431         GtkWidget *reg_btn;
 432         GtkWidget *subst_btn;
 433         GtkWidget *del_btn;
 434
 435         GtkWidget *cond_hbox;
 436         GtkWidget *cond_scrolledwin;
 437         GtkWidget *cond_list_view;
 438
 439         GtkWidget *btn_vbox;
 440         GtkWidget *up_btn;
 441         GtkWidget *down_btn;
 442
 443         GtkWidget *test_btn;
 444         GtkWidget *addressbook_select_btn;
 445
 446         GtkWidget *color_optmenu;
 447
 448         GList *combo_items;
 449         gint i;
 450         static GdkGeometry geometry;
 451
 452         debug_print("Creating matcher configuration window...\n");
 453
 454         window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefs_matcher");
 455         gtk_container_set_border_width(GTK_CONTAINER(window), 8);
 456         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
 457         gtk_window_set_modal(GTK_WINDOW(window), TRUE);
 458         gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
 459
 460         vbox = gtk_vbox_new(FALSE, 6);
 461         gtk_widget_show(vbox);
 462         gtk_container_add(GTK_CONTAINER(window), vbox);
 463
 464         gtkut_stock_button_set_create(&confirm_area, &cancel_btn, GTK_STOCK_CANCEL,
 465                                       &ok_btn, GTK_STOCK_OK, NULL, NULL);
 466         gtk_widget_show(confirm_area);
 467         gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
 468         gtk_widget_grab_default(ok_btn);
 469
 470         gtk_window_set_title(GTK_WINDOW(window),
 471                              _("Condition configuration"));
 472         g_signal_connect(G_OBJECT(window), "delete_event",
 473                          G_CALLBACK(prefs_matcher_deleted), NULL);
 474         g_signal_connect(G_OBJECT(window), "size_allocate",
 475                          G_CALLBACK(prefs_matcher_size_allocate_cb), NULL);
 476         g_signal_connect(G_OBJECT(window), "key_press_event",
 477                          G_CALLBACK(prefs_matcher_key_pressed), NULL);
 478         MANAGE_WINDOW_SIGNALS_CONNECT(window);
 479         g_signal_connect(G_OBJECT(ok_btn), "clicked",
 480                          G_CALLBACK(prefs_matcher_ok), NULL);
 481         g_signal_connect(G_OBJECT(cancel_btn), "clicked",
 482                          G_CALLBACK(prefs_matcher_cancel), NULL);
 483
 484         vbox1 = gtk_vbox_new(FALSE, VSPACING);
 485         gtk_widget_show(vbox1);
 486         gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0);
 487         gtk_container_set_border_width(GTK_CONTAINER (vbox1), 2);
 488
 489         criteria_table = gtk_table_new(2, 4, FALSE);
 490         gtk_widget_show(criteria_table);
 491
 492         gtk_box_pack_start(GTK_BOX(vbox1), criteria_table, FALSE, FALSE, 0);
 493         gtk_table_set_row_spacings(GTK_TABLE(criteria_table), 8);
 494         gtk_table_set_col_spacings(GTK_TABLE(criteria_table), 8);
 495
 496         /* criteria combo box */
 497
 498         criteria_label = gtk_label_new(_("Match type"));
 499         gtk_widget_show(criteria_label);
 500         gtk_misc_set_alignment(GTK_MISC(criteria_label), 0, 0.5);
 501         gtk_table_attach(GTK_TABLE(criteria_table), criteria_label, 0, 1, 0, 1,
 502                          GTK_FILL, 0, 0, 0);
 503
 504         criteria_combo = gtk_combo_new();
 505         gtk_widget_show(criteria_combo);
 506
 507         combo_items = NULL;
 508
 509         for (i = 0; criteria_text[i].text != NULL; i++) {
 510                 if (criteria_text[i].contains_header_name)
 511                         combo_items = g_list_append(combo_items,
 512                                             (gpointer) prefs_common_translated_header_name(criteria_text[i].text));
 513                 else
 514                         combo_items = g_list_append(combo_items,
 515                                             (gpointer) gettext(criteria_text[i].text));
 516         }
 517         gtk_combo_set_popdown_strings(GTK_COMBO(criteria_combo), combo_items);
 518
 519         g_list_free(combo_items);
 520
 521         gtk_widget_set_size_request(criteria_combo, 190, -1);
 522         gtk_table_attach(GTK_TABLE(criteria_table), criteria_combo, 0, 1, 1, 2,
 523                           0, 0, 0, 0);
 524         criteria_list = GTK_COMBO(criteria_combo)->list;
 525         g_signal_connect(G_OBJECT(criteria_list), "select-child",
 526                          G_CALLBACK(prefs_matcher_criteria_select),
 527                          NULL);
 528
 529         gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(criteria_combo)->entry),
 530                                FALSE);
 531
 532         /* header name */
 533
 534         header_label = gtk_label_new(_("Header name"));
 535         gtk_widget_show(header_label);
 536         gtk_misc_set_alignment(GTK_MISC(header_label), 0, 0.5);
 537         gtk_table_attach(GTK_TABLE(criteria_table), header_label, 1, 2, 0, 1,
 538                          GTK_FILL, 0, 0, 0);
 539
 540         header_combo = gtk_combo_new();
 541         gtk_widget_show(header_combo);
 542         gtk_widget_set_size_request(header_combo, 120, -1);
 543         gtkut_combo_set_items(GTK_COMBO (header_combo),
 544                               "Subject", "From", "To", "Cc", "Reply-To",
 545                               "Sender", "X-ML-Name", "X-List", "X-Sequence",
 546                               "X-Mailer","X-BeenThere",
 547                               NULL);
 548         gtk_table_attach(GTK_TABLE(criteria_table), header_combo, 1, 2, 1, 2,
 549                          0, 0, 0, 0);
 550         header_entry = GTK_COMBO(header_combo)->entry;
 551         gtk_entry_set_editable(GTK_ENTRY(header_entry), TRUE);
 552
 553         /* address header name */
 554
 555         header_addr_label = gtk_label_new(_("Address header"));
 556         gtk_misc_set_alignment(GTK_MISC(header_addr_label), 0, 0.5);
 557         gtk_table_attach(GTK_TABLE(criteria_table), header_addr_label, 1, 2, 0, 1,
 558                          GTK_FILL, 0, 0, 0);
 559
 560         header_addr_combo = gtk_combo_new();
 561         gtk_widget_set_size_request(header_addr_combo, 120, -1);
 562         gtkut_combo_set_items(GTK_COMBO (header_addr_combo),
 563                               Q_("Filtering Matcher Menu|All"),
 564                               _("Any"), "From", "To", "Cc", "Reply-To", "Sender",
 565                               NULL);
 566         gtk_table_attach(GTK_TABLE(criteria_table), header_addr_combo, 1, 2, 1, 2,
 567                          0, 0, 0, 0);
 568         header_addr_entry = GTK_COMBO(header_addr_combo)->entry;
 569         gtk_entry_set_editable(GTK_ENTRY(header_addr_entry), TRUE);
 570
 571         /* value */
 572
 573         value_label = gtk_label_new(_("Value"));
 574         gtk_widget_show(value_label);
 575         gtk_misc_set_alignment(GTK_MISC (value_label), 0, 0.5);
 576         gtk_table_attach(GTK_TABLE(criteria_table), value_label, 2, 3, 0, 1,
 577                          GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0, 0);
 578
 579         value_entry = gtk_entry_new();
 580         gtk_widget_show(value_entry);
 581         gtk_widget_set_size_request(value_entry, 200, -1);
 582         gtk_table_attach(GTK_TABLE(criteria_table), value_entry, 2, 3, 1, 2,
 583                          GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0, 0);
 584
 585         /* book/folder value */
 586
 587         addressbook_folder_label = gtk_label_new(_("Book/folder"));
 588         gtk_misc_set_alignment(GTK_MISC (addressbook_folder_label), 0, 0.5);
 589         gtk_table_attach(GTK_TABLE(criteria_table), addressbook_folder_label, 2, 3, 0, 1,
 590                          GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0, 0);
 591
 592         addressbook_folder_combo = gtk_combo_new();
 593         gtk_widget_show(addressbook_folder_combo);
 594         gtk_widget_set_size_request(addressbook_folder_combo, 200, -1);
 595         gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(addressbook_folder_combo)->entry),
 596                                TRUE);
 597
 598         combo_items = NULL;
 599         for (i = 0; i < (gint) (sizeof(addressbook_folder_text) / sizeof(gchar *)); i++) {
 600                 combo_items = g_list_append(combo_items,
 601                                             (gpointer) _(addressbook_folder_text[i]));
 602         }
 603         gtk_combo_set_popdown_strings(GTK_COMBO(addressbook_folder_combo), combo_items);
 604         g_list_free(combo_items);
 605
 606         gtk_table_attach(GTK_TABLE(criteria_table), addressbook_folder_combo, 2, 3, 1, 2,
 607                          GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0, 0);
 608
 609 #if GTK_CHECK_VERSION(2, 8, 0)
 610         test_btn = gtk_button_new_from_stock(GTK_STOCK_INFO);
 611 #else
 612         test_btn = gtk_button_new_with_label(_("Info..."));
 613 #endif
 614         gtk_widget_show(test_btn);
 615         gtk_table_attach(GTK_TABLE (criteria_table), test_btn, 3, 4, 1, 2,
 616                          0, 0, 0, 0);
 617         g_signal_connect(G_OBJECT (test_btn), "clicked",
 618                          G_CALLBACK(prefs_matcher_test_info),
 619                          NULL);
 620
 621         addressbook_select_btn = gtk_button_new_with_label(_("Select ..."));
 622         gtk_table_attach(GTK_TABLE (criteria_table), addressbook_select_btn, 3, 4, 1, 2,
 623                          0, 0, 0, 0);
 624         g_signal_connect(G_OBJECT (addressbook_select_btn), "clicked",
 625                          G_CALLBACK(prefs_matcher_addressbook_select),
 626                          NULL);
 627
 628         color_optmenu = gtk_option_menu_new();
 629         gtk_option_menu_set_menu(GTK_OPTION_MENU(color_optmenu),
 630                                  colorlabel_create_color_menu());
 631
 632         /* predicate */
 633
 634         vbox2 = gtk_vbox_new(FALSE, VSPACING);
 635         gtk_widget_show(vbox2);
 636         gtk_box_pack_start(GTK_BOX(vbox1), vbox2, FALSE, FALSE, 0);
 637
 638         hbox1 = gtk_hbox_new(FALSE, 8);
 639         gtk_widget_show(hbox1);
 640         gtk_box_pack_start(GTK_BOX(vbox2), hbox1, FALSE, FALSE, 0);
 641
 642         predicate_label = gtk_label_new(_("Predicate"));
 643         gtk_widget_show(predicate_label);
 644         gtk_box_pack_start(GTK_BOX(hbox1), predicate_label,
 645                            FALSE, FALSE, 0);
 646
 647         predicate_combo = gtk_combo_new();
 648         gtk_widget_show(predicate_combo);
 649         gtk_widget_set_size_request(predicate_combo, 120, -1);
 650         predicate_list = GTK_COMBO(predicate_combo)->list;
 651         gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(predicate_combo)->entry),
 652                                FALSE);
 653
 654         combo_items = NULL;
 655
 656         for (i = 0; i < (gint) (sizeof(predicate_text) / sizeof(gchar *)); i++) {
 657                 combo_items = g_list_append(combo_items,
 658                                             (gpointer) _(predicate_text[i]));
 659         }
 660         gtk_combo_set_popdown_strings(GTK_COMBO(predicate_combo), combo_items);
 661
 662         g_list_free(combo_items);
 663
 664         gtk_box_pack_start(GTK_BOX(hbox1), predicate_combo,
 665                            FALSE, FALSE, 0);
 666
 667         /* predicate flag */
 668
 669         predicate_flag_combo = gtk_combo_new();
 670         gtk_widget_hide(predicate_flag_combo);
 671         gtk_widget_set_size_request(predicate_flag_combo, 120, -1);
 672         predicate_flag_list = GTK_COMBO(predicate_flag_combo)->list;
 673         gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(predicate_flag_combo)->entry), FALSE);
 674
 675         combo_items = NULL;
 676
 677         for (i = 0; i < (gint) (sizeof(predicate_text) / sizeof(gchar *)); i++) {
 678                 combo_items = g_list_append(combo_items, (gpointer) _(predicate_flag_text[i]));
 679         }
 680         gtk_combo_set_popdown_strings(GTK_COMBO(predicate_flag_combo),
 681                                       combo_items);
 682
 683         g_list_free(combo_items);
 684
 685         gtk_box_pack_start(GTK_BOX(hbox1), predicate_flag_combo,
 686                            FALSE, FALSE, 0);
 687
 688         vbox3 = gtk_vbox_new(FALSE, 0);
 689         gtk_widget_show (vbox3);
 690         gtk_box_pack_start(GTK_BOX(hbox1), vbox3, FALSE, FALSE, 0);
 691
 692         PACK_CHECK_BUTTON(vbox3, case_checkbtn, _("Case sensitive"));
 693         PACK_CHECK_BUTTON(vbox3, regexp_checkbtn, _("Use regexp"));
 694
 695         /* register / substitute / delete */
 696
 697         reg_hbox = gtk_hbox_new(FALSE, 4);
 698         gtk_widget_show(reg_hbox);
 699         gtk_box_pack_start(GTK_BOX(vbox1), reg_hbox, FALSE, FALSE, 0);
 700
 701         arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
 702         gtk_widget_show(arrow);
 703         gtk_box_pack_start(GTK_BOX(reg_hbox), arrow, FALSE, FALSE, 0);
 704         gtk_widget_set_size_request(arrow, -1, 16);
 705
 706         btn_hbox = gtk_hbox_new(FALSE, 4);
 707         gtk_widget_show(btn_hbox);
 708         gtk_box_pack_start(GTK_BOX(reg_hbox), btn_hbox, FALSE, FALSE, 0);
 709
 710         reg_btn = gtk_button_new_from_stock(GTK_STOCK_ADD);
 711         gtk_widget_show(reg_btn);
 712         gtk_box_pack_start(GTK_BOX(btn_hbox), reg_btn, FALSE, TRUE, 0);
 713         g_signal_connect(G_OBJECT(reg_btn), "clicked",
 714                          G_CALLBACK(prefs_matcher_register_cb), NULL);
 715
 716         subst_btn = gtkut_get_replace_btn(_("Replace"));
 717         gtk_widget_show(subst_btn);
 718         gtk_box_pack_start(GTK_BOX(btn_hbox), subst_btn, FALSE, TRUE, 0);
 719         g_signal_connect(G_OBJECT(subst_btn), "clicked",
 720                          G_CALLBACK(prefs_matcher_substitute_cb),
 721                          NULL);
 722
 723         del_btn = gtk_button_new_from_stock(GTK_STOCK_DELETE);
 724         gtk_widget_show(del_btn);
 725         gtk_box_pack_start(GTK_BOX(btn_hbox), del_btn, FALSE, TRUE, 0);
 726         g_signal_connect(G_OBJECT(del_btn), "clicked",
 727                          G_CALLBACK(prefs_matcher_delete_cb), NULL);
 728
 729         /* boolean operation */
 730
 731         bool_op_label = gtk_label_new(_("Boolean Op"));
 732         gtk_misc_set_alignment(GTK_MISC(value_label), 0, 0.5);
 733         gtk_widget_show(bool_op_label);
 734         gtk_box_pack_start(GTK_BOX(btn_hbox), bool_op_label,
 735                            FALSE, FALSE, 0);
 736
 737         bool_op_combo = gtk_combo_new();
 738         gtk_widget_show(bool_op_combo);
 739         gtk_widget_set_size_request(bool_op_combo, 60, -1);
 740         bool_op_list = GTK_COMBO(bool_op_combo)->list;
 741         gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(bool_op_combo)->entry),
 742                                FALSE);
 743
 744         combo_items = NULL;
 745
 746         for (i = 0; i < (gint) (sizeof(bool_op_text) / sizeof(gchar *)); i++) {
 747                 combo_items = g_list_append(combo_items,
 748                                             (gpointer) _(bool_op_text[i]));
 749         }
 750         gtk_combo_set_popdown_strings(GTK_COMBO(bool_op_combo), combo_items);
 751
 752         g_list_free(combo_items);
 753
 754         gtk_box_pack_start(GTK_BOX(btn_hbox), bool_op_combo,
 755                            FALSE, FALSE, 0);
 756
 757         cond_hbox = gtk_hbox_new(FALSE, 8);
 758         gtk_widget_show(cond_hbox);
 759         gtk_box_pack_start(GTK_BOX(vbox1), cond_hbox, TRUE, TRUE, 0);
 760
 761         cond_scrolledwin = gtk_scrolled_window_new(NULL, NULL);
 762         gtk_widget_show(cond_scrolledwin);
 763         gtk_widget_set_size_request(cond_scrolledwin, -1, 150);
 764         gtk_box_pack_start(GTK_BOX(cond_hbox), cond_scrolledwin,
 765                            TRUE, TRUE, 0);
 766         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(cond_scrolledwin),
 767                                        GTK_POLICY_AUTOMATIC,
 768                                        GTK_POLICY_AUTOMATIC);
 769
 770         cond_list_view = prefs_matcher_list_view_create();
 771         gtk_widget_show(cond_list_view);
 772         gtk_container_add(GTK_CONTAINER(cond_scrolledwin), cond_list_view);
 773
 774         btn_vbox = gtk_vbox_new(FALSE, 8);
 775         gtk_widget_show(btn_vbox);
 776         gtk_box_pack_start(GTK_BOX(cond_hbox), btn_vbox, FALSE, FALSE, 0);
 777
 778         up_btn = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
 779         gtk_widget_show(up_btn);
 780         gtk_box_pack_start(GTK_BOX(btn_vbox), up_btn, FALSE, FALSE, 0);
 781         g_signal_connect(G_OBJECT(up_btn), "clicked",
 782                          G_CALLBACK(prefs_matcher_up), NULL);
 783
 784         down_btn = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
 785         gtk_widget_show(down_btn);
 786         gtk_box_pack_start(GTK_BOX(btn_vbox), down_btn, FALSE, FALSE, 0);
 787         g_signal_connect(G_OBJECT(down_btn), "clicked",
 788                          G_CALLBACK(prefs_matcher_down), NULL);
 789
 790         if (!geometry.min_height) {
 791                 geometry.min_width = 520;
 792                 geometry.min_height = 368;
 793         }
 794
 795         gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
 796                                       GDK_HINT_MIN_SIZE);
 797         gtk_widget_set_size_request(window, prefs_common.matcherwin_width,
 798                                     prefs_common.matcherwin_height);
 799
 800         gtk_widget_show_all(window);
 801         gtk_widget_hide(header_addr_label);
 802         gtk_widget_hide(header_addr_combo);
 803         gtk_widget_hide(addressbook_select_btn);
 804         gtk_widget_hide(addressbook_folder_label);
 805
 806         matcher.window    = window;
 807
 808         matcher.ok_btn = ok_btn;
 809
 810         matcher.criteria_list = criteria_list;
 811         matcher.header_combo = header_combo;
 812         matcher.header_entry = header_entry;
 813         matcher.header_label = header_label;
 814         matcher.header_addr_combo = header_addr_combo;
 815         matcher.header_addr_entry = header_addr_entry;
 816         matcher.header_addr_label = header_addr_label;
 817         matcher.value_entry = value_entry;
 818         matcher.value_label = value_label;
 819         matcher.addressbook_folder_label = addressbook_folder_label;
 820         matcher.addressbook_folder_combo = addressbook_folder_combo;
 821         matcher.predicate_label = predicate_label;
 822         matcher.predicate_list = predicate_list;
 823         matcher.predicate_combo = predicate_combo;
 824         matcher.predicate_flag_list = predicate_flag_list;
 825         matcher.predicate_flag_combo = predicate_flag_combo;
 826         matcher.case_checkbtn = case_checkbtn;
 827         matcher.regexp_checkbtn = regexp_checkbtn;
 828         matcher.bool_op_list = bool_op_list;
 829         matcher.test_btn = test_btn;
 830         matcher.addressbook_select_btn = addressbook_select_btn;
 831         matcher.color_optmenu = color_optmenu;
 832         matcher.criteria_table = criteria_table;
 833
 834         matcher.cond_list_view = cond_list_view;
 835
 836         matcher.selected_criteria = -1;
 837         prefs_matcher_criteria_select(GTK_LIST(criteria_list), NULL, NULL);
 838 }
 839
 840 /*!
 841  *\brief        Set the contents of a row
 842  *
 843  *\param        row Index of row to set
 844  *\param        prop Condition to set
 845  *
 846  *\return       gint Row index \a prop has been added
 847  */
 848 static void prefs_matcher_list_view_set_row(GtkTreeIter *row, MatcherProp *prop)
 849 {
 850         gchar *matcher_str;
 851
 852         if (prop == NULL) {
 853                 prefs_matcher_list_view_insert_matcher(matcher.cond_list_view,
 854                                                        NULL, _("(New)"), FALSE);
 855                 return;
 856         }
 857
 858         matcher_str = matcherprop_to_string(prop);
 859         if (!row)
 860                 prefs_matcher_list_view_insert_matcher(matcher.cond_list_view,
 861                                                        NULL, matcher_str,
 862                                                        TRUE);
 863         else
 864                 prefs_matcher_list_view_insert_matcher(matcher.cond_list_view,
 865                                                        row, matcher_str,
 866                                                        TRUE);
 867         g_free(matcher_str);
 868 }
 869
 870 /*!
 871  *\brief        Clears a condition in the list widget
 872  */
 873 static void prefs_matcher_reset_condition(void)
 874 {
 875         gtk_list_select_item(GTK_LIST(matcher.criteria_list), 0);
 876         gtk_list_select_item(GTK_LIST(matcher.predicate_list), 0);
 877         gtk_entry_set_text(GTK_ENTRY(matcher.header_entry), "");
 878         gtk_entry_set_text(GTK_ENTRY(matcher.header_addr_entry), "");
 879         gtk_entry_set_text(GTK_ENTRY(matcher.value_entry), "");
 880         gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(matcher.addressbook_folder_combo)->entry), "");
 881 }
 882
 883 /*!
 884  *\brief        Initializes dialog with a set of conditions
 885  *
 886  *\param        matchers List of conditions
 887  */
 888 static void prefs_matcher_set_dialog(MatcherList *matchers)
 889 {
 890         GSList *cur;
 891         gboolean bool_op = 1;
 892         GtkListStore *store = GTK_LIST_STORE(gtk_tree_view_get_model
 893                                 (GTK_TREE_VIEW(matcher.cond_list_view)));
 894
 895         gtk_list_store_clear(store);
 896
 897         prefs_matcher_list_view_set_row(NULL, NULL);
 898         if (matchers != NULL) {
 899                 for (cur = matchers->matchers; cur != NULL;
 900                      cur = g_slist_next(cur)) {
 901                         MatcherProp *prop;
 902                         prop = (MatcherProp *) cur->data;
 903                         prefs_matcher_list_view_set_row(NULL, prop);
 904                 }
 905
 906                 bool_op = matchers->bool_and;
 907         }
 908
 909         gtk_list_select_item(GTK_LIST(matcher.bool_op_list), bool_op);
 910
 911         prefs_matcher_reset_condition();
 912 }
 913
 914 /*!
 915  *\brief        Converts current conditions in list box in
 916  *              a matcher list used by the matcher.
 917  *
 918  *\return       MatcherList * List of conditions.
 919  */
 920 static MatcherList *prefs_matcher_get_list(void)
 921 {
 922         gchar *matcher_str;
 923         MatcherProp *prop;
 924         gboolean bool_and;
 925         GSList *matcher_list;
 926         MatcherList *matchers;
 927         GtkTreeModel *model;
 928         GtkTreeIter iter;
 929
 930         model = gtk_tree_view_get_model(GTK_TREE_VIEW(matcher.cond_list_view));
 931         if (!gtk_tree_model_get_iter_first(model, &iter))
 932                 return NULL;
 933
 934         matcher_list = NULL;
 935
 936         do {
 937                 gboolean is_valid;
 938
 939                 gtk_tree_model_get(model, &iter,
 940                                    PREFS_MATCHER_COND, &matcher_str,
 941                                    PREFS_MATCHER_COND_VALID, &is_valid,
 942                                    -1);
 943
 944                 if (is_valid) {
 945                         /* tmp = matcher_str; */
 946                         prop = matcher_parser_get_prop(matcher_str);
 947                         g_free(matcher_str);
 948                         if (prop == NULL)
 949                                 break;
 950
 951                         matcher_list = g_slist_append(matcher_list, prop);
 952                 }
 953         } while (gtk_tree_model_iter_next(model, &iter));
 954
 955         bool_and = get_sel_from_list(GTK_LIST(matcher.bool_op_list));
 956
 957         matchers = matcherlist_new(matcher_list, bool_and);
 958
 959         return matchers;
 960 }
 961
 962 /*!
 963  *\brief        Maps a keyword id (see #get_matchparser_tab_id) to a
 964  *              criteria type (see first parameter of #matcherprop_new
 965  *              or #matcherprop_unquote_new)
 966  *
 967  *\param        matching_id Id returned by the matcher parser.
 968  *
 969  *\return       gint One of the CRITERIA_xxx constants.
 970  */
 971 static gint prefs_matcher_get_criteria_from_matching(gint matching_id)
 972 {
 973         switch(matching_id) {
 974         case MATCHCRITERIA_ALL:
 975                 return CRITERIA_ALL;
 976         case MATCHCRITERIA_NOT_UNREAD:
 977         case MATCHCRITERIA_UNREAD:
 978                 return CRITERIA_UNREAD;
 979         case MATCHCRITERIA_NOT_NEW:
 980         case MATCHCRITERIA_NEW:
 981                 return CRITERIA_NEW;
 982         case MATCHCRITERIA_NOT_MARKED:
 983         case MATCHCRITERIA_MARKED:
 984                 return CRITERIA_MARKED;
 985         case MATCHCRITERIA_NOT_DELETED:
 986         case MATCHCRITERIA_DELETED:
 987                 return CRITERIA_DELETED;
 988         case MATCHCRITERIA_NOT_REPLIED:
 989         case MATCHCRITERIA_REPLIED:
 990                 return CRITERIA_REPLIED;
 991         case MATCHCRITERIA_NOT_FORWARDED:
 992         case MATCHCRITERIA_FORWARDED:
 993                 return CRITERIA_FORWARDED;
 994         case MATCHCRITERIA_LOCKED:
 995         case MATCHCRITERIA_NOT_LOCKED:
 996                 return CRITERIA_LOCKED;
 997         case MATCHCRITERIA_NOT_SPAM:
 998         case MATCHCRITERIA_SPAM:
 999                 return CRITERIA_SPAM;
1000         case MATCHCRITERIA_PARTIAL:
1001         case MATCHCRITERIA_NOT_PARTIAL:
1002                 return CRITERIA_PARTIAL;
1003         case MATCHCRITERIA_COLORLABEL:
1004         case MATCHCRITERIA_NOT_COLORLABEL:
1005                 return CRITERIA_COLORLABEL;
1006         case MATCHCRITERIA_IGNORE_THREAD:
1007         case MATCHCRITERIA_NOT_IGNORE_THREAD:
1008                 return CRITERIA_IGNORE_THREAD;
1009         case MATCHCRITERIA_WATCH_THREAD:
1010         case MATCHCRITERIA_NOT_WATCH_THREAD:
1011                 return CRITERIA_WATCH_THREAD;
1012         case MATCHCRITERIA_NOT_SUBJECT:
1013         case MATCHCRITERIA_SUBJECT:
1014                 return CRITERIA_SUBJECT;
1015         case MATCHCRITERIA_NOT_FROM:
1016         case MATCHCRITERIA_FROM:
1017                 return CRITERIA_FROM;
1018         case MATCHCRITERIA_NOT_TO:
1019         case MATCHCRITERIA_TO:
1020                 return CRITERIA_TO;
1021         case MATCHCRITERIA_NOT_CC:
1022         case MATCHCRITERIA_CC:
1023                 return CRITERIA_CC;
1024         case MATCHCRITERIA_NOT_NEWSGROUPS:
1025         case MATCHCRITERIA_NEWSGROUPS:
1026                 return CRITERIA_NEWSGROUPS;
1027         case MATCHCRITERIA_NOT_INREPLYTO:
1028         case MATCHCRITERIA_INREPLYTO:
1029                 return CRITERIA_INREPLYTO;
1030         case MATCHCRITERIA_NOT_REFERENCES:
1031         case MATCHCRITERIA_REFERENCES:
1032                 return CRITERIA_REFERENCES;
1033         case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
1034         case MATCHCRITERIA_TO_OR_CC:
1035                 return CRITERIA_TO_OR_CC;
1036         case MATCHCRITERIA_NOT_TAG:
1037         case MATCHCRITERIA_TAG:
1038                 return CRITERIA_TAG;
1039         case MATCHCRITERIA_NOT_TAGGED:
1040         case MATCHCRITERIA_TAGGED:
1041                 return CRITERIA_TAGGED;
1042         case MATCHCRITERIA_NOT_BODY_PART:
1043         case MATCHCRITERIA_BODY_PART:
1044                 return CRITERIA_BODY_PART;
1045         case MATCHCRITERIA_NOT_MESSAGE:
1046         case MATCHCRITERIA_MESSAGE:
1047                 return CRITERIA_MESSAGE;
1048         case MATCHCRITERIA_NOT_HEADERS_PART:
1049         case MATCHCRITERIA_HEADERS_PART:
1050                 return CRITERIA_HEADERS_PART;
1051         case MATCHCRITERIA_NOT_HEADER:
1052         case MATCHCRITERIA_HEADER:
1053                 return CRITERIA_HEADER;
1054         case MATCHCRITERIA_AGE_GREATER:
1055                 return CRITERIA_AGE_GREATER;
1056         case MATCHCRITERIA_AGE_LOWER:
1057                 return CRITERIA_AGE_LOWER;
1058         case MATCHCRITERIA_SCORE_GREATER:
1059                 return CRITERIA_SCORE_GREATER;
1060         case MATCHCRITERIA_SCORE_LOWER:
1061                 return CRITERIA_SCORE_LOWER;
1062         case MATCHCRITERIA_SCORE_EQUAL:
1063                 return CRITERIA_SCORE_EQUAL;
1064         case MATCHCRITERIA_NOT_TEST:
1065         case MATCHCRITERIA_TEST:
1066                 return CRITERIA_TEST;
1067         case MATCHCRITERIA_SIZE_GREATER:
1068                 return CRITERIA_SIZE_GREATER;
1069         case MATCHCRITERIA_SIZE_SMALLER:
1070                 return CRITERIA_SIZE_SMALLER;
1071         case MATCHCRITERIA_SIZE_EQUAL:
1072                 return CRITERIA_SIZE_EQUAL;
1073         case MATCHCRITERIA_FOUND_IN_ADDRESSBOOK:
1074         case MATCHCRITERIA_NOT_FOUND_IN_ADDRESSBOOK:
1075                 return CRITERIA_FOUND_IN_ADDRESSBOOK;
1076         default:
1077                 return -1;
1078         }
1079 }
1080
1081 /*!
1082  *\brief        Returns the matcher keyword id from a criteria id
1083  *
1084  *\param        criteria_id Criteria id (should not be the negate
1085  *              one)
1086  *
1087  *\return       gint A matcher keyword id. See #get_matchparser_tab_id.
1088  */
1089 static gint prefs_matcher_get_matching_from_criteria(gint criteria_id)
1090 {
1091         switch (criteria_id) {
1092         case CRITERIA_ALL:
1093                 return MATCHCRITERIA_ALL;
1094         case CRITERIA_UNREAD:
1095                 return MATCHCRITERIA_UNREAD;
1096         case CRITERIA_NEW:
1097                 return MATCHCRITERIA_NEW;
1098         case CRITERIA_MARKED:
1099                 return MATCHCRITERIA_MARKED;
1100         case CRITERIA_DELETED:
1101                 return MATCHCRITERIA_DELETED;
1102         case CRITERIA_REPLIED:
1103                 return MATCHCRITERIA_REPLIED;
1104         case CRITERIA_FORWARDED:
1105                 return MATCHCRITERIA_FORWARDED;
1106         case CRITERIA_LOCKED:
1107                 return MATCHCRITERIA_LOCKED;
1108         case CRITERIA_SPAM:
1109                 return MATCHCRITERIA_SPAM;
1110         case CRITERIA_PARTIAL:
1111                 return MATCHCRITERIA_PARTIAL;
1112         case CRITERIA_COLORLABEL:
1113                 return MATCHCRITERIA_COLORLABEL;
1114         case CRITERIA_IGNORE_THREAD:
1115                 return MATCHCRITERIA_IGNORE_THREAD;
1116         case CRITERIA_WATCH_THREAD:
1117                 return MATCHCRITERIA_WATCH_THREAD;
1118         case CRITERIA_SUBJECT:
1119                 return MATCHCRITERIA_SUBJECT;
1120         case CRITERIA_FROM:
1121                 return MATCHCRITERIA_FROM;
1122         case CRITERIA_TO:
1123                 return MATCHCRITERIA_TO;
1124         case CRITERIA_CC:
1125                 return MATCHCRITERIA_CC;
1126         case CRITERIA_TO_OR_CC:
1127                 return MATCHCRITERIA_TO_OR_CC;
1128         case CRITERIA_TAG:
1129                 return MATCHCRITERIA_TAG;
1130         case CRITERIA_TAGGED:
1131                 return MATCHCRITERIA_TAGGED;
1132         case CRITERIA_NEWSGROUPS:
1133                 return MATCHCRITERIA_NEWSGROUPS;
1134         case CRITERIA_INREPLYTO:
1135                 return MATCHCRITERIA_INREPLYTO;
1136         case CRITERIA_REFERENCES:
1137                 return MATCHCRITERIA_REFERENCES;
1138         case CRITERIA_AGE_GREATER:
1139                 return MATCHCRITERIA_AGE_GREATER;
1140         case CRITERIA_AGE_LOWER:
1141                 return MATCHCRITERIA_AGE_LOWER;
1142         case CRITERIA_SCORE_GREATER:
1143                 return MATCHCRITERIA_SCORE_GREATER;
1144         case CRITERIA_SCORE_LOWER:
1145                 return MATCHCRITERIA_SCORE_LOWER;
1146         case CRITERIA_SCORE_EQUAL:
1147                 return MATCHCRITERIA_SCORE_EQUAL;
1148         case CRITERIA_HEADER:
1149                 return MATCHCRITERIA_HEADER;
1150         case CRITERIA_HEADERS_PART:
1151                 return MATCHCRITERIA_HEADERS_PART;
1152         case CRITERIA_BODY_PART:
1153                 return MATCHCRITERIA_BODY_PART;
1154         case CRITERIA_MESSAGE:
1155                 return MATCHCRITERIA_MESSAGE;
1156         case CRITERIA_TEST:
1157                 return MATCHCRITERIA_TEST;
1158         case CRITERIA_SIZE_GREATER:
1159                 return MATCHCRITERIA_SIZE_GREATER;
1160         case CRITERIA_SIZE_SMALLER:
1161                 return MATCHCRITERIA_SIZE_SMALLER;
1162         case CRITERIA_SIZE_EQUAL:
1163                 return MATCHCRITERIA_SIZE_EQUAL;
1164         case CRITERIA_FOUND_IN_ADDRESSBOOK:
1165                 return MATCHCRITERIA_FOUND_IN_ADDRESSBOOK;
1166         default:
1167                 return -1;
1168         }
1169 }
1170
1171 /*!
1172  *\brief        Returns the negate matcher keyword id from a matcher keyword
1173  *              id.
1174  *
1175  *\param        matcher_criteria Matcher keyword id.
1176  *
1177  *\return       gint A matcher keyword id. See #get_matchparser_tab_id.
1178  */
1179 static gint prefs_matcher_not_criteria(gint matcher_criteria)
1180 {
1181         switch(matcher_criteria) {
1182         case MATCHCRITERIA_UNREAD:
1183                 return MATCHCRITERIA_NOT_UNREAD;
1184         case MATCHCRITERIA_NEW:
1185                 return MATCHCRITERIA_NOT_NEW;
1186         case MATCHCRITERIA_MARKED:
1187                 return MATCHCRITERIA_NOT_MARKED;
1188         case MATCHCRITERIA_DELETED:
1189                 return MATCHCRITERIA_NOT_DELETED;
1190         case MATCHCRITERIA_REPLIED:
1191                 return MATCHCRITERIA_NOT_REPLIED;
1192         case MATCHCRITERIA_FORWARDED:
1193                 return MATCHCRITERIA_NOT_FORWARDED;
1194         case MATCHCRITERIA_LOCKED:
1195                 return MATCHCRITERIA_NOT_LOCKED;
1196         case MATCHCRITERIA_SPAM:
1197                 return MATCHCRITERIA_NOT_SPAM;
1198         case MATCHCRITERIA_PARTIAL:
1199                 return MATCHCRITERIA_NOT_PARTIAL;
1200         case MATCHCRITERIA_COLORLABEL:
1201                 return MATCHCRITERIA_NOT_COLORLABEL;
1202         case MATCHCRITERIA_IGNORE_THREAD:
1203                 return MATCHCRITERIA_NOT_IGNORE_THREAD;
1204         case MATCHCRITERIA_WATCH_THREAD:
1205                 return MATCHCRITERIA_NOT_WATCH_THREAD;
1206         case MATCHCRITERIA_SUBJECT:
1207                 return MATCHCRITERIA_NOT_SUBJECT;
1208         case MATCHCRITERIA_FROM:
1209                 return MATCHCRITERIA_NOT_FROM;
1210         case MATCHCRITERIA_TO:
1211                 return MATCHCRITERIA_NOT_TO;
1212         case MATCHCRITERIA_CC:
1213                 return MATCHCRITERIA_NOT_CC;
1214         case MATCHCRITERIA_TO_OR_CC:
1215                 return MATCHCRITERIA_NOT_TO_AND_NOT_CC;
1216         case MATCHCRITERIA_TAG:
1217                 return MATCHCRITERIA_NOT_TAG;
1218         case MATCHCRITERIA_TAGGED:
1219                 return MATCHCRITERIA_NOT_TAGGED;
1220         case MATCHCRITERIA_NEWSGROUPS:
1221                 return MATCHCRITERIA_NOT_NEWSGROUPS;
1222         case MATCHCRITERIA_INREPLYTO:
1223                 return MATCHCRITERIA_NOT_INREPLYTO;
1224         case MATCHCRITERIA_REFERENCES:
1225                 return MATCHCRITERIA_NOT_REFERENCES;
1226         case MATCHCRITERIA_HEADER:
1227                 return MATCHCRITERIA_NOT_HEADER;
1228         case MATCHCRITERIA_HEADERS_PART:
1229                 return MATCHCRITERIA_NOT_HEADERS_PART;
1230         case MATCHCRITERIA_MESSAGE:
1231                 return MATCHCRITERIA_NOT_MESSAGE;
1232         case MATCHCRITERIA_TEST:
1233                 return MATCHCRITERIA_NOT_TEST;
1234         case MATCHCRITERIA_BODY_PART:
1235                 return MATCHCRITERIA_NOT_BODY_PART;
1236         case MATCHCRITERIA_FOUND_IN_ADDRESSBOOK:
1237                 return MATCHCRITERIA_NOT_FOUND_IN_ADDRESSBOOK;
1238         default:
1239                 return matcher_criteria;
1240         }
1241 }
1242
1243 /*!
1244  *\brief        Converts the text in the selected row to a
1245  *              matcher structure
1246  *
1247  *\return       MatcherProp * Newly allocated matcher structure.
1248  */
1249 static MatcherProp *prefs_matcher_dialog_to_matcher(void)
1250 {
1251         MatcherProp *matcherprop;
1252         gint criteria;
1253         gint matchtype;
1254         gint value_pred;
1255         gint value_pred_flag;
1256         gint value_criteria;
1257         gboolean use_regexp;
1258         gboolean case_sensitive;
1259         const gchar *header;
1260         const gchar *expr;
1261         gint value;
1262         const gchar *value_str;
1263
1264         value_criteria = get_sel_from_list(GTK_LIST(matcher.criteria_list));
1265
1266         criteria = prefs_matcher_get_matching_from_criteria(value_criteria);
1267
1268         value_pred = get_sel_from_list(GTK_LIST(matcher.predicate_list));
1269         value_pred_flag = get_sel_from_list(GTK_LIST(matcher.predicate_flag_list));
1270
1271         use_regexp = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(matcher.regexp_checkbtn));
1272         case_sensitive = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(matcher.case_checkbtn));
1273
1274         switch (value_criteria) {
1275         case CRITERIA_UNREAD:
1276         case CRITERIA_NEW:
1277         case CRITERIA_MARKED:
1278         case CRITERIA_DELETED:
1279         case CRITERIA_REPLIED:
1280         case CRITERIA_FORWARDED:
1281         case CRITERIA_LOCKED:
1282         case CRITERIA_SPAM:
1283         case CRITERIA_PARTIAL:
1284         case CRITERIA_TEST:
1285         case CRITERIA_COLORLABEL:
1286         case CRITERIA_IGNORE_THREAD:
1287         case CRITERIA_WATCH_THREAD:
1288         case CRITERIA_FOUND_IN_ADDRESSBOOK:
1289         case CRITERIA_TAGGED:
1290                 if (value_pred_flag == PREDICATE_FLAG_DISABLED)
1291                         criteria = prefs_matcher_not_criteria(criteria);
1292                 break;
1293         case CRITERIA_SUBJECT:
1294         case CRITERIA_FROM:
1295         case CRITERIA_TO:
1296         case CRITERIA_CC:
1297         case CRITERIA_TO_OR_CC:
1298         case CRITERIA_TAG:
1299         case CRITERIA_NEWSGROUPS:
1300         case CRITERIA_INREPLYTO:
1301         case CRITERIA_REFERENCES:
1302         case CRITERIA_HEADERS_PART:
1303         case CRITERIA_BODY_PART:
1304         case CRITERIA_MESSAGE:
1305         case CRITERIA_AGE_GREATER:
1306         case CRITERIA_AGE_LOWER:
1307         case CRITERIA_HEADER:
1308                 if (value_pred == PREDICATE_DOES_NOT_CONTAIN)
1309                         criteria = prefs_matcher_not_criteria(criteria);
1310                 break;
1311         }
1312
1313         if (use_regexp) {
1314                 if (case_sensitive)
1315                         matchtype = MATCHTYPE_REGEXP;
1316                 else
1317                         matchtype = MATCHTYPE_REGEXPCASE;
1318         }
1319         else {
1320                 if (case_sensitive)
1321                         matchtype = MATCHTYPE_MATCH;
1322                 else
1323                         matchtype = MATCHTYPE_MATCHCASE;
1324         }
1325
1326         header = NULL;
1327         expr = NULL;
1328         value = 0;
1329
1330         switch (value_criteria) {
1331         case CRITERIA_ALL:
1332         case CRITERIA_UNREAD:
1333         case CRITERIA_NEW:
1334         case CRITERIA_MARKED:
1335         case CRITERIA_DELETED:
1336         case CRITERIA_REPLIED:
1337         case CRITERIA_FORWARDED:
1338         case CRITERIA_LOCKED:
1339         case CRITERIA_SPAM:
1340         case CRITERIA_PARTIAL:
1341         case CRITERIA_IGNORE_THREAD:
1342         case CRITERIA_WATCH_THREAD:
1343         case CRITERIA_TAGGED:
1344                 break;
1345
1346         case CRITERIA_SUBJECT:
1347         case CRITERIA_FROM:
1348         case CRITERIA_TO:
1349         case CRITERIA_CC:
1350         case CRITERIA_TO_OR_CC:
1351         case CRITERIA_TAG:
1352         case CRITERIA_NEWSGROUPS:
1353         case CRITERIA_INREPLYTO:
1354         case CRITERIA_REFERENCES:
1355         case CRITERIA_HEADERS_PART:
1356         case CRITERIA_BODY_PART:
1357         case CRITERIA_MESSAGE:
1358         case CRITERIA_TEST:
1359                 expr = gtk_entry_get_text(GTK_ENTRY(matcher.value_entry));
1360                 break;
1361
1362         case CRITERIA_AGE_GREATER:
1363         case CRITERIA_AGE_LOWER:
1364         case CRITERIA_SCORE_GREATER:
1365         case CRITERIA_SCORE_LOWER:
1366         case CRITERIA_SCORE_EQUAL:
1367         case CRITERIA_SIZE_GREATER:
1368         case CRITERIA_SIZE_SMALLER:
1369         case CRITERIA_SIZE_EQUAL:
1370                 value_str = gtk_entry_get_text(GTK_ENTRY(matcher.value_entry));
1371
1372                 if (*value_str == '\0') {
1373                     alertpanel_error(_("Value is not set."));
1374                     return NULL;
1375                 }
1376
1377                 value = atoi(value_str);
1378                 break;
1379
1380         case CRITERIA_COLORLABEL:
1381                 value = colorlabel_get_color_menu_active_item
1382                         (gtk_option_menu_get_menu(GTK_OPTION_MENU
1383                                 (matcher.color_optmenu)));
1384                 break;
1385
1386         case CRITERIA_HEADER:
1387                 header = gtk_entry_get_text(GTK_ENTRY(matcher.header_entry));
1388                 expr = gtk_entry_get_text(GTK_ENTRY(matcher.value_entry));
1389
1390                 if (*header == '\0') {
1391                     alertpanel_error(_("Header name is not set."));
1392                     return NULL;
1393                 }
1394                 break;
1395
1396         case CRITERIA_FOUND_IN_ADDRESSBOOK:
1397                 header = gtk_entry_get_text(GTK_ENTRY(matcher.header_addr_entry));
1398                 expr = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(matcher.addressbook_folder_combo)->entry));
1399
1400                 if (*header == '\0') {
1401                     alertpanel_error(_("Header name is not set."));
1402                     return NULL;
1403                 }
1404                 if (*expr == '\0') {
1405                         gchar *tmp;
1406
1407                         if (strcasecmp(header, Q_("Filtering Matcher Menu|All")) == 0)
1408                                 tmp = g_strdup(_("all addresses in all headers"));
1409                         else
1410                         if (strcasecmp(header, _("Any")) == 0)
1411                                 tmp = g_strdup(_("any address in any header"));
1412                         else
1413                                 tmp = g_strdup_printf(_("the address(es) in header '%s'"), header);
1414                         alertpanel_error(_("Book/folder path is not set.\n\n"
1415                                                 "If you want to match %s against the whole address book, "
1416                                                 "you have to select 'Any' from the book/folder drop-down list."),
1417                                                 tmp);
1418                         g_free(tmp);
1419                     return NULL;
1420                 }
1421                 /* don't store translated "Any"/"All" in matcher expressions */
1422                 if (strcasecmp(header, Q_("Filtering Matcher Menu|All")) == 0)
1423                         header = "All";
1424                 else
1425                         if (strcasecmp(header, _("Any")) == 0)
1426                                 header = "Any";
1427                 if (strcasecmp(expr, _("Any")) == 0)
1428                         expr = "Any";
1429                 break;
1430         }
1431
1432         matcherprop = matcherprop_new(criteria, header, matchtype,
1433                                       expr, value);
1434
1435         return matcherprop;
1436 }
1437
1438 /*!
1439  *\brief        Signal handler for register button
1440  */
1441 static void prefs_matcher_register_cb(void)
1442 {
1443         MatcherProp *matcherprop;
1444
1445         matcherprop = prefs_matcher_dialog_to_matcher();
1446         if (matcherprop == NULL)
1447                 return;
1448
1449         prefs_matcher_list_view_set_row(NULL, matcherprop);
1450
1451         matcherprop_free(matcherprop);
1452
1453         prefs_matcher_reset_condition();
1454 }
1455
1456 /*!
1457  *\brief        Signal handler for substitute button
1458  */
1459 static void prefs_matcher_substitute_cb(void)
1460 {
1461         MatcherProp *matcherprop;
1462         GtkTreeIter row;
1463         GtkTreeSelection *selection;
1464         GtkTreeModel *model;
1465         gboolean is_valid;
1466
1467         selection = gtk_tree_view_get_selection
1468                         (GTK_TREE_VIEW(matcher.cond_list_view));
1469
1470         if (!gtk_tree_selection_get_selected(selection, &model, &row))
1471                 return;
1472
1473         gtk_tree_model_get(model, &row,
1474                            PREFS_MATCHER_COND_VALID, &is_valid,
1475                            -1);
1476         if (!is_valid)
1477                 return;
1478
1479         matcherprop = prefs_matcher_dialog_to_matcher();
1480         if (matcherprop == NULL)
1481                 return;
1482
1483         prefs_matcher_list_view_set_row(&row, matcherprop);
1484
1485         matcherprop_free(matcherprop);
1486
1487         prefs_matcher_reset_condition();
1488 }
1489
1490 /*!
1491  *\brief        Signal handler for delete button
1492  */
1493 static void prefs_matcher_delete_cb(void)
1494 {
1495         GtkTreeIter row;
1496         GtkTreeSelection *selection;
1497         GtkTreeModel *model;
1498         gboolean is_valid;
1499
1500         selection = gtk_tree_view_get_selection
1501                         (GTK_TREE_VIEW(matcher.cond_list_view));
1502
1503         if (!gtk_tree_selection_get_selected(selection, &model, &row))
1504                 return;
1505
1506         gtk_tree_model_get(model, &row,
1507                            PREFS_MATCHER_COND_VALID, &is_valid,
1508                            -1);
1509
1510         if (!is_valid)
1511                 return;
1512
1513         gtk_list_store_remove(GTK_LIST_STORE(model), &row);
1514
1515         prefs_matcher_reset_condition();
1516 }
1517
1518 /*!
1519  *\brief        Signal handler for 'move up' button
1520  */
1521 static void prefs_matcher_up(void)
1522 {
1523         GtkTreePath *prev, *sel, *try;
1524         GtkTreeIter isel;
1525         GtkListStore *store = NULL;
1526         GtkTreeModel *model = NULL;
1527         GtkTreeIter iprev;
1528
1529         if (!gtk_tree_selection_get_selected
1530                 (gtk_tree_view_get_selection
1531                         (GTK_TREE_VIEW(matcher.cond_list_view)),
1532                  &model,
1533                  &isel))
1534                 return;
1535         store = (GtkListStore *)model;
1536         sel = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &isel);
1537         if (!sel)
1538                 return;
1539
1540         /* no move if we're at row 0 or 1, looks phony, but other
1541          * solutions are more convoluted... */
1542         try = gtk_tree_path_copy(sel);
1543         if (!gtk_tree_path_prev(try) || !gtk_tree_path_prev(try)) {
1544                 gtk_tree_path_free(try);
1545                 gtk_tree_path_free(sel);
1546                 return;
1547         }
1548         gtk_tree_path_free(try);
1549
1550         prev = gtk_tree_path_copy(sel);
1551         if (gtk_tree_path_prev(prev)) {
1552                 gtk_tree_model_get_iter(GTK_TREE_MODEL(store),
1553                                         &iprev, prev);
1554                 gtk_list_store_swap(store, &iprev, &isel);
1555                 /* XXX: GTK2 select row?? */
1556         }
1557
1558         gtk_tree_path_free(sel);
1559         gtk_tree_path_free(prev);
1560 }
1561
1562 /*!
1563  *\brief        Signal handler for 'move down' button
1564  */
1565 static void prefs_matcher_down(void)
1566 {
1567         GtkListStore *store = NULL;
1568         GtkTreeModel *model = NULL;
1569         GtkTreeIter next, sel;
1570         GtkTreePath *try;
1571
1572         if (!gtk_tree_selection_get_selected
1573                 (gtk_tree_view_get_selection
1574                         (GTK_TREE_VIEW(matcher.cond_list_view)),
1575                  &model,
1576                  &sel))
1577                 return;
1578         store = (GtkListStore *)model;
1579         try = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &sel);
1580         if (!try)
1581                 return;
1582
1583         /* move when not at row 0 ... */
1584         if (gtk_tree_path_prev(try)) {
1585                 next = sel;
1586                 if (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &next))
1587                         gtk_list_store_swap(store, &next, &sel);
1588         }
1589
1590         gtk_tree_path_free(try);
1591 }
1592
1593 /*!
1594  *\brief        Helper function that allows us to replace the 'Value' entry box
1595  *              by another widget.
1596  *
1597  *\param        old_widget Widget that needs to be removed.
1598  *\param        new_widget Replacement widget
1599  */
1600 static void prefs_matcher_set_value_widget(GtkWidget *old_widget,
1601                                            GtkWidget *new_widget)
1602 {
1603         /* TODO: find out why the following spews harmless "parent errors" */
1604
1605         /* NOTE: we first need to bump up the refcount of the old_widget,
1606          * because the gtkut_container_remove() will otherwise destroy it */
1607         gtk_widget_ref(old_widget);
1608         gtkut_container_remove(GTK_CONTAINER(matcher.criteria_table), old_widget);
1609         gtk_widget_show(new_widget);
1610         gtk_widget_set_size_request(new_widget, 200, -1);
1611         gtk_table_attach(GTK_TABLE(matcher.criteria_table), new_widget,
1612                          2, 3, 1, 2,
1613                          GTK_FILL | GTK_SHRINK | GTK_EXPAND,
1614                          0, 0, 0);
1615 }
1616
1617 static void prefs_matcher_disable_widget(GtkWidget* widget)
1618 {
1619         g_return_if_fail( widget != NULL);
1620
1621         gtk_widget_set_sensitive(widget, FALSE);
1622         gtk_widget_hide(widget);
1623 }
1624
1625 static void prefs_matcher_enable_widget(GtkWidget* widget)
1626 {
1627         g_return_if_fail( widget != NULL);
1628
1629         gtk_widget_set_sensitive(widget, TRUE);
1630         gtk_widget_show(widget);
1631 }
1632
1633 /*!
1634  *\brief        Change widgets depending on the selected condition
1635  *
1636  *\param        list List widget
1637  *\param        widget Not used
1638  *\param        user_data Not used
1639  */
1640 static void prefs_matcher_criteria_select(GtkList *list,
1641                                           GtkWidget *widget,
1642                                           gpointer user_data)
1643 {
1644         gint value, old_value;
1645
1646         old_value = matcher.selected_criteria;
1647         matcher.selected_criteria = value = get_sel_from_list
1648                 (GTK_LIST(matcher.criteria_list));
1649
1650         if (old_value == matcher.selected_criteria)
1651                 return;
1652
1653         /* CLAWS: the value widget is currently either the color label combo box,
1654          * or a GtkEntry, so kiss for now */
1655         if (matcher.selected_criteria == CRITERIA_COLORLABEL) {
1656                 prefs_matcher_set_value_widget(matcher.value_entry,
1657                                                matcher.color_optmenu);
1658         } else if (old_value == CRITERIA_COLORLABEL) {
1659                 prefs_matcher_set_value_widget(matcher.color_optmenu,
1660                                                matcher.value_entry);
1661         }
1662
1663         switch (value) {
1664         case CRITERIA_ALL:
1665                 prefs_matcher_disable_widget(matcher.header_combo);
1666                 prefs_matcher_disable_widget(matcher.header_label);
1667                 prefs_matcher_disable_widget(matcher.header_addr_combo);
1668                 prefs_matcher_disable_widget(matcher.header_addr_label);
1669                 prefs_matcher_disable_widget(matcher.value_label);
1670                 prefs_matcher_disable_widget(matcher.value_entry);
1671                 prefs_matcher_disable_widget(matcher.addressbook_folder_label);
1672                 prefs_matcher_disable_widget(matcher.addressbook_folder_combo);
1673                 prefs_matcher_disable_widget(matcher.predicate_label);
1674                 prefs_matcher_disable_widget(matcher.predicate_combo);
1675                 prefs_matcher_disable_widget(matcher.predicate_flag_combo);
1676                 prefs_matcher_disable_widget(matcher.case_checkbtn);
1677                 prefs_matcher_disable_widget(matcher.regexp_checkbtn);
1678                 prefs_matcher_disable_widget(matcher.test_btn);
1679                 prefs_matcher_disable_widget(matcher.addressbook_select_btn);
1680                 break;
1681
1682         case CRITERIA_UNREAD:
1683         case CRITERIA_NEW:
1684         case CRITERIA_MARKED:
1685         case CRITERIA_DELETED:
1686         case CRITERIA_REPLIED:
1687         case CRITERIA_FORWARDED:
1688         case CRITERIA_LOCKED:
1689         case CRITERIA_SPAM:
1690         case CRITERIA_PARTIAL:
1691         case CRITERIA_IGNORE_THREAD:
1692         case CRITERIA_WATCH_THREAD:
1693         case CRITERIA_TAGGED:
1694                 prefs_matcher_disable_widget(matcher.header_combo);
1695                 prefs_matcher_disable_widget(matcher.header_label);
1696                 prefs_matcher_disable_widget(matcher.header_addr_combo);
1697                 prefs_matcher_disable_widget(matcher.header_addr_label);
1698                 prefs_matcher_disable_widget(matcher.value_label);
1699                 prefs_matcher_disable_widget(matcher.value_entry);
1700                 prefs_matcher_disable_widget(matcher.addressbook_folder_label);
1701                 prefs_matcher_disable_widget(matcher.addressbook_folder_combo);
1702                 prefs_matcher_enable_widget(matcher.predicate_label);
1703                 prefs_matcher_disable_widget(matcher.predicate_combo);
1704                 prefs_matcher_enable_widget(matcher.predicate_flag_combo);
1705                 prefs_matcher_disable_widget(matcher.case_checkbtn);
1706                 prefs_matcher_disable_widget(matcher.regexp_checkbtn);
1707                 prefs_matcher_disable_widget(matcher.test_btn);
1708                 prefs_matcher_disable_widget(matcher.addressbook_select_btn);
1709                 break;
1710
1711         case CRITERIA_COLORLABEL:
1712                 prefs_matcher_disable_widget(matcher.header_combo);
1713                 prefs_matcher_disable_widget(matcher.header_label);
1714                 prefs_matcher_disable_widget(matcher.header_addr_combo);
1715                 prefs_matcher_disable_widget(matcher.header_addr_label);
1716                 prefs_matcher_enable_widget(matcher.value_label);
1717                 prefs_matcher_disable_widget(matcher.value_entry);
1718                 prefs_matcher_disable_widget(matcher.addressbook_folder_label);
1719                 prefs_matcher_disable_widget(matcher.addressbook_folder_combo);
1720                 prefs_matcher_enable_widget(matcher.predicate_label);
1721                 prefs_matcher_disable_widget(matcher.predicate_combo);
1722                 prefs_matcher_enable_widget(matcher.predicate_flag_combo);
1723                 prefs_matcher_disable_widget(matcher.case_checkbtn);
1724                 prefs_matcher_disable_widget(matcher.regexp_checkbtn);
1725                 prefs_matcher_disable_widget(matcher.test_btn);
1726                 prefs_matcher_disable_widget(matcher.addressbook_select_btn);
1727                 break;
1728
1729         case CRITERIA_SUBJECT:
1730         case CRITERIA_FROM:
1731         case CRITERIA_TO:
1732         case CRITERIA_CC:
1733         case CRITERIA_TO_OR_CC:
1734         case CRITERIA_TAG:
1735         case CRITERIA_NEWSGROUPS:
1736         case CRITERIA_INREPLYTO:
1737         case CRITERIA_REFERENCES:
1738         case CRITERIA_HEADERS_PART:
1739         case CRITERIA_BODY_PART:
1740         case CRITERIA_MESSAGE:
1741                 prefs_matcher_disable_widget(matcher.header_combo);
1742                 prefs_matcher_disable_widget(matcher.header_label);
1743                 prefs_matcher_disable_widget(matcher.header_addr_combo);
1744                 prefs_matcher_disable_widget(matcher.header_addr_label);
1745                 prefs_matcher_enable_widget(matcher.value_label);
1746                 prefs_matcher_enable_widget(matcher.value_entry);
1747                 prefs_matcher_disable_widget(matcher.addressbook_folder_label);
1748                 prefs_matcher_disable_widget(matcher.addressbook_folder_combo);
1749                 prefs_matcher_enable_widget(matcher.predicate_label);
1750                 prefs_matcher_enable_widget(matcher.predicate_combo);
1751                 prefs_matcher_disable_widget(matcher.predicate_flag_combo);
1752                 prefs_matcher_enable_widget(matcher.case_checkbtn);
1753                 prefs_matcher_enable_widget(matcher.regexp_checkbtn);
1754                 prefs_matcher_disable_widget(matcher.test_btn);
1755                 prefs_matcher_disable_widget(matcher.addressbook_select_btn);
1756                 break;
1757
1758         case CRITERIA_TEST:
1759                 prefs_matcher_disable_widget(matcher.header_combo);
1760                 prefs_matcher_disable_widget(matcher.header_label);
1761                 prefs_matcher_disable_widget(matcher.header_addr_combo);
1762                 prefs_matcher_disable_widget(matcher.header_addr_label);
1763                 prefs_matcher_enable_widget(matcher.value_label);
1764                 prefs_matcher_enable_widget(matcher.value_entry);
1765                 prefs_matcher_disable_widget(matcher.addressbook_folder_label);
1766                 prefs_matcher_disable_widget(matcher.addressbook_folder_combo);
1767                 prefs_matcher_enable_widget(matcher.predicate_label);
1768                 prefs_matcher_disable_widget(matcher.predicate_combo);
1769                 prefs_matcher_enable_widget(matcher.predicate_flag_combo);
1770                 prefs_matcher_disable_widget(matcher.case_checkbtn);
1771                 prefs_matcher_disable_widget(matcher.regexp_checkbtn);
1772                 prefs_matcher_enable_widget(matcher.test_btn);
1773                 prefs_matcher_disable_widget(matcher.addressbook_select_btn);
1774                 break;
1775
1776         case CRITERIA_AGE_GREATER:
1777         case CRITERIA_AGE_LOWER:
1778         case CRITERIA_SCORE_GREATER:
1779         case CRITERIA_SCORE_LOWER:
1780         case CRITERIA_SCORE_EQUAL:
1781         case CRITERIA_SIZE_GREATER:
1782         case CRITERIA_SIZE_SMALLER:
1783         case CRITERIA_SIZE_EQUAL:
1784                 prefs_matcher_disable_widget(matcher.header_combo);
1785                 prefs_matcher_disable_widget(matcher.header_label);
1786                 prefs_matcher_disable_widget(matcher.header_addr_combo);
1787                 prefs_matcher_disable_widget(matcher.header_addr_label);
1788                 prefs_matcher_enable_widget(matcher.value_label);
1789                 prefs_matcher_enable_widget(matcher.value_entry);
1790                 prefs_matcher_disable_widget(matcher.addressbook_folder_label);
1791                 prefs_matcher_disable_widget(matcher.addressbook_folder_combo);
1792                 prefs_matcher_disable_widget(matcher.predicate_label);
1793                 prefs_matcher_disable_widget(matcher.predicate_combo);
1794                 prefs_matcher_disable_widget(matcher.predicate_flag_combo);
1795                 prefs_matcher_disable_widget(matcher.case_checkbtn);
1796                 prefs_matcher_disable_widget(matcher.regexp_checkbtn);
1797                 prefs_matcher_disable_widget(matcher.test_btn);
1798                 prefs_matcher_disable_widget(matcher.addressbook_select_btn);
1799                 break;
1800
1801         case CRITERIA_HEADER:
1802                 prefs_matcher_enable_widget(matcher.header_combo);
1803                 prefs_matcher_enable_widget(matcher.header_label);
1804                 prefs_matcher_disable_widget(matcher.header_addr_combo);
1805                 prefs_matcher_disable_widget(matcher.header_addr_label);
1806                 prefs_matcher_enable_widget(matcher.value_label);
1807                 prefs_matcher_enable_widget(matcher.value_entry);
1808                 prefs_matcher_disable_widget(matcher.addressbook_folder_label);
1809                 prefs_matcher_disable_widget(matcher.addressbook_folder_combo);
1810                 prefs_matcher_enable_widget(matcher.predicate_label);
1811                 prefs_matcher_enable_widget(matcher.predicate_combo);
1812                 prefs_matcher_disable_widget(matcher.predicate_flag_combo);
1813                 prefs_matcher_enable_widget(matcher.case_checkbtn);
1814                 prefs_matcher_enable_widget(matcher.regexp_checkbtn);
1815                 prefs_matcher_disable_widget(matcher.test_btn);
1816                 prefs_matcher_disable_widget(matcher.addressbook_select_btn);
1817                 break;
1818
1819         case CRITERIA_FOUND_IN_ADDRESSBOOK:
1820                 prefs_matcher_disable_widget(matcher.header_combo);
1821                 prefs_matcher_disable_widget(matcher.header_label);
1822                 prefs_matcher_enable_widget(matcher.header_addr_combo);
1823                 prefs_matcher_enable_widget(matcher.header_addr_label);
1824                 prefs_matcher_disable_widget(matcher.value_label);
1825                 prefs_matcher_disable_widget(matcher.value_entry);
1826                 prefs_matcher_enable_widget(matcher.addressbook_folder_label);
1827                 prefs_matcher_enable_widget(matcher.addressbook_folder_combo);
1828                 prefs_matcher_enable_widget(matcher.predicate_label);
1829                 prefs_matcher_disable_widget(matcher.predicate_combo);
1830                 prefs_matcher_enable_widget(matcher.predicate_flag_combo);
1831                 prefs_matcher_disable_widget(matcher.case_checkbtn);
1832                 prefs_matcher_disable_widget(matcher.regexp_checkbtn);
1833                 prefs_matcher_disable_widget(matcher.test_btn);
1834                 prefs_matcher_enable_widget(matcher.addressbook_select_btn);
1835                 break;
1836         }
1837 }
1838
1839 /*!
1840  *\brief        Handle key press
1841  *
1842  *\param        widget Widget receiving key press
1843  *\param        event Key event
1844  *\param        data User data
1845  */
1846 static gboolean prefs_matcher_key_pressed(GtkWidget *widget, GdkEventKey *event,
1847                                      gpointer data)
1848 {
1849         if (event && event->keyval == GDK_Escape) {
1850                 prefs_matcher_cancel();
1851                 return TRUE;
1852         }
1853         return FALSE;
1854 }
1855
1856 /*!
1857  *\brief        Cancel matcher dialog
1858  */
1859 static void prefs_matcher_cancel(void)
1860 {
1861         gtk_widget_hide(matcher.window);
1862         inc_unlock();
1863 }
1864
1865 /*!
1866  *\brief        Accept current matchers
1867  */
1868 static void prefs_matcher_ok(void)
1869 {
1870         MatcherList *matchers;
1871         MatcherProp *matcherprop;
1872         AlertValue val;
1873         gchar *matcher_str = NULL;
1874         gchar *str = NULL;
1875         gint row = 1;
1876         GtkTreeModel *model;
1877         GtkTreeIter iter;
1878
1879         matchers = prefs_matcher_get_list();
1880
1881         if (matchers != NULL) {
1882                 matcherprop = prefs_matcher_dialog_to_matcher();
1883                 if (matcherprop != NULL) {
1884                         str = matcherprop_to_string(matcherprop);
1885                         matcherprop_free(matcherprop);
1886                         if (strcmp(str, "all") != 0) {
1887                                 model = gtk_tree_view_get_model(GTK_TREE_VIEW
1888                                                 (matcher.cond_list_view));
1889
1890                                 while (gtk_tree_model_iter_nth_child(model, &iter, NULL, row)) {
1891                                         gtk_tree_model_get(model, &iter,
1892                                                            PREFS_MATCHER_COND, &matcher_str,
1893                                                            -1);
1894                                         if (matcher_str && strcmp(matcher_str, str) == 0)
1895                                                 break;
1896                                         row++;
1897                                         g_free(matcher_str);
1898                                         matcher_str = NULL;
1899                                 }
1900
1901                                 if (!matcher_str || strcmp(matcher_str, str) != 0) {
1902                                         val = alertpanel(_("Entry not saved"),
1903                                                  _("The entry was not saved.\nClose anyway?"),
1904                                                  GTK_STOCK_CLOSE, _("+_Continue editing"), NULL);
1905                                         if (G_ALERTDEFAULT != val) {
1906                                                 g_free(matcher_str);
1907                                                 g_free(str);
1908                                                 return;
1909                                         }
1910                                 }
1911                                 g_free(matcher_str);
1912                         }
1913                 }
1914                 g_free(str);
1915                 gtk_widget_hide(matcher.window);
1916                 inc_unlock();
1917                 if (matchers_callback != NULL)
1918                         matchers_callback(matchers);
1919                 matcherlist_free(matchers);
1920         }
1921 }
1922
1923 /*!
1924  *\brief        Called when closing dialog box
1925  *
1926  *\param        widget Dialog widget
1927  *\param        event Event info
1928  *\param        data User data
1929  *
1930  *\return       gint TRUE
1931  */
1932 static gint prefs_matcher_deleted(GtkWidget *widget, GdkEventAny *event,
1933                                   gpointer data)
1934 {
1935         prefs_matcher_cancel();
1936         return TRUE;
1937 }
1938
1939 /*
1940  * Strings describing test format strings
1941  *
1942  * When adding new lines, remember to put 2 strings for each line
1943  */
1944 static gchar *test_desc_strings[] = {
1945         "%%",   N_("literal %"),
1946         "%s",   N_("Subject"),
1947         "%f",   N_("From"),
1948         "%t",   N_("To"),
1949         "%c",   N_("Cc"),
1950         "%d",   N_("Date"),
1951         "%i",   N_("Message-ID"),
1952         "%n",   N_("Newsgroups"),
1953         "%r",   N_("References"),
1954         "%F",   N_("filename (should not be modified)"),
1955         "\\n",  N_("new line"),
1956         "\\",   N_("escape character for quotes"),
1957         "\\\"", N_("quote character"),
1958         NULL,   NULL
1959 };
1960
1961 static DescriptionWindow test_desc_win = {
1962         NULL,
1963         NULL,
1964         2,
1965         N_("Match Type: 'Test'"),
1966         N_("'Test' allows you to test a message or message element "
1967            "using an external program or script. The program will "
1968            "return either 0 or 1.\n\n"
1969            "The following symbols can be used:"),
1970         test_desc_strings
1971 };
1972
1973
1974
1975 /*!
1976  *\brief        Show Test action's info
1977  */
1978 static void prefs_matcher_test_info(void)
1979 {
1980         description_window_create(&test_desc_win);
1981 }
1982
1983 static void prefs_matcher_addressbook_select(void)
1984 {
1985         gchar *folderpath = NULL;
1986         gboolean ret = FALSE;
1987
1988         folderpath = (gchar *) gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(matcher.addressbook_folder_combo)->entry));
1989         ret = addressbook_folder_selection(&folderpath);
1990         if ( ret != FALSE && folderpath != NULL)
1991                 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(matcher.addressbook_folder_combo)->entry), folderpath);
1992 }
1993
1994
1995 /*
1996  * list view
1997  */
1998
1999 static GtkListStore* prefs_matcher_create_data_store(void)
2000 {
2001         return gtk_list_store_new(N_PREFS_MATCHER_COLUMNS,
2002                                   G_TYPE_STRING,
2003                                   G_TYPE_BOOLEAN,
2004                                   -1);
2005 }
2006
2007 static void prefs_matcher_list_view_insert_matcher(GtkWidget *list_view,
2008                                                    GtkTreeIter *row_iter,
2009                                                    const gchar *matcher,
2010                                                    gboolean is_valid)
2011 {
2012         GtkTreeIter iter;
2013         GtkListStore *list_store = GTK_LIST_STORE(gtk_tree_view_get_model
2014                                         (GTK_TREE_VIEW(list_view)));
2015
2016         if (row_iter == NULL) {
2017                 /* append new */
2018                 gtk_list_store_append(list_store, &iter);
2019         } else {
2020                 /* change existing */
2021                 iter = *row_iter;
2022         }
2023
2024         gtk_list_store_set(list_store, &iter,
2025                            PREFS_MATCHER_COND, matcher,
2026                            PREFS_MATCHER_COND_VALID, is_valid,
2027                            -1);
2028 }
2029
2030 static GtkWidget *prefs_matcher_list_view_create(void)
2031 {
2032         GtkTreeView *list_view;
2033         GtkTreeSelection *selector;
2034         GtkTreeModel *model;
2035
2036         model = GTK_TREE_MODEL(prefs_matcher_create_data_store());
2037         list_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model));
2038         g_object_unref(model);
2039
2040         gtk_tree_view_set_rules_hint(list_view, prefs_common.use_stripes_everywhere);
2041
2042         selector = gtk_tree_view_get_selection(list_view);
2043         gtk_tree_selection_set_mode(selector, GTK_SELECTION_BROWSE);
2044         gtk_tree_selection_set_select_function(selector, prefs_matcher_selected,
2045                                                NULL, NULL);
2046
2047         /* create the columns */
2048         prefs_matcher_create_list_view_columns(GTK_WIDGET(list_view));
2049
2050         return GTK_WIDGET(list_view);
2051 }
2052
2053 static void prefs_matcher_create_list_view_columns(GtkWidget *list_view)
2054 {
2055         GtkTreeViewColumn *column;
2056         GtkCellRenderer *renderer;
2057
2058         renderer = gtk_cell_renderer_text_new();
2059         column = gtk_tree_view_column_new_with_attributes
2060                 (_("Current condition rules"),
2061                  renderer,
2062                  "text", PREFS_MATCHER_COND,
2063                  NULL);
2064         gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);
2065 }
2066
2067 static gboolean prefs_matcher_selected(GtkTreeSelection *selector,
2068                                        GtkTreeModel *model,
2069                                        GtkTreePath *path,
2070                                        gboolean currently_selected,
2071                                        gpointer data)
2072 {
2073         gchar *matcher_str;
2074         MatcherProp *prop;
2075         gboolean negative_cond;
2076         gint criteria;
2077         GtkTreeIter iter;
2078         gboolean is_valid;
2079
2080         if (currently_selected)
2081                 return TRUE;
2082
2083         if (!gtk_tree_model_get_iter(model, &iter, path))
2084                 return TRUE;
2085
2086         gtk_tree_model_get(model, &iter,
2087                            PREFS_MATCHER_COND_VALID,  &is_valid,
2088                            PREFS_MATCHER_COND, &matcher_str,
2089                            -1);
2090
2091         if (!is_valid) {
2092                 g_free(matcher_str);
2093                 prefs_matcher_reset_condition();
2094                 return TRUE;
2095         }
2096
2097         negative_cond = FALSE;
2098
2099         prop = matcher_parser_get_prop(matcher_str);
2100         if (prop == NULL) {
2101                 g_free(matcher_str);
2102                 return TRUE;
2103         }
2104
2105         criteria = prefs_matcher_get_criteria_from_matching(prop->criteria);
2106         if (criteria != -1)
2107                 gtk_list_select_item(GTK_LIST(matcher.criteria_list),
2108                                      criteria);
2109
2110         switch(prop->criteria) {
2111         case MATCHCRITERIA_NOT_UNREAD:
2112         case MATCHCRITERIA_NOT_NEW:
2113         case MATCHCRITERIA_NOT_MARKED:
2114         case MATCHCRITERIA_NOT_DELETED:
2115         case MATCHCRITERIA_NOT_REPLIED:
2116         case MATCHCRITERIA_NOT_FORWARDED:
2117         case MATCHCRITERIA_NOT_LOCKED:
2118         case MATCHCRITERIA_NOT_SPAM:
2119         case MATCHCRITERIA_NOT_PARTIAL:
2120         case MATCHCRITERIA_NOT_COLORLABEL:
2121         case MATCHCRITERIA_NOT_IGNORE_THREAD:
2122         case MATCHCRITERIA_NOT_WATCH_THREAD:
2123         case MATCHCRITERIA_NOT_SUBJECT:
2124         case MATCHCRITERIA_NOT_FROM:
2125         case MATCHCRITERIA_NOT_TO:
2126         case MATCHCRITERIA_NOT_CC:
2127         case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
2128         case MATCHCRITERIA_NOT_TAG:
2129         case MATCHCRITERIA_NOT_TAGGED:
2130         case MATCHCRITERIA_NOT_NEWSGROUPS:
2131         case MATCHCRITERIA_NOT_INREPLYTO:
2132         case MATCHCRITERIA_NOT_REFERENCES:
2133         case MATCHCRITERIA_NOT_HEADER:
2134         case MATCHCRITERIA_NOT_HEADERS_PART:
2135         case MATCHCRITERIA_NOT_MESSAGE:
2136         case MATCHCRITERIA_NOT_BODY_PART:
2137         case MATCHCRITERIA_NOT_TEST:
2138         case MATCHCRITERIA_NOT_FOUND_IN_ADDRESSBOOK:
2139                 negative_cond = TRUE;
2140                 break;
2141         }
2142
2143         switch(prop->criteria) {
2144         case MATCHCRITERIA_ALL:
2145                 break;
2146
2147         case MATCHCRITERIA_NOT_SUBJECT:
2148         case MATCHCRITERIA_NOT_FROM:
2149         case MATCHCRITERIA_NOT_TO:
2150         case MATCHCRITERIA_NOT_CC:
2151         case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
2152         case MATCHCRITERIA_NOT_TAG:
2153         case MATCHCRITERIA_NOT_NEWSGROUPS:
2154         case MATCHCRITERIA_NOT_INREPLYTO:
2155         case MATCHCRITERIA_NOT_REFERENCES:
2156         case MATCHCRITERIA_NOT_HEADERS_PART:
2157         case MATCHCRITERIA_NOT_BODY_PART:
2158         case MATCHCRITERIA_NOT_MESSAGE:
2159         case MATCHCRITERIA_NOT_TEST:
2160         case MATCHCRITERIA_SUBJECT:
2161         case MATCHCRITERIA_FROM:
2162         case MATCHCRITERIA_TO:
2163         case MATCHCRITERIA_CC:
2164         case MATCHCRITERIA_TO_OR_CC:
2165         case MATCHCRITERIA_TAG:
2166         case MATCHCRITERIA_NEWSGROUPS:
2167         case MATCHCRITERIA_INREPLYTO:
2168         case MATCHCRITERIA_REFERENCES:
2169         case MATCHCRITERIA_HEADERS_PART:
2170         case MATCHCRITERIA_BODY_PART:
2171         case MATCHCRITERIA_MESSAGE:
2172         case MATCHCRITERIA_TEST:
2173                 gtk_entry_set_text(GTK_ENTRY(matcher.value_entry), prop->expr);
2174                 break;
2175
2176         case MATCHCRITERIA_FOUND_IN_ADDRESSBOOK:
2177         case MATCHCRITERIA_NOT_FOUND_IN_ADDRESSBOOK:
2178         {
2179                 gchar *header;
2180                 gchar *expr;
2181
2182                 /* matcher expressions contain UNtranslated "Any"/"All",
2183                   select the relevant translated combo item */
2184                 if (strcasecmp(prop->header, "All") == 0)
2185                         header = (gchar*)Q_("Filtering Matcher Menu|All");
2186                 else
2187                         if (strcasecmp(prop->header, "Any") == 0)
2188                                 header = _("Any");
2189                         else
2190                                 header = prop->header;
2191                 if (strcasecmp(prop->expr, "Any") == 0)
2192                         expr = _("Any");
2193                 else
2194                         expr = prop->expr;
2195
2196                 gtk_entry_set_text(GTK_ENTRY(matcher.header_addr_entry), header);
2197                 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(matcher.addressbook_folder_combo)->entry), expr);
2198                 break;
2199         }
2200
2201         case MATCHCRITERIA_AGE_GREATER:
2202         case MATCHCRITERIA_AGE_LOWER:
2203         case MATCHCRITERIA_SCORE_GREATER:
2204         case MATCHCRITERIA_SCORE_LOWER:
2205         case MATCHCRITERIA_SCORE_EQUAL:
2206         case MATCHCRITERIA_SIZE_GREATER:
2207         case MATCHCRITERIA_SIZE_SMALLER:
2208         case MATCHCRITERIA_SIZE_EQUAL:
2209                 gtk_entry_set_text(GTK_ENTRY(matcher.value_entry), itos(prop->value));
2210                 break;
2211
2212         case MATCHCRITERIA_NOT_COLORLABEL:
2213         case MATCHCRITERIA_COLORLABEL:
2214                 gtk_option_menu_set_history(GTK_OPTION_MENU(matcher.color_optmenu),
2215                                             prop->value);
2216                 break;
2217
2218         case MATCHCRITERIA_NOT_HEADER:
2219         case MATCHCRITERIA_HEADER:
2220                 gtk_entry_set_text(GTK_ENTRY(matcher.header_entry), prop->header);
2221                 gtk_entry_set_text(GTK_ENTRY(matcher.value_entry), prop->expr);
2222                 break;
2223         }
2224
2225         if (negative_cond) {
2226                 gtk_list_select_item(GTK_LIST(matcher.predicate_list), 1);
2227                 gtk_list_select_item(GTK_LIST(matcher.predicate_flag_list), 1);
2228         } else {
2229                 gtk_list_select_item(GTK_LIST(matcher.predicate_list), 0);
2230                 gtk_list_select_item(GTK_LIST(matcher.predicate_flag_list), 0);
2231         }
2232
2233         switch(prop->matchtype) {
2234         case MATCHTYPE_MATCH:
2235                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.regexp_checkbtn), FALSE);
2236                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.case_checkbtn), TRUE);
2237                 break;
2238
2239         case MATCHTYPE_MATCHCASE:
2240                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.regexp_checkbtn), FALSE);
2241                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.case_checkbtn), FALSE);
2242                 break;
2243
2244         case MATCHTYPE_REGEXP:
2245                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.regexp_checkbtn), TRUE);
2246                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.case_checkbtn), TRUE);
2247                 break;
2248
2249         case MATCHTYPE_REGEXPCASE:
2250                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.regexp_checkbtn), TRUE);
2251                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.case_checkbtn), FALSE);
2252                 break;
2253         }
2254
2255         g_free(matcher_str);
2256         return TRUE;
2257 }
2258