fix english ;)
[claws.git] / src / prefs_matcher.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2001 Hiroyuki Yamamoto
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #include "defs.h"
25
26 #include <glib.h>
27 #include <gtk/gtk.h>
28 #include <gdk/gdkkeysyms.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <errno.h>
33
34 #include "intl.h"
35 #include "main.h"
36 #include "prefs.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
49 #include "matcher_parser.h"
50
51 static struct Matcher {
52         GtkWidget *window;
53
54         GtkWidget *ok_btn;
55
56         GtkWidget *predicate_combo;
57         GtkWidget *predicate_flag_combo;
58         GtkWidget *header_combo;
59
60         GtkWidget *criteria_list;
61
62         GtkWidget *predicate_list;
63         GtkWidget *predicate_label;
64         GtkWidget *predicate_flag_list;
65
66         GtkWidget *bool_op_list;
67
68         GtkWidget *header_entry;
69         GtkWidget *header_label;
70         GtkWidget *value_entry;
71         GtkWidget *value_label;
72         GtkWidget *case_chkbtn;
73         GtkWidget *regexp_chkbtn;
74
75         GtkWidget *exec_btn;
76
77         GtkWidget *cond_clist;
78 } matcher;
79
80 /* choice in the list */
81
82 enum {
83         CRITERIA_ALL = 0,
84
85         CRITERIA_SUBJECT = 1,
86         CRITERIA_FROM = 2,
87         CRITERIA_TO = 3,
88         CRITERIA_CC = 4,
89         CRITERIA_TO_OR_CC = 5,
90         CRITERIA_NEWSGROUPS = 6,
91         CRITERIA_INREPLYTO = 7,
92         CRITERIA_REFERENCES = 8,
93         CRITERIA_AGE_GREATER = 9,
94         CRITERIA_AGE_LOWER = 10,
95         CRITERIA_HEADER = 11,
96         CRITERIA_HEADERS_PART = 12,
97         CRITERIA_BODY_PART = 13,
98         CRITERIA_MESSAGE = 14,
99
100         CRITERIA_UNREAD = 15,
101         CRITERIA_NEW = 16,
102         CRITERIA_MARKED = 17,
103         CRITERIA_DELETED = 18,
104         CRITERIA_REPLIED = 19,
105         CRITERIA_FORWARDED = 20,
106
107         CRITERIA_SCORE_GREATER = 21,
108         CRITERIA_SCORE_LOWER = 22,
109         CRITERIA_SCORE_EQUAL = 23,
110
111         CRITERIA_EXECUTE = 24,
112
113         CRITERIA_SIZE_GREATER = 25,
114         CRITERIA_SIZE_SMALLER = 26,
115         CRITERIA_SIZE_EQUAL   = 27
116 };
117
118 enum {
119         BOOL_OP_OR = 0,
120         BOOL_OP_AND = 1
121 };
122
123 gchar * bool_op_text [] = {
124         N_("or"), N_("and")
125 };
126
127 enum {
128         PREDICATE_CONTAINS = 0,
129         PREDICATE_DOES_NOT_CONTAIN = 1
130 };
131
132 gchar * predicate_text [] = {
133         N_("contains"), N_("does not contain")
134 };
135
136 enum {
137         PREDICATE_FLAG_ENABLED = 0,
138         PREDICATE_FLAG_DISABLED = 1
139 };
140
141 gchar * predicate_flag_text [] = {
142         N_("yes"), N_("no")
143 };
144
145 gchar * criteria_text [] = {
146         N_("All messages"), N_("Subject"),
147         N_("From"), N_("To"), N_("Cc"), N_("To or Cc"),
148         N_("Newsgroups"), N_("In reply to"), N_("References"),
149         N_("Age greater than"), N_("Age lower than"),
150         N_("Header"), N_("Headers part"),
151         N_("Body part"), N_("Whole message"),
152         N_("Unread flag"), N_("New flag"),
153         N_("Marked flag"), N_("Deleted flag"),
154         N_("Replied flag"), N_("Forwarded flag"),
155         N_("Score greater than"), N_("Score lower than"),
156         N_("Score equal to"),
157         N_("Execute"),
158         N_("Size greater than"), 
159         N_("Size smaller than"),
160         N_("Size exactly")
161 };
162
163 static gint get_sel_from_list(GtkList * list)
164 {
165         gint row = 0;
166         void * sel;
167         GList * child;
168
169         sel = list->selection->data;
170         for(child = list->children ; child != NULL ;
171             child = g_list_next(child)) {
172                 if (child->data == sel)
173                         return row;
174                 row ++;
175         }
176         
177         return row;
178 }
179
180 static PrefsMatcherSignal * matchers_callback;
181
182 /* widget creating functions */
183 static void prefs_matcher_create        (void);
184
185 static void prefs_matcher_set_dialog    (MatcherList * matchers);
186
187 /*
188 static void prefs_matcher_set_list      (void);
189 static gint prefs_matcher_clist_set_row (gint    row);
190 */
191
192 /* callback functions */
193
194 /*
195 static void prefs_matcher_select_dest_cb        (void);
196 */
197 static void prefs_matcher_register_cb   (void);
198 static void prefs_matcher_substitute_cb (void);
199 static void prefs_matcher_delete_cb     (void);
200 static void prefs_matcher_up            (void);
201 static void prefs_matcher_down          (void);
202 static void prefs_matcher_select        (GtkCList       *clist,
203                                          gint            row,
204                                          gint            column,
205                                          GdkEvent       *event);
206
207 static void prefs_matcher_key_pressed   (GtkWidget      *widget,
208                                          GdkEventKey    *event,
209                                          gpointer        data);
210 static void prefs_matcher_ok            (void);
211 static void prefs_matcher_cancel                (void);
212 static gint prefs_matcher_deleted(GtkWidget *widget, GdkEventAny *event,
213                                   gpointer data);
214 static void prefs_matcher_criteria_select(GtkList *list,
215                                           GtkWidget *widget,
216                                           gpointer user_data);
217 static MatcherList * prefs_matcher_get_list(void);
218 static void prefs_matcher_exec_info_create(void);
219
220 void prefs_matcher_open(MatcherList * matchers, PrefsMatcherSignal * cb)
221 {
222         inc_lock();
223
224         if (!matcher.window) {
225                 prefs_matcher_create();
226         }
227
228         manage_window_set_transient(GTK_WINDOW(matcher.window));
229         gtk_widget_grab_focus(matcher.ok_btn);
230
231         matchers_callback = cb;
232
233         prefs_matcher_set_dialog(matchers);
234
235         gtk_widget_show(matcher.window);
236 }
237
238 static void prefs_matcher_create(void)
239 {
240         GtkWidget *window;
241         GtkWidget *vbox;
242         GtkWidget *ok_btn;
243         GtkWidget *cancel_btn;
244         GtkWidget *confirm_area;
245
246         GtkWidget *vbox1;
247         GtkWidget *vbox2;
248         GtkWidget *vbox3;
249         GtkWidget *table1;
250
251         GtkWidget *hbox1;
252
253         GtkWidget *header_combo;
254         GtkWidget *header_entry;
255         GtkWidget *header_label;
256         GtkWidget *criteria_combo;
257         GtkWidget *criteria_list;
258         GtkWidget *criteria_label;
259         GtkWidget *value_label;
260         GtkWidget *value_entry;
261         GtkWidget *predicate_combo;
262         GtkWidget *predicate_list;
263         GtkWidget *predicate_flag_combo;
264         GtkWidget *predicate_flag_list;
265         GtkWidget *predicate_label;
266         GtkWidget *bool_op_combo;
267         GtkWidget *bool_op_list;
268         GtkWidget *bool_op_label;
269
270         GtkWidget *regexp_chkbtn;
271         GtkWidget *case_chkbtn;
272
273         GtkWidget *reg_hbox;
274         GtkWidget *btn_hbox;
275         GtkWidget *arrow;
276         GtkWidget *reg_btn;
277         GtkWidget *subst_btn;
278         GtkWidget *del_btn;
279
280         GtkWidget *cond_hbox;
281         GtkWidget *cond_scrolledwin;
282         GtkWidget *cond_clist;
283
284         GtkWidget *btn_vbox;
285         GtkWidget *up_btn;
286         GtkWidget *down_btn;
287
288         GtkWidget *exec_btn;
289
290         GList *combo_items;
291         gint i;
292
293         gchar *title[1];
294
295         debug_print("Creating matcher configuration window...\n");
296
297         window = gtk_window_new (GTK_WINDOW_DIALOG);
298         gtk_container_set_border_width (GTK_CONTAINER (window), 8);
299         gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
300         gtk_window_set_modal (GTK_WINDOW (window), TRUE);
301         gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, FALSE);
302
303         vbox = gtk_vbox_new (FALSE, 6);
304         gtk_widget_show (vbox);
305         gtk_container_add (GTK_CONTAINER (window), vbox);
306
307         gtkut_button_set_create(&confirm_area, &ok_btn, _("OK"),
308                                 &cancel_btn, _("Cancel"), NULL, NULL);
309         gtk_widget_show (confirm_area);
310         gtk_box_pack_end (GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
311         gtk_widget_grab_default (ok_btn);
312
313         gtk_window_set_title (GTK_WINDOW(window),
314                               _("Condition configuration"));
315         gtk_signal_connect (GTK_OBJECT(window), "delete_event",
316                             GTK_SIGNAL_FUNC(prefs_matcher_deleted), NULL);
317         gtk_signal_connect (GTK_OBJECT(window), "key_press_event",
318                             GTK_SIGNAL_FUNC(prefs_matcher_key_pressed), NULL);
319         MANAGE_WINDOW_SIGNALS_CONNECT (window);
320         gtk_signal_connect (GTK_OBJECT(ok_btn), "clicked",
321                             GTK_SIGNAL_FUNC(prefs_matcher_ok), NULL);
322         gtk_signal_connect (GTK_OBJECT(cancel_btn), "clicked",
323                             GTK_SIGNAL_FUNC(prefs_matcher_cancel), NULL);
324
325         vbox1 = gtk_vbox_new (FALSE, VSPACING);
326         gtk_widget_show (vbox1);
327         gtk_box_pack_start (GTK_BOX (vbox), vbox1, TRUE, TRUE, 0);
328         gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);
329
330         table1 = gtk_table_new (2, 4, FALSE);
331         gtk_widget_show (table1);
332
333         gtk_box_pack_start (GTK_BOX (vbox1), table1, FALSE, FALSE, 0);
334         gtk_table_set_row_spacings (GTK_TABLE (table1), 8);
335         gtk_table_set_col_spacings (GTK_TABLE (table1), 8);
336
337         /* criteria combo box */
338
339         criteria_label = gtk_label_new (_("Match type"));
340         gtk_widget_show (criteria_label);
341         gtk_misc_set_alignment (GTK_MISC (criteria_label), 0, 0.5);
342         gtk_table_attach (GTK_TABLE (table1), criteria_label, 0, 1, 0, 1,
343                           GTK_FILL, 0, 0, 0);
344
345         criteria_combo = gtk_combo_new ();
346         gtk_widget_show (criteria_combo);
347
348         combo_items = NULL;
349
350         for(i = 0 ; i < (gint) (sizeof(criteria_text) / sizeof(gchar *)) ;
351             i++) {
352                 combo_items = g_list_append(combo_items,
353                                             (gpointer) _(criteria_text[i]));
354         }
355         gtk_combo_set_popdown_strings(GTK_COMBO(criteria_combo), combo_items);
356
357         g_list_free(combo_items);
358
359         gtk_widget_set_usize (criteria_combo, 120, -1);
360         gtk_table_attach (GTK_TABLE (table1), criteria_combo, 0, 1, 1, 2,
361                           0, 0, 0, 0);
362         criteria_list = GTK_COMBO(criteria_combo)->list;
363         gtk_signal_connect (GTK_OBJECT (criteria_list), "select-child",
364                             GTK_SIGNAL_FUNC (prefs_matcher_criteria_select),
365                             NULL);
366
367         gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(criteria_combo)->entry),
368                                FALSE);
369
370         /* header name */
371
372         header_label = gtk_label_new (_("Header name"));
373         gtk_widget_show (header_label);
374         gtk_misc_set_alignment (GTK_MISC (header_label), 0, 0.5);
375         gtk_table_attach (GTK_TABLE (table1), header_label, 1, 2, 0, 1,
376                           GTK_FILL, 0, 0, 0);
377
378         header_combo = gtk_combo_new ();
379         gtk_widget_show (header_combo);
380         gtk_widget_set_usize (header_combo, 96, -1);
381         gtkut_combo_set_items (GTK_COMBO (header_combo),
382                                "Subject", "From", "To", "Cc", "Reply-To",
383                                "Sender", "X-ML-Name", "X-List", "X-Sequence",
384                                "X-Mailer","X-BeenThere",
385                                NULL);
386         gtk_table_attach (GTK_TABLE (table1), header_combo, 1, 2, 1, 2,
387                           0, 0, 0, 0);
388         header_entry = GTK_COMBO (header_combo)->entry;
389         gtk_entry_set_editable (GTK_ENTRY (header_entry), TRUE);
390
391         /* value */
392
393         value_label = gtk_label_new (_("Value"));
394         gtk_widget_show (value_label);
395         gtk_misc_set_alignment (GTK_MISC (value_label), 0, 0.5);
396         gtk_table_attach (GTK_TABLE (table1), value_label, 2, 3, 0, 1,
397                           GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0, 0);
398
399         value_entry = gtk_entry_new ();
400         gtk_widget_show (value_entry);
401         gtk_widget_set_usize (value_entry, 200, -1);
402         gtk_table_attach (GTK_TABLE (table1), value_entry, 2, 3, 1, 2,
403                           GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0, 0);
404
405         exec_btn = gtk_button_new_with_label (_("Info ..."));
406         gtk_widget_show (exec_btn);
407         gtk_table_attach (GTK_TABLE (table1), exec_btn, 3, 4, 1, 2,
408                           GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0, 0);
409         gtk_signal_connect (GTK_OBJECT (exec_btn), "clicked",
410                             GTK_SIGNAL_FUNC (prefs_matcher_exec_info),
411                             NULL);
412
413         /* predicate */
414
415         vbox2 = gtk_vbox_new (FALSE, VSPACING);
416         gtk_widget_show (vbox2);
417         gtk_box_pack_start (GTK_BOX (vbox1), vbox2, FALSE, FALSE, 0);
418
419         hbox1 = gtk_hbox_new (FALSE, 8);
420         gtk_widget_show (hbox1);
421         gtk_box_pack_start (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 0);
422
423         predicate_label = gtk_label_new (_("Predicate"));
424         gtk_widget_show (predicate_label);
425         gtk_box_pack_start (GTK_BOX (hbox1), predicate_label,
426                             FALSE, FALSE, 0);
427
428         predicate_combo = gtk_combo_new ();
429         gtk_widget_show (predicate_combo);
430         gtk_widget_set_usize (predicate_combo, 120, -1);
431         predicate_list = GTK_COMBO(predicate_combo)->list;
432         gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(predicate_combo)->entry),
433                                FALSE);
434
435         combo_items = NULL;
436
437         for(i = 0 ; i < (gint) (sizeof(predicate_text) / sizeof(gchar *)) ;
438             i++) {
439                 combo_items = g_list_append(combo_items,
440                                             (gpointer) _(predicate_text[i]));
441         }
442         gtk_combo_set_popdown_strings(GTK_COMBO(predicate_combo), combo_items);
443
444         g_list_free(combo_items);
445
446         gtk_box_pack_start (GTK_BOX (hbox1), predicate_combo,
447                             FALSE, FALSE, 0);
448
449         /* predicate flag */
450
451         predicate_flag_combo = gtk_combo_new ();
452         gtk_widget_hide (predicate_flag_combo);
453         gtk_widget_set_usize (predicate_flag_combo, 120, -1);
454         predicate_flag_list = GTK_COMBO(predicate_flag_combo)->list;
455         gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(predicate_flag_combo)->entry), FALSE);
456
457         combo_items = NULL;
458
459         for(i = 0 ; i < (gint) (sizeof(predicate_text) / sizeof(gchar *)) ;
460             i++) {
461                 combo_items = g_list_append(combo_items, (gpointer) _(predicate_flag_text[i]));
462         }
463         gtk_combo_set_popdown_strings(GTK_COMBO(predicate_flag_combo),
464                                       combo_items);
465
466         g_list_free(combo_items);
467
468         gtk_box_pack_start (GTK_BOX (hbox1), predicate_flag_combo,
469                             FALSE, FALSE, 0);
470
471         vbox3 = gtk_vbox_new (FALSE, 0);
472         gtk_widget_show (vbox3);
473         gtk_box_pack_start (GTK_BOX (hbox1), vbox3, FALSE, FALSE, 0);
474
475         PACK_CHECK_BUTTON (vbox3, case_chkbtn, _("Case sensitive"));
476         PACK_CHECK_BUTTON (vbox3, regexp_chkbtn, _("Use regexp"));
477
478         /* register / substitute / delete */
479
480         reg_hbox = gtk_hbox_new (FALSE, 4);
481         gtk_widget_show (reg_hbox);
482         gtk_box_pack_start (GTK_BOX (vbox1), reg_hbox, FALSE, FALSE, 0);
483
484         arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
485         gtk_widget_show (arrow);
486         gtk_box_pack_start (GTK_BOX (reg_hbox), arrow, FALSE, FALSE, 0);
487         gtk_widget_set_usize (arrow, -1, 16);
488
489         btn_hbox = gtk_hbox_new (TRUE, 4);
490         gtk_widget_show (btn_hbox);
491         gtk_box_pack_start (GTK_BOX (reg_hbox), btn_hbox, FALSE, FALSE, 0);
492
493         reg_btn = gtk_button_new_with_label (_("Add"));
494         gtk_widget_show (reg_btn);
495         gtk_box_pack_start (GTK_BOX (btn_hbox), reg_btn, FALSE, TRUE, 0);
496         gtk_signal_connect (GTK_OBJECT (reg_btn), "clicked",
497                             GTK_SIGNAL_FUNC (prefs_matcher_register_cb), NULL);
498
499         subst_btn = gtk_button_new_with_label (_("  Replace  "));
500         gtk_widget_show (subst_btn);
501         gtk_box_pack_start (GTK_BOX (btn_hbox), subst_btn, FALSE, TRUE, 0);
502         gtk_signal_connect (GTK_OBJECT (subst_btn), "clicked",
503                             GTK_SIGNAL_FUNC (prefs_matcher_substitute_cb),
504                             NULL);
505
506         del_btn = gtk_button_new_with_label (_("Delete"));
507         gtk_widget_show (del_btn);
508         gtk_box_pack_start (GTK_BOX (btn_hbox), del_btn, FALSE, TRUE, 0);
509         gtk_signal_connect (GTK_OBJECT (del_btn), "clicked",
510                             GTK_SIGNAL_FUNC (prefs_matcher_delete_cb), NULL);
511
512         /* boolean operation */
513
514         bool_op_label = gtk_label_new (_("Boolean Op"));
515         gtk_misc_set_alignment (GTK_MISC (value_label), 0, 0.5);
516         gtk_widget_show (bool_op_label);
517         gtk_box_pack_start (GTK_BOX (btn_hbox), bool_op_label,
518                             FALSE, FALSE, 0);
519
520         bool_op_combo = gtk_combo_new ();
521         gtk_widget_show (bool_op_combo);
522         gtk_widget_set_usize (bool_op_combo, 50, -1);
523         bool_op_list = GTK_COMBO(bool_op_combo)->list;
524         gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(bool_op_combo)->entry),
525                                FALSE);
526
527         combo_items = NULL;
528
529         for(i = 0 ; i < (gint) (sizeof(bool_op_text) / sizeof(gchar *)) ;
530             i++) {
531                 combo_items = g_list_append(combo_items,
532                                             (gpointer) _(bool_op_text[i]));
533         }
534         gtk_combo_set_popdown_strings(GTK_COMBO(bool_op_combo), combo_items);
535
536         g_list_free(combo_items);
537
538         gtk_box_pack_start (GTK_BOX (btn_hbox), bool_op_combo,
539                             FALSE, FALSE, 0);
540
541         cond_hbox = gtk_hbox_new (FALSE, 8);
542         gtk_widget_show (cond_hbox);
543         gtk_box_pack_start (GTK_BOX (vbox1), cond_hbox, TRUE, TRUE, 0);
544
545         cond_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
546         gtk_widget_show (cond_scrolledwin);
547         gtk_widget_set_usize (cond_scrolledwin, -1, 150);
548         gtk_box_pack_start (GTK_BOX (cond_hbox), cond_scrolledwin,
549                             TRUE, TRUE, 0);
550         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (cond_scrolledwin),
551                                         GTK_POLICY_AUTOMATIC,
552                                         GTK_POLICY_AUTOMATIC);
553
554         title[0] = _("Current condition rules");
555         cond_clist = gtk_clist_new_with_titles(1, title);
556         gtk_widget_show (cond_clist);
557         gtk_container_add (GTK_CONTAINER (cond_scrolledwin), cond_clist);
558         gtk_clist_set_column_width (GTK_CLIST (cond_clist), 0, 80);
559         gtk_clist_set_selection_mode (GTK_CLIST (cond_clist),
560                                       GTK_SELECTION_BROWSE);
561         GTK_WIDGET_UNSET_FLAGS (GTK_CLIST (cond_clist)->column[0].button,
562                                 GTK_CAN_FOCUS);
563         gtk_signal_connect (GTK_OBJECT (cond_clist), "select_row",
564                             GTK_SIGNAL_FUNC (prefs_matcher_select), NULL);
565
566         btn_vbox = gtk_vbox_new (FALSE, 8);
567         gtk_widget_show (btn_vbox);
568         gtk_box_pack_start (GTK_BOX (cond_hbox), btn_vbox, FALSE, FALSE, 0);
569
570         up_btn = gtk_button_new_with_label (_("Up"));
571         gtk_widget_show (up_btn);
572         gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0);
573         gtk_signal_connect (GTK_OBJECT (up_btn), "clicked",
574                             GTK_SIGNAL_FUNC (prefs_matcher_up), NULL);
575
576         down_btn = gtk_button_new_with_label (_("Down"));
577         gtk_widget_show (down_btn);
578         gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0);
579         gtk_signal_connect (GTK_OBJECT (down_btn), "clicked",
580                             GTK_SIGNAL_FUNC (prefs_matcher_down), NULL);
581
582         gtk_widget_show_all(window);
583
584         matcher.window    = window;
585
586         matcher.ok_btn = ok_btn;
587
588         matcher.criteria_list = criteria_list;
589         matcher.header_combo = header_combo;
590         matcher.header_entry = header_entry;
591         matcher.header_label = header_label;
592         matcher.value_entry = value_entry;
593         matcher.value_label = value_label;
594         matcher.predicate_label = predicate_label;
595         matcher.predicate_list = predicate_list;
596         matcher.predicate_combo = predicate_combo;
597         matcher.predicate_flag_list = predicate_flag_list;
598         matcher.predicate_flag_combo = predicate_flag_combo;
599         matcher.case_chkbtn = case_chkbtn;
600         matcher.regexp_chkbtn = regexp_chkbtn;
601         matcher.bool_op_list = bool_op_list;
602         matcher.exec_btn = exec_btn;
603
604         matcher.cond_clist   = cond_clist;
605 }
606
607 static gint prefs_matcher_clist_set_row(gint row, MatcherProp * prop)
608 {
609         GtkCList *clist = GTK_CLIST(matcher.cond_clist);
610         gchar * cond_str[1];
611         gchar * matcher_str;
612
613         if (prop == NULL) {
614                 cond_str[0] = _("(New)");
615                 return gtk_clist_append(clist, cond_str);
616         }
617
618         matcher_str = matcherprop_to_string(prop);
619         cond_str[0] = matcher_str;
620         if (row < 0)
621                 row = gtk_clist_append(clist, cond_str);
622         else
623                 gtk_clist_set_text(clist, row, 0, cond_str[0]);
624         g_free(matcher_str);
625
626         return row;
627 }
628
629 static void prefs_matcher_reset_condition(void)
630 {
631         gtk_list_select_item(GTK_LIST(matcher.criteria_list), 0);
632         gtk_list_select_item(GTK_LIST(matcher.predicate_list), 0);
633         gtk_entry_set_text(GTK_ENTRY(matcher.header_entry), "");
634         gtk_entry_set_text(GTK_ENTRY(matcher.value_entry), "");
635 }
636
637 static void prefs_matcher_update_hscrollbar(void)
638 {
639         gint optwidth = gtk_clist_optimal_column_width(GTK_CLIST(matcher.cond_clist), 0);
640         gtk_clist_set_column_width(GTK_CLIST(matcher.cond_clist), 0, optwidth);
641 }
642
643 static void prefs_matcher_set_dialog(MatcherList * matchers)
644 {
645         GtkCList *clist = GTK_CLIST(matcher.cond_clist);
646         GSList * cur;
647         gboolean bool_op = 1;
648
649         gtk_clist_freeze(clist);
650         gtk_clist_clear(clist);
651
652         prefs_matcher_clist_set_row(-1, NULL);
653         if (matchers != NULL) {
654                 for (cur = matchers->matchers ; cur != NULL ;
655                      cur = g_slist_next(cur)) {
656                         MatcherProp * prop;
657                         prop = (MatcherProp *) cur->data;
658                         prefs_matcher_clist_set_row(-1, prop);
659                 }
660
661                 bool_op = matchers->bool_and;
662         }
663         
664         prefs_matcher_update_hscrollbar();
665
666         gtk_clist_thaw(clist);
667
668         gtk_list_select_item(GTK_LIST(matcher.bool_op_list), bool_op);
669
670         prefs_matcher_reset_condition();
671 }
672
673 static MatcherList * prefs_matcher_get_list(void)
674 {
675         gchar * matcher_str;
676         MatcherProp * prop;
677         gint row = 1;
678         gboolean bool_and;
679         GSList * matcher_list;
680         MatcherList * matchers;
681
682         matcher_list = NULL;
683
684         while (gtk_clist_get_text(GTK_CLIST(matcher.cond_clist),
685                                   row, 0, &matcher_str)) {
686
687                 if (strcmp(matcher_str, _("(New)")) != 0) {
688                         /* tmp = matcher_str; */
689                         prop = matcher_parser_get_prop(matcher_str);
690                         
691                         if (prop == NULL)
692                                 break;
693                         
694                         matcher_list = g_slist_append(matcher_list, prop);
695                 }
696                 row ++;
697         }
698
699         bool_and = get_sel_from_list(GTK_LIST(matcher.bool_op_list));
700
701         matchers = matcherlist_new(matcher_list, bool_and);
702
703         return matchers;
704 }
705
706 static gint prefs_matcher_get_criteria_from_matching(gint matching_id)
707 {
708         switch(matching_id) {
709         case MATCHCRITERIA_ALL:
710                 return CRITERIA_ALL;
711         case MATCHCRITERIA_NOT_UNREAD:
712         case MATCHCRITERIA_UNREAD:
713                 return CRITERIA_UNREAD;
714         case MATCHCRITERIA_NOT_NEW:
715         case MATCHCRITERIA_NEW:
716                 return CRITERIA_NEW;
717         case MATCHCRITERIA_NOT_MARKED:
718         case MATCHCRITERIA_MARKED:
719                 return CRITERIA_MARKED;
720         case MATCHCRITERIA_NOT_DELETED:
721         case MATCHCRITERIA_DELETED:
722                 return CRITERIA_DELETED;
723                 break;
724         case MATCHCRITERIA_NOT_REPLIED:
725         case MATCHCRITERIA_REPLIED:
726                 return CRITERIA_REPLIED;
727         case MATCHCRITERIA_NOT_FORWARDED:
728         case MATCHCRITERIA_FORWARDED:
729                 return CRITERIA_FORWARDED;
730         case MATCHCRITERIA_NOT_SUBJECT:
731         case MATCHCRITERIA_SUBJECT:
732                 return CRITERIA_SUBJECT;
733         case MATCHCRITERIA_NOT_FROM:
734         case MATCHCRITERIA_FROM:
735                 return CRITERIA_FROM;
736         case MATCHCRITERIA_NOT_TO:
737         case MATCHCRITERIA_TO:
738                 return CRITERIA_TO;
739         case MATCHCRITERIA_NOT_CC:
740         case MATCHCRITERIA_CC:
741                 return CRITERIA_CC;
742         case MATCHCRITERIA_NOT_NEWSGROUPS:
743         case MATCHCRITERIA_NEWSGROUPS:
744                 return CRITERIA_NEWSGROUPS;
745         case MATCHCRITERIA_NOT_INREPLYTO:
746         case MATCHCRITERIA_INREPLYTO:
747                 return CRITERIA_INREPLYTO;
748         case MATCHCRITERIA_NOT_REFERENCES:
749         case MATCHCRITERIA_REFERENCES:
750                 return CRITERIA_REFERENCES;
751         case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
752         case MATCHCRITERIA_TO_OR_CC:
753                 return CRITERIA_TO_OR_CC;
754         case MATCHCRITERIA_NOT_BODY_PART:
755         case MATCHCRITERIA_BODY_PART:
756                 return CRITERIA_BODY_PART;
757         case MATCHCRITERIA_NOT_MESSAGE:
758         case MATCHCRITERIA_MESSAGE:
759                 return CRITERIA_MESSAGE;
760                 break;
761         case MATCHCRITERIA_NOT_HEADERS_PART:
762         case MATCHCRITERIA_HEADERS_PART:
763                 return CRITERIA_HEADERS_PART;
764         case MATCHCRITERIA_NOT_HEADER:
765         case MATCHCRITERIA_HEADER:
766                 return CRITERIA_HEADER;
767         case MATCHCRITERIA_AGE_GREATER:
768                 return CRITERIA_AGE_GREATER;
769         case MATCHCRITERIA_AGE_LOWER:
770                 return CRITERIA_AGE_LOWER;
771         case MATCHCRITERIA_SCORE_GREATER:
772                 return CRITERIA_SCORE_GREATER;
773         case MATCHCRITERIA_SCORE_LOWER:
774                 return CRITERIA_SCORE_LOWER;
775         case MATCHCRITERIA_SCORE_EQUAL:
776                 return CRITERIA_SCORE_EQUAL;
777         case MATCHCRITERIA_NOT_EXECUTE:
778         case MATCHCRITERIA_EXECUTE:
779                 return CRITERIA_EXECUTE;
780         case MATCHCRITERIA_SIZE_GREATER:
781                 return CRITERIA_SIZE_GREATER;
782         case MATCHCRITERIA_SIZE_SMALLER:
783                 return CRITERIA_SIZE_SMALLER;
784         case MATCHCRITERIA_SIZE_EQUAL:
785                 return CRITERIA_SIZE_EQUAL;
786         default:
787                 return -1;
788         }
789 }
790
791 static gint prefs_matcher_get_matching_from_criteria(gint criteria_id)
792 {
793         switch (criteria_id) {
794         case CRITERIA_ALL:
795                 return MATCHCRITERIA_ALL;
796         case CRITERIA_UNREAD:
797                 return MATCHCRITERIA_UNREAD;
798         case CRITERIA_NEW:
799                 return MATCHCRITERIA_NEW;
800         case CRITERIA_MARKED:
801                 return MATCHCRITERIA_MARKED;
802         case CRITERIA_DELETED:
803                 return MATCHCRITERIA_DELETED;
804         case CRITERIA_REPLIED:
805                 return MATCHCRITERIA_REPLIED;
806         case CRITERIA_FORWARDED:
807                 return MATCHCRITERIA_FORWARDED;
808         case CRITERIA_SUBJECT:
809                 return MATCHCRITERIA_SUBJECT;
810         case CRITERIA_FROM:
811                 return MATCHCRITERIA_FROM;
812         case CRITERIA_TO:
813                 return MATCHCRITERIA_TO;
814         case CRITERIA_CC:
815                 return MATCHCRITERIA_CC;
816         case CRITERIA_TO_OR_CC:
817                 return MATCHCRITERIA_TO_OR_CC;
818         case CRITERIA_NEWSGROUPS:
819                 return MATCHCRITERIA_NEWSGROUPS;
820         case CRITERIA_INREPLYTO:
821                 return MATCHCRITERIA_INREPLYTO;
822         case CRITERIA_REFERENCES:
823                 return MATCHCRITERIA_REFERENCES;
824         case CRITERIA_AGE_GREATER:
825                 return MATCHCRITERIA_AGE_GREATER;
826         case CRITERIA_AGE_LOWER:
827                 return MATCHCRITERIA_AGE_LOWER;
828         case CRITERIA_SCORE_GREATER:
829                 return MATCHCRITERIA_SCORE_GREATER;
830         case CRITERIA_SCORE_LOWER:
831                 return MATCHCRITERIA_SCORE_LOWER;
832         case CRITERIA_SCORE_EQUAL:
833                 return MATCHCRITERIA_SCORE_EQUAL;
834         case CRITERIA_HEADER:
835                 return MATCHCRITERIA_HEADER;
836         case CRITERIA_HEADERS_PART:
837                 return MATCHCRITERIA_HEADERS_PART;
838         case CRITERIA_BODY_PART:
839                 return MATCHCRITERIA_BODY_PART;
840         case CRITERIA_MESSAGE:
841                 return MATCHCRITERIA_MESSAGE;
842         case CRITERIA_EXECUTE:
843                 return MATCHCRITERIA_EXECUTE;
844         case CRITERIA_SIZE_GREATER:
845                 return MATCHCRITERIA_SIZE_GREATER;
846         case CRITERIA_SIZE_SMALLER:
847                 return MATCHCRITERIA_SIZE_SMALLER;
848         case CRITERIA_SIZE_EQUAL:
849                 return MATCHCRITERIA_SIZE_EQUAL;
850         default:
851                 return -1;
852         }
853 }
854
855 static gint prefs_matcher_not_criteria(gint matcher_criteria)
856 {
857         switch(matcher_criteria) {
858         case MATCHCRITERIA_UNREAD:
859                 return MATCHCRITERIA_NOT_UNREAD;
860         case MATCHCRITERIA_NEW:
861                 return MATCHCRITERIA_NOT_NEW;
862         case MATCHCRITERIA_MARKED:
863                 return MATCHCRITERIA_NOT_MARKED;
864         case MATCHCRITERIA_DELETED:
865                 return MATCHCRITERIA_NOT_DELETED;
866         case MATCHCRITERIA_REPLIED:
867                 return MATCHCRITERIA_NOT_REPLIED;
868         case MATCHCRITERIA_FORWARDED:
869                 return MATCHCRITERIA_NOT_FORWARDED;
870         case MATCHCRITERIA_SUBJECT:
871                 return MATCHCRITERIA_NOT_SUBJECT;
872         case MATCHCRITERIA_FROM:
873                 return MATCHCRITERIA_NOT_FROM;
874         case MATCHCRITERIA_TO:
875                 return MATCHCRITERIA_NOT_TO;
876         case MATCHCRITERIA_CC:
877                 return MATCHCRITERIA_NOT_CC;
878         case MATCHCRITERIA_TO_OR_CC:
879                 return MATCHCRITERIA_NOT_TO_AND_NOT_CC;
880         case MATCHCRITERIA_NEWSGROUPS:
881                 return MATCHCRITERIA_NOT_NEWSGROUPS;
882         case MATCHCRITERIA_INREPLYTO:
883                 return MATCHCRITERIA_NOT_INREPLYTO;
884         case MATCHCRITERIA_REFERENCES:
885                 return MATCHCRITERIA_NOT_REFERENCES;
886         case MATCHCRITERIA_HEADER:
887                 return MATCHCRITERIA_NOT_HEADER;
888         case MATCHCRITERIA_HEADERS_PART:
889                 return MATCHCRITERIA_NOT_HEADERS_PART;
890         case MATCHCRITERIA_MESSAGE:
891                 return MATCHCRITERIA_NOT_MESSAGE;
892         case MATCHCRITERIA_EXECUTE:
893                 return MATCHCRITERIA_NOT_EXECUTE;
894         case MATCHCRITERIA_BODY_PART:
895                 return MATCHCRITERIA_NOT_BODY_PART;
896         default:
897                 return matcher_criteria;
898         }
899 }
900
901 static MatcherProp * prefs_matcher_dialog_to_matcher()
902 {
903         MatcherProp * matcherprop;
904         gint criteria;
905         gint matchtype;
906         gint value_pred;
907         gint value_pred_flag;
908         gint value_criteria;
909         gboolean use_regexp;
910         gboolean case_sensitive;
911         gchar * header;
912         gchar * expr;
913         gint value;
914         gchar * value_str;
915
916         value_criteria = get_sel_from_list(GTK_LIST(matcher.criteria_list));
917
918         criteria = prefs_matcher_get_matching_from_criteria(value_criteria);
919
920         value_pred = get_sel_from_list(GTK_LIST(matcher.predicate_list));
921         value_pred_flag = get_sel_from_list(GTK_LIST(matcher.predicate_flag_list));
922
923         use_regexp = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(matcher.regexp_chkbtn));
924         case_sensitive = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(matcher.case_chkbtn));
925
926         switch (value_criteria) {
927         case CRITERIA_UNREAD:
928         case CRITERIA_NEW:
929         case CRITERIA_MARKED:
930         case CRITERIA_DELETED:
931         case CRITERIA_REPLIED:
932         case CRITERIA_FORWARDED:
933         case CRITERIA_EXECUTE:
934                 if (value_pred_flag == PREDICATE_FLAG_DISABLED)
935                         criteria = prefs_matcher_not_criteria(criteria);
936                 break;
937         case CRITERIA_SUBJECT:
938         case CRITERIA_FROM:
939         case CRITERIA_TO:
940         case CRITERIA_CC:
941         case CRITERIA_TO_OR_CC:
942         case CRITERIA_NEWSGROUPS:
943         case CRITERIA_INREPLYTO:
944         case CRITERIA_REFERENCES:
945         case CRITERIA_HEADERS_PART:
946         case CRITERIA_BODY_PART:
947         case CRITERIA_MESSAGE:
948         case CRITERIA_AGE_GREATER:
949         case CRITERIA_AGE_LOWER:
950         case CRITERIA_HEADER:
951                 if (value_pred == PREDICATE_DOES_NOT_CONTAIN)
952                         criteria = prefs_matcher_not_criteria(criteria);
953                 break;
954         }
955
956         if (use_regexp) {
957                 if (case_sensitive)
958                         matchtype = MATCHTYPE_REGEXP;
959                 else
960                         matchtype = MATCHTYPE_REGEXPCASE;
961         }
962         else {
963                 if (case_sensitive)
964                         matchtype = MATCHTYPE_MATCH;
965                 else
966                         matchtype = MATCHTYPE_MATCHCASE;
967         }
968
969         header = NULL;
970         expr = NULL;
971         value = 0;
972
973         switch (value_criteria) {
974         case CRITERIA_ALL:
975         case CRITERIA_UNREAD:
976         case CRITERIA_NEW:
977         case CRITERIA_MARKED:
978         case CRITERIA_DELETED:
979         case CRITERIA_REPLIED:
980         case CRITERIA_FORWARDED:
981                 break;
982
983         case CRITERIA_SUBJECT:
984         case CRITERIA_FROM:
985         case CRITERIA_TO:
986         case CRITERIA_CC:
987         case CRITERIA_TO_OR_CC:
988         case CRITERIA_NEWSGROUPS:
989         case CRITERIA_INREPLYTO:
990         case CRITERIA_REFERENCES:
991         case CRITERIA_HEADERS_PART:
992         case CRITERIA_BODY_PART:
993         case CRITERIA_MESSAGE:
994         case CRITERIA_EXECUTE:
995                 expr = gtk_entry_get_text(GTK_ENTRY(matcher.value_entry));
996                 break;
997
998         case CRITERIA_AGE_GREATER:
999         case CRITERIA_AGE_LOWER:
1000         case CRITERIA_SCORE_GREATER:
1001         case CRITERIA_SCORE_LOWER:
1002         case CRITERIA_SCORE_EQUAL:
1003         case CRITERIA_SIZE_GREATER:
1004         case CRITERIA_SIZE_SMALLER:
1005         case CRITERIA_SIZE_EQUAL:
1006                 value_str = gtk_entry_get_text(GTK_ENTRY(matcher.value_entry));
1007
1008                 if (*value_str == '\0') {
1009                     alertpanel_error(_("Value is not set."));
1010                     return NULL;
1011                 }
1012
1013                 value = atoi(value_str);
1014
1015                 break;
1016
1017         case CRITERIA_HEADER:
1018
1019                 header = gtk_entry_get_text(GTK_ENTRY(matcher.header_entry));
1020                 expr = gtk_entry_get_text(GTK_ENTRY(matcher.value_entry));
1021
1022                 if (*header == '\0') {
1023                     alertpanel_error(_("Header name is not set."));
1024                     return NULL;
1025                 }
1026                 break;
1027         }
1028
1029         matcherprop =  matcherprop_new(criteria, header, matchtype,
1030                                        expr, value);
1031
1032         return matcherprop;
1033 }
1034
1035 static void prefs_matcher_register_cb(void)
1036 {
1037         MatcherProp * matcherprop;
1038         
1039         matcherprop = prefs_matcher_dialog_to_matcher();
1040         if (matcherprop == NULL)
1041                 return;
1042
1043         prefs_matcher_clist_set_row(-1, matcherprop);
1044
1045         matcherprop_free(matcherprop);
1046
1047         prefs_matcher_reset_condition();
1048         prefs_matcher_update_hscrollbar();
1049 }
1050
1051 static void prefs_matcher_substitute_cb(void)
1052 {
1053         GtkCList *clist = GTK_CLIST(matcher.cond_clist);
1054         gint row;
1055         MatcherProp * matcherprop;
1056
1057         row = GPOINTER_TO_INT(clist->selection->data);
1058         if (row == 0)
1059                 return;
1060         
1061         matcherprop = prefs_matcher_dialog_to_matcher();
1062         if (matcherprop == NULL)
1063                 return;
1064
1065         prefs_matcher_clist_set_row(row, matcherprop);
1066
1067         matcherprop_free(matcherprop);
1068
1069         prefs_matcher_reset_condition();
1070         
1071         prefs_matcher_update_hscrollbar();
1072 }
1073
1074 static void prefs_matcher_delete_cb(void)
1075 {
1076         GtkCList *clist = GTK_CLIST(matcher.cond_clist);
1077         gint row;
1078
1079         if (!clist->selection) return;
1080         row = GPOINTER_TO_INT(clist->selection->data);
1081         if (row == 0)
1082                 return;
1083
1084         gtk_clist_remove(clist, row);
1085         
1086         prefs_matcher_update_hscrollbar();
1087 }
1088
1089 static void prefs_matcher_up(void)
1090 {
1091         GtkCList *clist = GTK_CLIST(matcher.cond_clist);
1092         gint row;
1093
1094         if (!clist->selection) return;
1095
1096         row = GPOINTER_TO_INT(clist->selection->data);
1097         if (row > 1) {
1098                 gtk_clist_row_move(clist, row, row - 1);
1099                 if(gtk_clist_row_is_visible(clist, row - 1) != GTK_VISIBILITY_FULL) {
1100                         gtk_clist_moveto(clist, row - 1, 0, 0, 0);
1101                 } 
1102         }
1103 }
1104
1105 static void prefs_matcher_down(void)
1106 {
1107         GtkCList *clist = GTK_CLIST(matcher.cond_clist);
1108         gint row;
1109
1110         if (!clist->selection) return;
1111
1112         row = GPOINTER_TO_INT(clist->selection->data);
1113         if (row >= 1 && row < clist->rows - 1) {
1114                 gtk_clist_row_move(clist, row, row + 1);
1115                 if(gtk_clist_row_is_visible(clist, row + 1) != GTK_VISIBILITY_FULL) {
1116                         gtk_clist_moveto(clist, row + 1, 0, 1, 0);
1117                 } 
1118         }
1119 }
1120
1121 static void prefs_matcher_select(GtkCList *clist, gint row, gint column,
1122                                  GdkEvent *event)
1123 {
1124         gchar * matcher_str;
1125         MatcherProp * prop;
1126         gboolean negative_cond;
1127         gint criteria;
1128
1129         if (!gtk_clist_get_text(GTK_CLIST(matcher.cond_clist),
1130                                 row, 0, &matcher_str))
1131                 return;
1132
1133         negative_cond = FALSE;
1134
1135         if (row == 0) {
1136                 prefs_matcher_reset_condition();
1137                 return;
1138         }
1139
1140         //      tmp = matcher_str;
1141         prop = matcher_parser_get_prop(matcher_str);
1142         if (prop == NULL)
1143                 return;
1144
1145         criteria = prefs_matcher_get_criteria_from_matching(prop->criteria);
1146         if (criteria != -1)
1147                 gtk_list_select_item(GTK_LIST(matcher.criteria_list),
1148                                      criteria);
1149
1150         switch(prop->criteria) {
1151         case MATCHCRITERIA_NOT_UNREAD:
1152         case MATCHCRITERIA_NOT_NEW:
1153         case MATCHCRITERIA_NOT_MARKED:
1154         case MATCHCRITERIA_NOT_DELETED:
1155         case MATCHCRITERIA_NOT_REPLIED:
1156         case MATCHCRITERIA_NOT_FORWARDED:
1157         case MATCHCRITERIA_NOT_SUBJECT:
1158         case MATCHCRITERIA_NOT_FROM:
1159         case MATCHCRITERIA_NOT_TO:
1160         case MATCHCRITERIA_NOT_CC:
1161         case MATCHCRITERIA_NOT_NEWSGROUPS:
1162         case MATCHCRITERIA_NOT_INREPLYTO:
1163         case MATCHCRITERIA_NOT_REFERENCES:
1164         case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
1165         case MATCHCRITERIA_NOT_BODY_PART:
1166         case MATCHCRITERIA_NOT_MESSAGE:
1167         case MATCHCRITERIA_NOT_HEADERS_PART:
1168         case MATCHCRITERIA_NOT_HEADER:
1169                 negative_cond = TRUE;
1170                 break;
1171         }
1172         
1173         switch(prop->criteria) {
1174         case MATCHCRITERIA_ALL:
1175                 break;
1176
1177         case MATCHCRITERIA_NOT_SUBJECT:
1178         case MATCHCRITERIA_NOT_FROM:
1179         case MATCHCRITERIA_NOT_TO:
1180         case MATCHCRITERIA_NOT_CC:
1181         case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
1182         case MATCHCRITERIA_NOT_NEWSGROUPS:
1183         case MATCHCRITERIA_NOT_INREPLYTO:
1184         case MATCHCRITERIA_NOT_REFERENCES:
1185         case MATCHCRITERIA_NOT_HEADERS_PART:
1186         case MATCHCRITERIA_NOT_BODY_PART:
1187         case MATCHCRITERIA_NOT_MESSAGE:
1188         case MATCHCRITERIA_SUBJECT:
1189         case MATCHCRITERIA_FROM:
1190         case MATCHCRITERIA_TO:
1191         case MATCHCRITERIA_CC:
1192         case MATCHCRITERIA_TO_OR_CC:
1193         case MATCHCRITERIA_NEWSGROUPS:
1194         case MATCHCRITERIA_INREPLYTO:
1195         case MATCHCRITERIA_REFERENCES:
1196         case MATCHCRITERIA_HEADERS_PART:
1197         case MATCHCRITERIA_BODY_PART:
1198         case MATCHCRITERIA_MESSAGE:
1199                 gtk_entry_set_text(GTK_ENTRY(matcher.value_entry), prop->expr);
1200                 break;
1201
1202         case MATCHCRITERIA_AGE_GREATER:
1203         case MATCHCRITERIA_AGE_LOWER:
1204         case MATCHCRITERIA_SCORE_GREATER:
1205         case MATCHCRITERIA_SCORE_LOWER:
1206         case MATCHCRITERIA_SCORE_EQUAL:
1207         case MATCHCRITERIA_SIZE_GREATER:
1208         case MATCHCRITERIA_SIZE_SMALLER:
1209         case MATCHCRITERIA_SIZE_EQUAL:
1210                 gtk_entry_set_text(GTK_ENTRY(matcher.value_entry), itos(prop->value));
1211                 break;
1212
1213         case MATCHCRITERIA_NOT_HEADER:
1214         case MATCHCRITERIA_HEADER:
1215                 gtk_entry_set_text(GTK_ENTRY(matcher.header_entry), prop->header);
1216                 gtk_entry_set_text(GTK_ENTRY(matcher.value_entry), prop->expr);
1217                 break;
1218         }
1219
1220         if (negative_cond)
1221                 gtk_list_select_item(GTK_LIST(matcher.predicate_list), 1);
1222         else
1223                 gtk_list_select_item(GTK_LIST(matcher.predicate_list), 0);
1224
1225         switch(prop->matchtype) {
1226         case MATCHTYPE_MATCH:
1227                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.regexp_chkbtn), FALSE);
1228                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.case_chkbtn), TRUE);
1229                 break;
1230
1231         case MATCHTYPE_MATCHCASE:
1232                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.regexp_chkbtn), FALSE);
1233                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.case_chkbtn), FALSE);
1234                 break;
1235
1236         case MATCHTYPE_REGEXP:
1237                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.regexp_chkbtn), TRUE);
1238                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.case_chkbtn), TRUE);
1239                 break;
1240
1241         case MATCHTYPE_REGEXPCASE:
1242                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.regexp_chkbtn), TRUE);
1243                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.case_chkbtn), FALSE);
1244                 break;
1245         }
1246 }
1247
1248 static void prefs_matcher_criteria_select(GtkList *list,
1249                                           GtkWidget *widget,
1250                                           gpointer user_data)
1251 {
1252         gint value;
1253
1254         value = get_sel_from_list(GTK_LIST(matcher.criteria_list));
1255
1256         switch (value) {
1257         case CRITERIA_ALL:
1258                 gtk_widget_set_sensitive(matcher.header_combo, FALSE);
1259                 gtk_widget_set_sensitive(matcher.header_label, FALSE);
1260                 gtk_widget_set_sensitive(matcher.value_label, FALSE);
1261                 gtk_widget_set_sensitive(matcher.value_entry, FALSE);
1262                 gtk_widget_set_sensitive(matcher.predicate_label, FALSE);
1263                 gtk_widget_set_sensitive(matcher.predicate_combo, FALSE);
1264                 gtk_widget_set_sensitive(matcher.predicate_flag_combo, FALSE);
1265                 gtk_widget_hide(matcher.predicate_combo);
1266                 gtk_widget_show(matcher.predicate_flag_combo);
1267                 gtk_widget_set_sensitive(matcher.case_chkbtn, FALSE);
1268                 gtk_widget_set_sensitive(matcher.regexp_chkbtn, FALSE);
1269                 gtk_widget_set_sensitive(matcher.exec_btn, FALSE);
1270                 break;
1271
1272         case CRITERIA_UNREAD:
1273         case CRITERIA_NEW:
1274         case CRITERIA_MARKED:
1275         case CRITERIA_DELETED:
1276         case CRITERIA_REPLIED:
1277         case CRITERIA_FORWARDED:
1278                 gtk_widget_set_sensitive(matcher.header_combo, FALSE);
1279                 gtk_widget_set_sensitive(matcher.header_label, FALSE);
1280                 gtk_widget_set_sensitive(matcher.value_label, FALSE);
1281                 gtk_widget_set_sensitive(matcher.value_entry, FALSE);
1282                 gtk_widget_set_sensitive(matcher.predicate_label, TRUE);
1283                 gtk_widget_set_sensitive(matcher.predicate_combo, FALSE);
1284                 gtk_widget_set_sensitive(matcher.predicate_flag_combo, TRUE);
1285                 gtk_widget_hide(matcher.predicate_combo);
1286                 gtk_widget_show(matcher.predicate_flag_combo);
1287                 gtk_widget_set_sensitive(matcher.case_chkbtn, FALSE);
1288                 gtk_widget_set_sensitive(matcher.regexp_chkbtn, FALSE);
1289                 gtk_widget_set_sensitive(matcher.exec_btn, FALSE);
1290                 break;
1291
1292         case CRITERIA_SUBJECT:
1293         case CRITERIA_FROM:
1294         case CRITERIA_TO:
1295         case CRITERIA_CC:
1296         case CRITERIA_TO_OR_CC:
1297         case CRITERIA_NEWSGROUPS:
1298         case CRITERIA_INREPLYTO:
1299         case CRITERIA_REFERENCES:
1300         case CRITERIA_HEADERS_PART:
1301         case CRITERIA_BODY_PART:
1302         case CRITERIA_MESSAGE:
1303                 gtk_widget_set_sensitive(matcher.header_combo, FALSE);
1304                 gtk_widget_set_sensitive(matcher.header_label, FALSE);
1305                 gtk_widget_set_sensitive(matcher.value_label, TRUE);
1306                 gtk_widget_set_sensitive(matcher.value_entry, TRUE);
1307                 gtk_widget_set_sensitive(matcher.predicate_label, TRUE);
1308                 gtk_widget_set_sensitive(matcher.predicate_combo, TRUE);
1309                 gtk_widget_set_sensitive(matcher.predicate_flag_combo, FALSE);
1310                 gtk_widget_show(matcher.predicate_combo);
1311                 gtk_widget_hide(matcher.predicate_flag_combo);
1312                 gtk_widget_set_sensitive(matcher.case_chkbtn, TRUE);
1313                 gtk_widget_set_sensitive(matcher.regexp_chkbtn, TRUE);
1314                 gtk_widget_set_sensitive(matcher.exec_btn, FALSE);
1315                 break;
1316
1317         case CRITERIA_EXECUTE:
1318                 gtk_widget_set_sensitive(matcher.header_combo, FALSE);
1319                 gtk_widget_set_sensitive(matcher.header_label, FALSE);
1320                 gtk_widget_set_sensitive(matcher.value_label, TRUE);
1321                 gtk_widget_set_sensitive(matcher.value_entry, TRUE);
1322                 gtk_widget_set_sensitive(matcher.predicate_label, TRUE);
1323                 gtk_widget_set_sensitive(matcher.predicate_combo, FALSE);
1324                 gtk_widget_set_sensitive(matcher.predicate_flag_combo, TRUE);
1325                 gtk_widget_hide(matcher.predicate_combo);
1326                 gtk_widget_show(matcher.predicate_flag_combo);
1327                 gtk_widget_set_sensitive(matcher.case_chkbtn, FALSE);
1328                 gtk_widget_set_sensitive(matcher.regexp_chkbtn, FALSE);
1329                 gtk_widget_set_sensitive(matcher.exec_btn, TRUE);
1330                 break;
1331
1332         case CRITERIA_AGE_GREATER:
1333         case CRITERIA_AGE_LOWER:
1334         case CRITERIA_SCORE_GREATER:
1335         case CRITERIA_SCORE_LOWER:
1336         case CRITERIA_SCORE_EQUAL:
1337         case CRITERIA_SIZE_GREATER:
1338         case CRITERIA_SIZE_SMALLER:
1339         case CRITERIA_SIZE_EQUAL:
1340                 gtk_widget_set_sensitive(matcher.header_combo, FALSE);
1341                 gtk_widget_set_sensitive(matcher.header_label, FALSE);
1342                 gtk_widget_set_sensitive(matcher.value_label, TRUE);
1343                 gtk_widget_set_sensitive(matcher.value_entry, TRUE);
1344                 gtk_widget_set_sensitive(matcher.predicate_label, FALSE);
1345                 gtk_widget_set_sensitive(matcher.predicate_combo, FALSE);
1346                 gtk_widget_set_sensitive(matcher.predicate_flag_combo, FALSE);
1347                 gtk_widget_show(matcher.predicate_combo);
1348                 gtk_widget_hide(matcher.predicate_flag_combo);
1349                 gtk_widget_set_sensitive(matcher.case_chkbtn, FALSE);
1350                 gtk_widget_set_sensitive(matcher.regexp_chkbtn, FALSE);
1351                 gtk_widget_set_sensitive(matcher.exec_btn, FALSE);
1352                 break;
1353
1354         case CRITERIA_HEADER:
1355                 gtk_widget_set_sensitive(matcher.header_combo, TRUE);
1356                 gtk_widget_set_sensitive(matcher.header_label, TRUE);
1357                 gtk_widget_set_sensitive(matcher.value_label, TRUE);
1358                 gtk_widget_set_sensitive(matcher.value_entry, TRUE);
1359                 gtk_widget_set_sensitive(matcher.predicate_label, TRUE);
1360                 gtk_widget_set_sensitive(matcher.predicate_combo, TRUE);
1361                 gtk_widget_set_sensitive(matcher.predicate_flag_combo, FALSE);
1362                 gtk_widget_show(matcher.predicate_combo);
1363                 gtk_widget_hide(matcher.predicate_flag_combo);
1364                 gtk_widget_set_sensitive(matcher.case_chkbtn, TRUE);
1365                 gtk_widget_set_sensitive(matcher.regexp_chkbtn, TRUE);
1366                 gtk_widget_set_sensitive(matcher.exec_btn, FALSE);
1367                 break;
1368         }
1369 }
1370
1371 static void prefs_matcher_key_pressed(GtkWidget *widget, GdkEventKey *event,
1372                                      gpointer data)
1373 {
1374         if (event && event->keyval == GDK_Escape)
1375                 prefs_matcher_cancel();
1376 }
1377
1378 static void prefs_matcher_cancel(void)
1379 {
1380         gtk_widget_hide(matcher.window);
1381         inc_unlock();
1382 }
1383
1384 static void prefs_matcher_ok(void)
1385 {
1386         MatcherList * matchers;
1387         MatcherProp * matcherprop;
1388         AlertValue val;
1389         gint criteria;
1390         gint value_criteria;
1391         gchar * matcher_str;
1392         gchar * str;
1393         gint row = 1;
1394
1395         matchers = prefs_matcher_get_list();
1396
1397         if (matchers != NULL) {
1398                 matcherprop = prefs_matcher_dialog_to_matcher();
1399                 if (matcherprop != NULL) {
1400                         str = matcherprop_to_string(matcherprop);
1401                         if(strcmp(str, "all") != 0) {
1402                                 while (gtk_clist_get_text(GTK_CLIST(matcher.cond_clist),
1403                                                   row, 0, &matcher_str)) {
1404                                         if (strcmp(matcher_str, str) == 0) break;
1405                                         row++;
1406                                 }
1407                                 if (strcmp(matcher_str, str) != 0) {
1408                                         val = alertpanel(_("Entry not registered"),
1409                                                  _("The entry was not registered\nAre you really finished?"),
1410                                                  _("Yes"), _("No"), NULL);
1411                                         if (G_ALERTDEFAULT != val) {
1412                                                 g_free(str);
1413                                                 return;
1414                                         }
1415                                 }
1416                         }
1417                 }
1418                 g_free(str);
1419                 gtk_widget_hide(matcher.window);
1420                 inc_unlock();
1421                 if (matchers_callback != NULL)
1422                         matchers_callback(matchers);
1423                 matcherlist_free(matchers);
1424         }
1425 }
1426
1427 static gint prefs_matcher_deleted(GtkWidget *widget, GdkEventAny *event,
1428                                   gpointer data)
1429 {
1430         prefs_matcher_cancel();
1431         return TRUE;
1432 }
1433
1434 static GtkWidget * exec_info_win;
1435
1436 void prefs_matcher_exec_info(void)
1437 {
1438         if (!exec_info_win)
1439                 prefs_matcher_exec_info_create();
1440
1441         gtk_widget_show(exec_info_win);
1442         gtk_main();
1443         gtk_widget_hide(exec_info_win);
1444 }
1445
1446 static void prefs_matcher_exec_info_create(void)
1447 {
1448         GtkWidget *vbox;
1449         GtkWidget *hbox;
1450         GtkWidget *hbbox;
1451         GtkWidget *label;
1452         GtkWidget *ok_btn;
1453
1454         exec_info_win = gtk_window_new(GTK_WINDOW_DIALOG);
1455         gtk_window_set_title(GTK_WINDOW(exec_info_win),
1456                              _("Description of symbols"));
1457         gtk_container_set_border_width(GTK_CONTAINER(exec_info_win), 8);
1458         gtk_window_set_position(GTK_WINDOW(exec_info_win), GTK_WIN_POS_CENTER);
1459         gtk_window_set_modal(GTK_WINDOW(exec_info_win), TRUE);
1460         gtk_window_set_policy(GTK_WINDOW(exec_info_win), FALSE, TRUE, FALSE);
1461
1462         vbox = gtk_vbox_new(FALSE, 8);
1463         gtk_container_add(GTK_CONTAINER(exec_info_win), vbox);
1464
1465         hbox = gtk_hbox_new(FALSE, 4);
1466         gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
1467
1468         label = gtk_label_new
1469                 ("%%:\n"
1470                  "%s:\n"
1471                  "%f:\n"
1472                  "%t:\n"
1473                  "%c:\n"
1474                  "%d:\n"
1475                  "%i:\n"
1476                  "%n:\n"
1477                  "%r:\n"
1478                  "%F:\n"
1479                  "\\n:\n"
1480                  "\\:\n"
1481                  "\\\":\n"
1482                  "%%:");
1483
1484         gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
1485         gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
1486
1487         label = gtk_label_new
1488                 (_("%\n"
1489                    "Subject\n"
1490                    "From\n"
1491                    "To\n"
1492                    "Cc\n"
1493                    "Date\n"
1494                    "Message-ID\n"
1495                    "Newsgroups\n"
1496                    "References\n"
1497                    "Filename - should not be modified\n"
1498                    "new line\n"
1499                    "escape character for quotes\n"
1500                    "quote character\n"
1501                    "%"));
1502
1503         gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
1504         gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
1505
1506         gtkut_button_set_create(&hbbox, &ok_btn, _("OK"),
1507                                 NULL, NULL, NULL, NULL);
1508         gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
1509
1510         gtk_widget_grab_default(ok_btn);
1511         gtk_signal_connect(GTK_OBJECT(ok_btn), "clicked",
1512                                   GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
1513
1514         gtk_signal_connect(GTK_OBJECT(exec_info_win), "delete_event",
1515                                           GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
1516
1517         gtk_widget_show_all(vbox);
1518 }