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