new matcher parser / bounce fix / rrr fixed
authorHoà Viêt Dinh <dinh.viet.hoa@free.fr>
Thu, 15 Nov 2001 22:41:46 +0000 (22:41 +0000)
committerHoà Viêt Dinh <dinh.viet.hoa@free.fr>
Thu, 15 Nov 2001 22:41:46 +0000 (22:41 +0000)
25 files changed:
ChangeLog.claws
configure.in
src/Makefile.am
src/compose.c
src/defs.h
src/filtering.c
src/filtering.h
src/folder.c
src/inc.c
src/main.c
src/mainwindow.c
src/matcher.c
src/matcher.h
src/matcher_parser.h
src/matcher_parser_lex.l
src/matcher_parser_parse.y
src/mbox.c
src/messageview.c
src/prefs_filtering.c
src/prefs_filtering.h
src/prefs_matcher.c
src/prefs_scoring.c
src/scoring.c
src/scoring.h
src/summaryview.c

index 7c262da..916a639 100644 (file)
@@ -1,3 +1,36 @@
+2001-11-15 [hoa]       0.6.5claws15
+
+       * src/compose.c
+               fix bounce, mails we received couln't be bounced to ourself.
+
+       * src/defs.h
+       * src/filtering.[ch]
+       * src/matcher.[ch]
+       * src/matcher_parser.h
+       * src/matcher_parser_lex.l
+       * src/matcher_parser_parse.y
+       * src/inc.c
+       * src/main.c
+       * src/mbox.c
+       * src/prefs_filtering.[ch]
+       * src/mainwindow.c
+       * src/prefs_matcher.c
+       * src/prefs_scoring.c
+       * src/scoring.[ch]
+       * src/summaryview.c
+               new matcher/filter/score configuration file parser
+               one unique configuration file => ~/.sylpheed/matcherrc
+               import in currently automatic, then save are made
+               in this new file.
+               one filter per folder and one global filter
+               (filter of a folder will be used as folder processing)
+
+       * src/folder.c
+               fix a bug in folder_item_get_identifier
+               
+       * src/messageview.c
+               receive receipt return are fixed.
+
 2001-11-14 [alfons]    0.6.5claws14
 
        * src/session.h
index 131d3b4..a1597a9 100644 (file)
@@ -8,7 +8,7 @@ MINOR_VERSION=6
 MICRO_VERSION=5
 INTERFACE_AGE=0
 BINARY_AGE=0
-EXTRA_VERSION=claws14
+EXTRA_VERSION=claws15
 VERSION=$MAJOR_VERSION.$MINOR_VERSION.$MICRO_VERSION$EXTRA_VERSION
 
 dnl
index 315cadf..4663fec 100644 (file)
@@ -119,12 +119,17 @@ sylpheed_SOURCES = \
        mbox_folder.c mbox_folder.h \
        quote_fmt_lex.l quote_fmt_lex.h \
        quote_fmt_parse.y quote_fmt.h \
-       gtkspell.c gtkspell.h gtkxtext.h
+       gtkspell.c gtkspell.h gtkxtext.h \
+       matcher_parser_lex.l matcher_parser_lex.h \
+       matcher_parser_parse.y matcher_parser.h
 
 BUILT_SOURCES = \
        quote_fmt_lex.c \
        quote_fmt_parse.c \
-       quote_fmt_parse.h
+       quote_fmt_parse.h \
+       matcher_parser_lex.c \
+       matcher_parser_parse.c \
+       matcher_parser_parse.h
 
 EXTRA_DIST = \
        quote_fmt_parse.h \
index 8c745c3..a28f66a 100644 (file)
@@ -2772,6 +2772,12 @@ static gint compose_bounce_write_to_file(Compose *compose, const gchar *file)
        }
 
        while (procheader_get_unfolded_line(buf, sizeof(buf), fp)) {
+               /* should filter returnpath, delivered-to */
+               if ((g_strncasecmp(buf, "Return-Path:",
+                                  strlen("Return-Path:")) == 0)
+                   || (g_strncasecmp(buf, "Delivered-To:",
+                                     strlen("Delivered-To:")) == 0))
+                       continue;
                if (fputs(buf, fdest) == -1)
                        goto error;
                if (fputs("\n", fdest) == -1)
index d8a1982..e5d7870 100644 (file)
@@ -50,6 +50,7 @@
 #define FOLDERITEM_RC           "folderitemrc"
 #define SCORING_RC              "scoringrc"
 #define FILTERING_RC           "filteringrc"
+#define MATCHER_RC             "matcherrc"
 #define MENU_RC                        "menurc"
 #define COMMAND_HISTORY                "command_history"
 #define TEMPLATE_DIR           "templates"
index ccb8ffe..3c8891b 100644 (file)
@@ -50,7 +50,7 @@
 
 #define PREFSBUFSIZE           1024
 
-GSList * prefs_filtering = NULL;
+GSList * global_processing = NULL;
 
 FilteringAction * filteringaction_new(int type, int account_id,
                                      gchar * destination,
@@ -75,6 +75,7 @@ void filteringaction_free(FilteringAction * action)
        g_free(action);
 }
 
+/*
 FilteringAction * filteringaction_parse(gchar ** str)
 {
        FilteringAction * action;
@@ -89,27 +90,27 @@ FilteringAction * filteringaction_parse(gchar ** str)
        key = matcher_parse_keyword(&tmp);
 
        switch (key) {
-       case MATCHING_ACTION_MOVE:
-       case MATCHING_ACTION_COPY:
-       case MATCHING_EXECUTE:
+       case MATCHACTION_MOVE:
+       case MATCHACTION_COPY:
+       case MATCHACTION_EXECUTE:
                destination = matcher_parse_str(&tmp);
                if (tmp == NULL) {
                        * str = NULL;
                        return NULL;
                }
                break;
-       case MATCHING_ACTION_DELETE:
+       case MATCHACTION_DELETE:
                break;
-       case MATCHING_ACTION_MARK:
+       case MATCHACTION_MARK:
                break;
-       case MATCHING_ACTION_MARK_AS_READ:
+       case MATCHACTION_MARK_AS_READ:
                break;
-       case MATCHING_ACTION_UNMARK:
+       case MATCHACTION_UNMARK:
                break;
-       case MATCHING_ACTION_MARK_AS_UNREAD:
+       case MATCHACTION_MARK_AS_UNREAD:
                break;
-       case MATCHING_ACTION_FORWARD:
-       case MATCHING_ACTION_FORWARD_AS_ATTACHMENT:
+       case MATCHACTION_FORWARD:
+       case MATCHACTION_FORWARD_AS_ATTACHMENT:
                account_id = matcher_parse_number(&tmp);
                if (tmp == NULL) {
                        * str = NULL;
@@ -123,7 +124,7 @@ FilteringAction * filteringaction_parse(gchar ** str)
                }
 
                break;
-       case MATCHING_ACTION_COLOR:
+       case MATCHACTION_COLOR:
                labelcolor = matcher_parse_number(&tmp);
                if (tmp == NULL) {
                        *str = NULL;
@@ -177,7 +178,7 @@ FilteringProp * filteringprop_parse(gchar ** str)
        * str = tmp;
        return filtering;
 }
-
+*/
 
 FilteringProp * filteringprop_new(MatcherList * matchers,
                                  FilteringAction * action)
@@ -421,7 +422,7 @@ static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info,
        gchar * cmd;
 
        switch(action->type) {
-       case MATCHING_ACTION_MOVE:
+       case MATCHACTION_MOVE:
                dest_folder =
                        folder_find_item_from_identifier(action->destination);
                if (!dest_folder)
@@ -455,7 +456,7 @@ static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info,
                }
                return TRUE;
 
-       case MATCHING_ACTION_COPY:
+       case MATCHACTION_COPY:
                dest_folder =
                        folder_find_item_from_identifier(action->destination);
 
@@ -481,7 +482,7 @@ static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info,
                        
                return TRUE;
 
-       case MATCHING_ACTION_DELETE:
+       case MATCHACTION_DELETE:
                if (folder_item_remove_msg(info->folder, info->msgnum) == -1)
                        return FALSE;
 
@@ -494,7 +495,7 @@ static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info,
 
                return TRUE;
 
-       case MATCHING_ACTION_MARK:
+       case MATCHACTION_MARK:
                MSG_SET_PERM_FLAGS(info->flags, MSG_MARKED);
                debug_print("*** MARKING message %d, in folder %s, \"%s\"\n",
                            info->msgnum, info->folder->name,
@@ -505,7 +506,7 @@ static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info,
 
                return TRUE;
 
-       case MATCHING_ACTION_UNMARK:
+       case MATCHACTION_UNMARK:
                MSG_UNSET_PERM_FLAGS(info->flags, MSG_MARKED);
                filteringaction_update_mark(info);
 
@@ -513,7 +514,7 @@ static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info,
 
                return TRUE;
                
-       case MATCHING_ACTION_MARK_AS_READ:
+       case MATCHACTION_MARK_AS_READ:
                MSG_UNSET_PERM_FLAGS(info->flags, MSG_UNREAD | MSG_NEW);
                filteringaction_update_mark(info);
 
@@ -521,7 +522,7 @@ static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info,
 
                return TRUE;
 
-       case MATCHING_ACTION_MARK_AS_UNREAD:
+       case MATCHACTION_MARK_AS_UNREAD:
                MSG_SET_PERM_FLAGS(info->flags, MSG_UNREAD | MSG_NEW);
                filteringaction_update_mark(info);
 
@@ -529,7 +530,7 @@ static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info,
                
                return TRUE;
 
-       case MATCHING_ACTION_FORWARD:
+       case MATCHACTION_FORWARD:
 
                account = account_find_from_id(action->account_id);
                compose = compose_forward(account, info, FALSE);
@@ -549,7 +550,7 @@ static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info,
                gtk_widget_destroy(compose->window);
                return FALSE;
 
-       case MATCHING_ACTION_FORWARD_AS_ATTACHMENT:
+       case MATCHACTION_FORWARD_AS_ATTACHMENT:
 
                account = account_find_from_id(action->account_id);
                compose = compose_forward(account, info, TRUE);
@@ -569,7 +570,7 @@ static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info,
                gtk_widget_destroy(compose->window);
                return FALSE;
 
-       case MATCHING_EXECUTE:
+       case MATCHACTION_EXECUTE:
 
                cmd = matching_build_command(action->destination, info);
                if (cmd == NULL)
@@ -622,17 +623,17 @@ static gboolean filteringprop_apply(FilteringProp * filtering, MsgInfo * info,
                g_free(action_str);
 
                switch(filtering->action->type) {
-               case MATCHING_ACTION_MOVE:
-               case MATCHING_ACTION_DELETE:
+               case MATCHACTION_MOVE:
+               case MATCHACTION_DELETE:
                        return TRUE; /* MsgInfo invalid for message */
-               case MATCHING_EXECUTE:
-               case MATCHING_ACTION_COPY:
-               case MATCHING_ACTION_MARK:
-               case MATCHING_ACTION_MARK_AS_READ:
-               case MATCHING_ACTION_UNMARK:
-               case MATCHING_ACTION_MARK_AS_UNREAD:
-               case MATCHING_ACTION_FORWARD:
-               case MATCHING_ACTION_FORWARD_AS_ATTACHMENT:
+               case MATCHACTION_EXECUTE:
+               case MATCHACTION_COPY:
+               case MATCHACTION_MARK:
+               case MATCHACTION_MARK_AS_READ:
+               case MATCHACTION_UNMARK:
+               case MATCHACTION_MARK_AS_UNREAD:
+               case MATCHACTION_FORWARD:
+               case MATCHACTION_FORWARD_AS_ATTACHMENT:
                        return FALSE; /* MsgInfo still valid for message */
                default:
                        return FALSE;
@@ -674,8 +675,8 @@ void filter_msginfo_move_or_delete(GSList * filtering_list, MsgInfo * info,
                FilteringProp * filtering = (FilteringProp *) l->data;
 
                switch (filtering->action->type) {
-               case MATCHING_ACTION_MOVE:
-               case MATCHING_ACTION_DELETE:
+               case MATCHACTION_MOVE:
+               case MATCHACTION_DELETE:
                        if (filteringprop_apply(filtering, info, folder_table))
                                return;
                }
@@ -820,7 +821,7 @@ static gboolean filter_incoming_perform_actions(FolderItem *default_folder,
        MsgFlags     markflags = { 0, 0 };
 
        /* use the global prefs_filtering list */
-       GSList *     list = prefs_filtering;
+       GSList *     list = global_processing;
 
        /* things we get after having added a message to a folder */
        FolderItem  *dest_folder;
@@ -863,31 +864,31 @@ static gboolean filter_incoming_perform_actions(FolderItem *default_folder,
        for (ma_tail = &ma_head, stop = FALSE; ma_tail->action && !stop; ma_tail = ma_tail->next) {
                switch (ma_tail->action->type) {
                
-               case MATCHING_ACTION_MARK:
+               case MATCHACTION_MARK:
                        MSG_SET_PERM_FLAGS(markflags, MSG_MARKED);
                        break;
                        
-               case MATCHING_ACTION_UNMARK:
+               case MATCHACTION_UNMARK:
                        MSG_UNSET_PERM_FLAGS(markflags, MSG_MARKED);
                        break;
                
-               case MATCHING_ACTION_MARK_AS_READ:
+               case MATCHACTION_MARK_AS_READ:
                        MSG_UNSET_PERM_FLAGS(markflags, MSG_UNREAD);
                        break;
 
-               case MATCHING_ACTION_MARK_AS_UNREAD:                    
+               case MATCHACTION_MARK_AS_UNREAD:                        
                        MSG_SET_PERM_FLAGS(markflags, MSG_UNREAD);
                        break;
 
-               case MATCHING_ACTION_COLOR:
+               case MATCHACTION_COLOR:
                        MSG_SET_COLORLABEL_VALUE(markflags, ma_tail->action->labelcolor);
                        break;
 
                /* UNCONTINUABLE */
-               case MATCHING_ACTION_FORWARD:
-               case MATCHING_ACTION_FORWARD_AS_ATTACHMENT:
-               case MATCHING_ACTION_MOVE:
-               case MATCHING_ACTION_DELETE:
+               case MATCHACTION_FORWARD:
+               case MATCHACTION_FORWARD_AS_ATTACHMENT:
+               case MATCHACTION_MOVE:
+               case MATCHACTION_DELETE:
                        stop = TRUE;
                        break;
                
@@ -918,7 +919,7 @@ static gboolean filter_incoming_perform_actions(FolderItem *default_folder,
 
                /* C O N T I N U A B L E */
 
-               if (MATCHING_ACTION_COPY == ACTION) {
+               if (MATCHACTION_COPY == ACTION) {
                        debug_print("*** performing copy\n");
                        copy_to_inbox_too = TRUE;
                        if (!prepare_destination(ma_tail->action->destination, &dest_folder, folder_table)) {
@@ -933,7 +934,7 @@ static gboolean filter_incoming_perform_actions(FolderItem *default_folder,
                        flags = msginfo->flags.perm_flags | markflags.perm_flags;
                        add_mark(dest_folder, msgnum, flags);
                }               
-               else if (MATCHING_EXECUTE == ACTION) {
+               else if (MATCHACTION_EXECUTE == ACTION) {
                        debug_print("*** performing exec\n");
                        copy_to_inbox_too = TRUE;
                        
@@ -949,8 +950,8 @@ static gboolean filter_incoming_perform_actions(FolderItem *default_folder,
 
                /* U N C O N T I N U A B L E */
                
-               else if (MATCHING_ACTION_FORWARD == ACTION
-               ||       MATCHING_ACTION_FORWARD_AS_ATTACHMENT == ACTION) {
+               else if (MATCHACTION_FORWARD == ACTION
+               ||       MATCHACTION_FORWARD_AS_ATTACHMENT == ACTION) {
                        debug_print("*** performing forward\n");
 
                        /* forwarding messages is complicated because there's currently no 
@@ -978,7 +979,7 @@ static gboolean filter_incoming_perform_actions(FolderItem *default_folder,
 
                        /* do the compose_XXX stuff */
                        account = account_find_from_id(ma_tail->action->account_id);
-                       compose = compose_forward(account, fwd_msg, ACTION == MATCHING_ACTION_FORWARD ? FALSE : TRUE);
+                       compose = compose_forward(account, fwd_msg, ACTION == MATCHACTION_FORWARD ? FALSE : TRUE);
                        if (compose->account->protocol == A_NNTP)
                                compose_entry_append(compose, ma_tail->action->destination,
                                                     COMPOSE_NEWSGROUPS);
@@ -993,7 +994,7 @@ static gboolean filter_incoming_perform_actions(FolderItem *default_folder,
                        gtk_widget_destroy(compose->window);
                        break;
                }                       
-               else if (MATCHING_ACTION_DELETE == ACTION) {
+               else if (MATCHACTION_DELETE == ACTION) {
                        debug_print("*** performing delete\n");
                        copy_to_inbox_too = FALSE;
 
@@ -1010,7 +1011,7 @@ static gboolean filter_incoming_perform_actions(FolderItem *default_folder,
                        }
                        break;                          
                }
-               else if (MATCHING_ACTION_MOVE == ACTION) {
+               else if (MATCHACTION_MOVE == ACTION) {
                        debug_print("*** performing move\n");
                        copy_to_inbox_too = FALSE;
                        
@@ -1090,10 +1091,14 @@ void filter_incoming_message(FolderItem *default_folder, const gchar *file_name,
        procmsg_msginfo_free(msginfo);
 }
 
-/******************************************************************************/
+/****************************************************************************/
 
+
+
+/*
 void prefs_filtering_read_config(void)
 {
+
        gchar *rcpath;
        FILE *fp;
        gchar buf[PREFSBUFSIZE];
@@ -1109,8 +1114,9 @@ void prefs_filtering_read_config(void)
                return;
        }
        g_free(rcpath);
-
+       */
        /* remove all filtering */
+       /*
        while (prefs_filtering != NULL) {
                FilteringProp * filtering =
                        (FilteringProp *) prefs_filtering->data;
@@ -1133,7 +1139,9 @@ void prefs_filtering_read_config(void)
                                                       filtering);
                        }
                        else {
+       */
                                /* debug */
+       /*
                                g_warning(_("syntax error : %s\n"), buf);
                        }
                }
@@ -1141,6 +1149,7 @@ void prefs_filtering_read_config(void)
 
        fclose(fp);
 }
+*/
 
 gchar * filteringaction_to_string(FilteringAction * action)
 {
@@ -1158,27 +1167,27 @@ gchar * filteringaction_to_string(FilteringAction * action)
                return NULL;
 
        switch(action->type) {
-       case MATCHING_ACTION_MOVE:
-       case MATCHING_ACTION_COPY:
-       case MATCHING_EXECUTE:
+       case MATCHACTION_MOVE:
+       case MATCHACTION_COPY:
+       case MATCHACTION_EXECUTE:
                return g_strconcat(command_str, " \"", action->destination,
                                   "\"", NULL);
 
-       case MATCHING_ACTION_DELETE:
-       case MATCHING_ACTION_MARK:
-       case MATCHING_ACTION_UNMARK:
-       case MATCHING_ACTION_MARK_AS_READ:
-       case MATCHING_ACTION_MARK_AS_UNREAD:
+       case MATCHACTION_DELETE:
+       case MATCHACTION_MARK:
+       case MATCHACTION_UNMARK:
+       case MATCHACTION_MARK_AS_READ:
+       case MATCHACTION_MARK_AS_UNREAD:
                return g_strdup(command_str);
                break;
 
-       case MATCHING_ACTION_FORWARD:
-       case MATCHING_ACTION_FORWARD_AS_ATTACHMENT:
+       case MATCHACTION_FORWARD:
+       case MATCHACTION_FORWARD_AS_ATTACHMENT:
                account_id_str = itos(action->account_id);
                return g_strconcat(command_str, " ", account_id_str,
                                   " \"", action->destination, "\"", NULL);
 
-       case MATCHING_ACTION_COLOR:
+       case MATCHACTION_COLOR:
                labelcolor_str = itos(action->labelcolor);
                return g_strconcat(command_str, " ", labelcolor_str, NULL);  
 
@@ -1214,6 +1223,7 @@ gchar * filteringprop_to_string(FilteringProp * prop)
 
 void prefs_filtering_write_config(void)
 {
+       /*
        gchar *rcpath;
        PrefFile *pfile;
        GSList *cur;
@@ -1229,7 +1239,7 @@ void prefs_filtering_write_config(void)
                return;
        }
 
-       for (cur = prefs_filtering; cur != NULL; cur = cur->next) {
+       for (cur = global_processing; cur != NULL; cur = cur->next) {
                gchar *filtering_str;
 
                prop = (FilteringProp *) cur->data;
@@ -1252,4 +1262,44 @@ void prefs_filtering_write_config(void)
                g_warning(_("failed to write configuration to file\n"));
                return;
        }
+       */
+}
+
+void prefs_filtering_free(GSList * prefs_filtering)
+{
+       while (prefs_filtering != NULL) {
+               FilteringProp * filtering = (FilteringProp *)
+                       prefs_filtering->data;
+               filteringprop_free(filtering);
+               prefs_filtering = g_slist_remove(prefs_filtering, filtering);
+       }
+}
+
+static gboolean prefs_filtering_free_func(GNode *node, gpointer data)
+{
+       FolderItem *item = node->data;
+
+       if(!item->prefs)
+               return FALSE;
+
+       prefs_filtering_free(item->prefs->processing);
+       item->prefs->processing = NULL;
+
+       return FALSE;
+}
+
+void prefs_filtering_clear()
+{
+       GList * cur;
+
+       for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
+               Folder *folder;
+
+               folder = (Folder *) cur->data;
+               g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
+                               prefs_filtering_free_func, NULL);
+       }
+
+       prefs_filtering_free(global_processing);
+       global_processing = NULL;
 }
index 113e33b..4c650f9 100644 (file)
@@ -41,7 +41,7 @@ struct _FilteringProp {
 
 typedef struct _FilteringProp FilteringProp;
 
-extern GSList * prefs_filtering;
+/* extern GSList * prefs_filtering; */
 
 
 FilteringAction * filteringaction_new(int type, int account_id,
@@ -71,4 +71,9 @@ void prefs_filtering_write_config(void);
 void prefs_filtering_read_config(void);
 gchar * filteringprop_to_string(FilteringProp * prop);
 
+void prefs_filtering_clear();
+void prefs_filtering_free(GSList * prefs_filtering);
+
+extern GSList * global_processing;
+
 #endif
index 42cb5c6..1f46786 100644 (file)
@@ -1427,7 +1427,7 @@ gchar * folder_item_get_identifier(FolderItem * item)
        gchar * id;
        gchar * folder_str;
 
-       g_return_if_fail(item->path != NULL);
+       g_return_val_if_fail(item->path != NULL, NULL);
 
        folder_str = folder_get_identifier(item->folder);
        id = g_strconcat(folder_str, "/", item->path, NULL);
index f1f3c3f..12fb15b 100644 (file)
--- a/src/inc.c
+++ b/src/inc.c
@@ -910,7 +910,7 @@ gint inc_drop_message(const gchar *file, Pop3State *state)
                return -1;
        }
 
-       if (prefs_filtering == NULL) {
+       if (global_processing == NULL) {
                /* old filtering */
                if (state->ac_prefs->filter_on_recv) {
                        dropfolder =
@@ -935,7 +935,7 @@ gint inc_drop_message(const gchar *file, Pop3State *state)
                                    GINT_TO_POINTER(1));
        }
 
-       if (prefs_filtering == NULL || !state->ac_prefs->filter_on_recv) {
+       if (global_processing == NULL || !state->ac_prefs->filter_on_recv) {
                if ((msgnum = folder_item_add_msg(dropfolder, file, TRUE)) < 0) {
                        unlink(file);
                        return -1;
index 464ea2f..b0b05b3 100644 (file)
@@ -248,7 +248,7 @@ int main(int argc, char *argv[])
        prefs_filter_write_config();
        prefs_display_header_read_config();
        prefs_display_header_write_config();
-       prefs_filtering_read_config();
+       /* prefs_filtering_read_config(); */
        addressbook_read_file();
 
        gtkut_widget_init();
@@ -278,7 +278,8 @@ int main(int argc, char *argv[])
        account_set_missing_folder();
        folderview_set(folderview);
 
-       prefs_scoring_read_config();
+       /* prefs_scoring_read_config(); */
+       prefs_matcher_read_config();
 
        addressbook_read_file();
 
index 0b0badf..683c768 100644 (file)
@@ -2727,7 +2727,7 @@ static void prefs_scoring_open_cb(MainWindow *mainwin, guint action,
 static void prefs_filtering_open_cb(MainWindow *mainwin, guint action,
                                    GtkWidget *widget)
 {
-       prefs_filtering_open();
+       prefs_filtering_open(NULL);
 }
 
 static void prefs_template_open_cb(MainWindow *mainwin, guint action,
index fdcd379..3742204 100644 (file)
@@ -34,6 +34,8 @@
 #include "procheader.h"
 #include "matcher.h"
 #include "intl.h"
+#include "matcher_parser.h"
+#include "prefs.h"
 
 struct _MatchParser {
        gint id;
@@ -44,76 +46,75 @@ typedef struct _MatchParser MatchParser;
 
 static MatchParser matchparser_tab[] = {
        /* msginfo flags */
-       {MATCHING_ALL, "all"},
-       {MATCHING_UNREAD, "unread"},
-       {MATCHING_NOT_UNREAD, "~unread"},
-       {MATCHING_NEW, "new"},
-       {MATCHING_NOT_NEW, "~new"},
-       {MATCHING_MARKED, "marked"},
-       {MATCHING_NOT_MARKED, "~marked"},
-       {MATCHING_DELETED, "deleted"},
-       {MATCHING_NOT_DELETED, "~deleted"},
-       {MATCHING_REPLIED, "replied"},
-       {MATCHING_NOT_REPLIED, "~replied"},
-       {MATCHING_FORWARDED, "forwarded"},
-       {MATCHING_NOT_FORWARDED, "~forwarded"},
+       {MATCHCRITERIA_ALL, "all"},
+       {MATCHCRITERIA_UNREAD, "unread"},
+       {MATCHCRITERIA_NOT_UNREAD, "~unread"},
+       {MATCHCRITERIA_NEW, "new"},
+       {MATCHCRITERIA_NOT_NEW, "~new"},
+       {MATCHCRITERIA_MARKED, "marked"},
+       {MATCHCRITERIA_NOT_MARKED, "~marked"},
+       {MATCHCRITERIA_DELETED, "deleted"},
+       {MATCHCRITERIA_NOT_DELETED, "~deleted"},
+       {MATCHCRITERIA_REPLIED, "replied"},
+       {MATCHCRITERIA_NOT_REPLIED, "~replied"},
+       {MATCHCRITERIA_FORWARDED, "forwarded"},
+       {MATCHCRITERIA_NOT_FORWARDED, "~forwarded"},
 
        /* msginfo headers */
-       {MATCHING_SUBJECT, "subject"},
-       {MATCHING_NOT_SUBJECT, "~subject"},
-       {MATCHING_FROM, "from"},
-       {MATCHING_NOT_FROM, "~from"},
-       {MATCHING_TO, "to"},
-       {MATCHING_NOT_TO, "~to"},
-       {MATCHING_CC, "cc"},
-       {MATCHING_NOT_CC, "~cc"},
-       {MATCHING_TO_OR_CC, "to_or_cc"},
-       {MATCHING_NOT_TO_AND_NOT_CC, "~to_or_cc"},
-       {MATCHING_AGE_GREATER, "age_greater"},
-       {MATCHING_AGE_LOWER, "age_lower"},
-       {MATCHING_NEWSGROUPS, "newsgroups"},
-       {MATCHING_NOT_NEWSGROUPS, "~newsgroups"},
-       {MATCHING_INREPLYTO, "inreplyto"},
-       {MATCHING_NOT_INREPLYTO, "~inreplyto"},
-       {MATCHING_REFERENCES, "references"},
-       {MATCHING_NOT_REFERENCES, "~references"},
-       {MATCHING_SCORE_GREATER, "score_greater"},
-       {MATCHING_SCORE_LOWER, "score_lower"},
-       {MATCHING_SCORE_EQUAL, "score_equal"},
+       {MATCHCRITERIA_SUBJECT, "subject"},
+       {MATCHCRITERIA_NOT_SUBJECT, "~subject"},
+       {MATCHCRITERIA_FROM, "from"},
+       {MATCHCRITERIA_NOT_FROM, "~from"},
+       {MATCHCRITERIA_TO, "to"},
+       {MATCHCRITERIA_NOT_TO, "~to"},
+       {MATCHCRITERIA_CC, "cc"},
+       {MATCHCRITERIA_NOT_CC, "~cc"},
+       {MATCHCRITERIA_TO_OR_CC, "to_or_cc"},
+       {MATCHCRITERIA_NOT_TO_AND_NOT_CC, "~to_or_cc"},
+       {MATCHCRITERIA_AGE_GREATER, "age_greater"},
+       {MATCHCRITERIA_AGE_LOWER, "age_lower"},
+       {MATCHCRITERIA_NEWSGROUPS, "newsgroups"},
+       {MATCHCRITERIA_NOT_NEWSGROUPS, "~newsgroups"},
+       {MATCHCRITERIA_INREPLYTO, "inreplyto"},
+       {MATCHCRITERIA_NOT_INREPLYTO, "~inreplyto"},
+       {MATCHCRITERIA_REFERENCES, "references"},
+       {MATCHCRITERIA_NOT_REFERENCES, "~references"},
+       {MATCHCRITERIA_SCORE_GREATER, "score_greater"},
+       {MATCHCRITERIA_SCORE_LOWER, "score_lower"},
+       {MATCHCRITERIA_SCORE_EQUAL, "score_equal"},
 
        /* content have to be read */
-       {MATCHING_HEADER, "header"},
-       {MATCHING_NOT_HEADER, "~header"},
-       {MATCHING_HEADERS_PART, "headers_part"},
-       {MATCHING_NOT_HEADERS_PART, "~headers_part"},
-       {MATCHING_MESSAGE, "message"},
-       {MATCHING_NOT_MESSAGE, "~message"},
-       {MATCHING_BODY_PART, "body_part"},
-       {MATCHING_NOT_BODY_PART, "~body_part"},
-       {MATCHING_EXECUTE, "execute"},
-       {MATCHING_NOT_EXECUTE, "~execute"},
+       {MATCHCRITERIA_HEADER, "header"},
+       {MATCHCRITERIA_NOT_HEADER, "~header"},
+       {MATCHCRITERIA_HEADERS_PART, "headers_part"},
+       {MATCHCRITERIA_NOT_HEADERS_PART, "~headers_part"},
+       {MATCHCRITERIA_MESSAGE, "message"},
+       {MATCHCRITERIA_NOT_MESSAGE, "~message"},
+       {MATCHCRITERIA_BODY_PART, "body_part"},
+       {MATCHCRITERIA_NOT_BODY_PART, "~body_part"},
+       {MATCHCRITERIA_EXECUTE, "execute"},
+       {MATCHCRITERIA_NOT_EXECUTE, "~execute"},
 
        /* match type */
-       {MATCHING_MATCHCASE, "matchcase"},
-       {MATCHING_MATCH, "match"},
-       {MATCHING_REGEXPCASE, "regexpcase"},
-       {MATCHING_REGEXP, "regexp"},
+       {MATCHTYPE_MATCHCASE, "matchcase"},
+       {MATCHTYPE_MATCH, "match"},
+       {MATCHTYPE_REGEXPCASE, "regexpcase"},
+       {MATCHTYPE_REGEXP, "regexp"},
 
        /* actions */
-       {MATCHING_SCORE, "score"},
-
-       /* actions */
-       {MATCHING_ACTION_MOVE, "move"},
-       {MATCHING_ACTION_COPY, "copy"},
-       {MATCHING_ACTION_DELETE, "delete"},
-       {MATCHING_ACTION_MARK, "mark"},
-       {MATCHING_ACTION_UNMARK, "unmark"},
-       {MATCHING_ACTION_MARK_AS_READ, "mark_as_read"},
-       {MATCHING_ACTION_MARK_AS_UNREAD, "mark_as_unread"},
-       {MATCHING_ACTION_FORWARD, "forward"},
-       {MATCHING_ACTION_FORWARD_AS_ATTACHMENT, "forward_as_attachment"},
-       {MATCHING_ACTION_COLOR, "color"}
-       /*      {MATCHING_EXECUTE, "execute"}, */
+       {MATCHACTION_SCORE, "score"},
+       {MATCHACTION_MOVE, "move"},
+       {MATCHACTION_COPY, "copy"},
+       {MATCHACTION_DELETE, "delete"},
+       {MATCHACTION_MARK, "mark"},
+       {MATCHACTION_UNMARK, "unmark"},
+       {MATCHACTION_MARK_AS_READ, "mark_as_read"},
+       {MATCHACTION_MARK_AS_UNREAD, "mark_as_unread"},
+       {MATCHACTION_FORWARD, "forward"},
+       {MATCHACTION_FORWARD_AS_ATTACHMENT, "forward_as_attachment"},
+       {MATCHACTION_EXECUTE, "execute"},
+       {MATCHACTION_COLOR, "color"},
+       {MATCHACTION_BOUNCE, "bounce"}
 };
 
 gchar * get_matchparser_tab_str(gint id)
@@ -138,6 +139,7 @@ gchar * get_matchparser_tab_str(gint id)
   subject match "regexp" | to regexpcase "regexp" | age_sup 5
  */
 
+#if 0
 static gboolean matcher_is_blank(gchar ch);
 
 /* ******************* parser *********************** */
@@ -167,11 +169,11 @@ MatcherProp * matcherprop_parse(gchar ** str)
        }
 
        switch (key) {
-       case MATCHING_AGE_LOWER:
-       case MATCHING_AGE_GREATER:
-       case MATCHING_SCORE_LOWER:
-       case MATCHING_SCORE_GREATER:
-       case MATCHING_SCORE_EQUAL:
+       case MATCHCRITERIA_AGE_LOWER:
+       case MATCHCRITERIA_AGE_GREATER:
+       case MATCHCRITERIA_SCORE_LOWER:
+       case MATCHCRITERIA_SCORE_GREATER:
+       case MATCHCRITERIA_SCORE_EQUAL:
                value = matcher_parse_number(&tmp);
                if (tmp == NULL) {
                        * str = NULL;
@@ -183,51 +185,51 @@ MatcherProp * matcherprop_parse(gchar ** str)
 
                return prop;
 
-       case MATCHING_ALL:
-       case MATCHING_UNREAD:
-       case MATCHING_NOT_UNREAD:
-       case MATCHING_NEW:
-       case MATCHING_NOT_NEW:
-       case MATCHING_MARKED:
-       case MATCHING_NOT_MARKED:
-       case MATCHING_DELETED:
-       case MATCHING_NOT_DELETED:
-       case MATCHING_REPLIED:
-       case MATCHING_NOT_REPLIED:
-       case MATCHING_FORWARDED:
-       case MATCHING_NOT_FORWARDED:
+       case MATCHCRITERIA_ALL:
+       case MATCHCRITERIA_UNREAD:
+       case MATCHCRITERIA_NOT_UNREAD:
+       case MATCHCRITERIA_NEW:
+       case MATCHCRITERIA_NOT_NEW:
+       case MATCHCRITERIA_MARKED:
+       case MATCHCRITERIA_NOT_MARKED:
+       case MATCHCRITERIA_DELETED:
+       case MATCHCRITERIA_NOT_DELETED:
+       case MATCHCRITERIA_REPLIED:
+       case MATCHCRITERIA_NOT_REPLIED:
+       case MATCHCRITERIA_FORWARDED:
+       case MATCHCRITERIA_NOT_FORWARDED:
                prop = matcherprop_new(key, NULL, 0, NULL, 0);
                *str = tmp;
 
                return prop;
 
-       case MATCHING_SUBJECT:
-       case MATCHING_NOT_SUBJECT:
-       case MATCHING_FROM:
-       case MATCHING_NOT_FROM:
-       case MATCHING_TO:
-       case MATCHING_NOT_TO:
-       case MATCHING_CC:
-       case MATCHING_NOT_CC:
-       case MATCHING_TO_OR_CC:
-       case MATCHING_NOT_TO_AND_NOT_CC:
-       case MATCHING_NEWSGROUPS:
-       case MATCHING_NOT_NEWSGROUPS:
-       case MATCHING_INREPLYTO:
-       case MATCHING_NOT_REFERENCES:
-       case MATCHING_REFERENCES:
-       case MATCHING_NOT_INREPLYTO:
-       case MATCHING_MESSAGE:
-       case MATCHING_NOT_MESSAGE:
-       case MATCHING_EXECUTE:
-       case MATCHING_NOT_EXECUTE:
-       case MATCHING_HEADERS_PART:
-       case MATCHING_NOT_HEADERS_PART:
-       case MATCHING_BODY_PART:
-       case MATCHING_NOT_BODY_PART:
-       case MATCHING_HEADER:
-       case MATCHING_NOT_HEADER:
-               if ((key == MATCHING_HEADER) || (key == MATCHING_NOT_HEADER)) {
+       case MATCHCRITERIA_SUBJECT:
+       case MATCHCRITERIA_NOT_SUBJECT:
+       case MATCHCRITERIA_FROM:
+       case MATCHCRITERIA_NOT_FROM:
+       case MATCHCRITERIA_TO:
+       case MATCHCRITERIA_NOT_TO:
+       case MATCHCRITERIA_CC:
+       case MATCHCRITERIA_NOT_CC:
+       case MATCHCRITERIA_TO_OR_CC:
+       case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
+       case MATCHCRITERIA_NEWSGROUPS:
+       case MATCHCRITERIA_NOT_NEWSGROUPS:
+       case MATCHCRITERIA_INREPLYTO:
+       case MATCHCRITERIA_NOT_REFERENCES:
+       case MATCHCRITERIA_REFERENCES:
+       case MATCHCRITERIA_NOT_INREPLYTO:
+       case MATCHCRITERIA_MESSAGE:
+       case MATCHCRITERIA_NOT_MESSAGE:
+       case MATCHCRITERIA_EXECUTE:
+       case MATCHCRITERIA_NOT_EXECUTE:
+       case MATCHCRITERIA_HEADERS_PART:
+       case MATCHCRITERIA_NOT_HEADERS_PART:
+       case MATCHCRITERIA_BODY_PART:
+       case MATCHCRITERIA_NOT_BODY_PART:
+       case MATCHCRITERIA_HEADER:
+       case MATCHCRITERIA_NOT_HEADER:
+               if ((key == MATCHCRITERIA_HEADER) || (key == MATCHCRITERIA_NOT_HEADER)) {
                        header = matcher_parse_str(&tmp);
                        if (tmp == NULL) {
                                * str = NULL;
@@ -244,8 +246,8 @@ MatcherProp * matcherprop_parse(gchar ** str)
                }
 
                switch(match) {
-               case MATCHING_REGEXP:
-               case MATCHING_REGEXPCASE:
+               case MATCHCRITERIA_REGEXP:
+               case MATCHCRITERIA_REGEXPCASE:
                        expr = matcher_parse_regexp(&tmp);
                        if (tmp == NULL) {
                                if (header)
@@ -258,8 +260,8 @@ MatcherProp * matcherprop_parse(gchar ** str)
                        g_free(expr);
 
                        return prop;
-               case MATCHING_MATCH:
-               case MATCHING_MATCHCASE:
+               case MATCHCRITERIA_MATCH:
+               case MATCHCRITERIA_MATCHCASE:
                        expr = matcher_parse_str(&tmp);
                        if (tmp == NULL) {
                                if (header)
@@ -409,11 +411,13 @@ gchar * matcher_parse_regexp(gchar ** str)
        *str += p - dup + 2;
        return g_strdup(start);
 }
+#endif
 
 /* matcher_parse_str() - parses a string until it hits a 
  * terminating \". to unescape characters use \. The string
  * should not be used directly: matcher_unescape_str() 
  * returns a string that can be used directly. */
+#if 0
 gchar * matcher_parse_str(gchar ** str)
 {
        gchar * p;
@@ -450,6 +454,7 @@ gchar * matcher_parse_str(gchar ** str)
        *str += dest - dup + 2;
        return g_strdup(start);
 }
+#endif
 
 gchar *matcher_unescape_str(gchar *str)
 {
@@ -534,13 +539,13 @@ static gboolean matcherprop_string_match(MatcherProp * prop, gchar * str)
                return FALSE;
 
        switch(prop->matchtype) {
-       case MATCHING_REGEXPCASE:
-       case MATCHING_REGEXP:
+       case MATCHTYPE_REGEXPCASE:
+       case MATCHTYPE_REGEXP:
                if (!prop->preg && (prop->error == 0)) {
                        prop->preg = g_new0(regex_t, 1);
                        if (regcomp(prop->preg, prop->expr,
                                    REG_NOSUB | REG_EXTENDED
-                                   | ((prop->matchtype == MATCHING_REGEXPCASE)
+                                   | ((prop->matchtype == MATCHTYPE_REGEXPCASE)
                                    ? REG_ICASE : 0)) != 0) {
                                prop->error = 1;
                                g_free(prop->preg);
@@ -554,10 +559,10 @@ static gboolean matcherprop_string_match(MatcherProp * prop, gchar * str)
                else
                        return FALSE;
 
-       case MATCHING_MATCH:
+       case MATCHTYPE_MATCH:
                return (strstr(str, prop->expr) != NULL);
 
-       case MATCHING_MATCHCASE:
+       case MATCHTYPE_MATCHCASE:
                str2 = alloca(strlen(prop->expr) + 1);
                strcpy(str2, prop->expr);
                g_strup(str2);
@@ -590,81 +595,81 @@ gboolean matcherprop_match(MatcherProp * prop, MsgInfo * info)
        time_t t;
 
        switch(prop->criteria) {
-       case MATCHING_ALL:
+       case MATCHCRITERIA_ALL:
                return 1;
-       case MATCHING_UNREAD:
+       case MATCHCRITERIA_UNREAD:
                return MSG_IS_UNREAD(info->flags);
-       case MATCHING_NOT_UNREAD:
+       case MATCHCRITERIA_NOT_UNREAD:
                return !MSG_IS_UNREAD(info->flags);
-       case MATCHING_NEW:
+       case MATCHCRITERIA_NEW:
                return MSG_IS_NEW(info->flags);
-       case MATCHING_NOT_NEW:
+       case MATCHCRITERIA_NOT_NEW:
                return !MSG_IS_NEW(info->flags);
-       case MATCHING_MARKED:
+       case MATCHCRITERIA_MARKED:
                return MSG_IS_MARKED(info->flags);
-       case MATCHING_NOT_MARKED:
+       case MATCHCRITERIA_NOT_MARKED:
                return !MSG_IS_MARKED(info->flags);
-       case MATCHING_DELETED:
+       case MATCHCRITERIA_DELETED:
                return MSG_IS_DELETED(info->flags);
-       case MATCHING_NOT_DELETED:
+       case MATCHCRITERIA_NOT_DELETED:
                return !MSG_IS_DELETED(info->flags);
-       case MATCHING_REPLIED:
+       case MATCHCRITERIA_REPLIED:
                return MSG_IS_REPLIED(info->flags);
-       case MATCHING_NOT_REPLIED:
+       case MATCHCRITERIA_NOT_REPLIED:
                return !MSG_IS_REPLIED(info->flags);
-       case MATCHING_FORWARDED:
+       case MATCHCRITERIA_FORWARDED:
                return MSG_IS_FORWARDED(info->flags);
-       case MATCHING_NOT_FORWARDED:
+       case MATCHCRITERIA_NOT_FORWARDED:
                return !MSG_IS_FORWARDED(info->flags);
-       case MATCHING_SUBJECT:
+       case MATCHCRITERIA_SUBJECT:
                return matcherprop_string_match(prop, info->subject);
-       case MATCHING_NOT_SUBJECT:
+       case MATCHCRITERIA_NOT_SUBJECT:
                return !matcherprop_string_match(prop, info->subject);
-       case MATCHING_FROM:
+       case MATCHCRITERIA_FROM:
                return matcherprop_string_match(prop, info->from);
-       case MATCHING_NOT_FROM:
+       case MATCHCRITERIA_NOT_FROM:
                return !matcherprop_string_match(prop, info->from);
-       case MATCHING_TO:
+       case MATCHCRITERIA_TO:
                return matcherprop_string_match(prop, info->to);
-       case MATCHING_NOT_TO:
+       case MATCHCRITERIA_NOT_TO:
                return !matcherprop_string_match(prop, info->to);
-       case MATCHING_CC:
+       case MATCHCRITERIA_CC:
                return matcherprop_string_match(prop, info->cc);
-       case MATCHING_NOT_CC:
+       case MATCHCRITERIA_NOT_CC:
                return !matcherprop_string_match(prop, info->cc);
-       case MATCHING_TO_OR_CC:
+       case MATCHCRITERIA_TO_OR_CC:
                return matcherprop_string_match(prop, info->to)
                        || matcherprop_string_match(prop, info->cc);
-       case MATCHING_NOT_TO_AND_NOT_CC:
+       case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
                return !(matcherprop_string_match(prop, info->to)
                || matcherprop_string_match(prop, info->cc));
-       case MATCHING_AGE_GREATER:
+       case MATCHCRITERIA_AGE_GREATER:
                t = time(NULL);
                return ((t - info->date_t) / (60 * 60 * 24)) >= prop->value;
-       case MATCHING_AGE_LOWER:
+       case MATCHCRITERIA_AGE_LOWER:
                t = time(NULL);
                return ((t - info->date_t) / (60 * 60 * 24)) <= prop->value;
-       case MATCHING_SCORE_GREATER:
+       case MATCHCRITERIA_SCORE_GREATER:
                return info->score >= prop->value;
-       case MATCHING_SCORE_LOWER:
+       case MATCHCRITERIA_SCORE_LOWER:
                return info->score <= prop->value;
-       case MATCHING_SCORE_EQUAL:
+       case MATCHCRITERIA_SCORE_EQUAL:
                return info->score == prop->value;
-       case MATCHING_NEWSGROUPS:
+       case MATCHCRITERIA_NEWSGROUPS:
                return matcherprop_string_match(prop, info->newsgroups);
-       case MATCHING_NOT_NEWSGROUPS:
+       case MATCHCRITERIA_NOT_NEWSGROUPS:
                return !matcherprop_string_match(prop, info->newsgroups);
-       case MATCHING_INREPLYTO:
+       case MATCHCRITERIA_INREPLYTO:
                return matcherprop_string_match(prop, info->inreplyto);
-       case MATCHING_NOT_INREPLYTO:
+       case MATCHCRITERIA_NOT_INREPLYTO:
                return !matcherprop_string_match(prop, info->inreplyto);
-       case MATCHING_REFERENCES:
+       case MATCHCRITERIA_REFERENCES:
                return matcherprop_string_match(prop, info->references);
-       case MATCHING_NOT_REFERENCES:
+       case MATCHCRITERIA_NOT_REFERENCES:
                return !matcherprop_string_match(prop, info->references);
-       case MATCHING_EXECUTE:
+       case MATCHCRITERIA_EXECUTE:
                return matcherprop_match_execute(prop, info);
-       case MATCHING_NOT_EXECUTE:
+       case MATCHCRITERIA_NOT_EXECUTE:
                return !matcherprop_match_execute(prop, info);
        default:
                return 0;
@@ -676,6 +681,7 @@ gboolean matcherprop_match(MatcherProp * prop, MsgInfo * info)
 
 /* parse for a list of conditions */
 
+/*
 MatcherList * matcherlist_parse(gchar ** str)
 {
        gchar * tmp;
@@ -728,6 +734,7 @@ MatcherList * matcherlist_parse(gchar ** str)
 
        return cond;
 }
+*/
 
 MatcherList * matcherlist_new(GSList * matchers, gboolean bool_and)
 {
@@ -775,14 +782,14 @@ static gboolean matcherprop_match_one_header(MatcherProp * matcher,
        Header *header;
 
        switch(matcher->criteria) {
-       case MATCHING_HEADER:
-       case MATCHING_NOT_HEADER:
+       case MATCHCRITERIA_HEADER:
+       case MATCHCRITERIA_NOT_HEADER:
                header = procheader_parse_header(buf);
                if (!header)
                        return FALSE;
                if (procheader_headername_equal(header->name,
                                                matcher->header)) {
-                       if (matcher->criteria == MATCHING_HEADER)
+                       if (matcher->criteria == MATCHCRITERIA_HEADER)
                                result = matcherprop_string_match(matcher, header->body);
                        else
                                result = !matcherprop_string_match(matcher, header->body);
@@ -793,11 +800,11 @@ static gboolean matcherprop_match_one_header(MatcherProp * matcher,
                        procheader_header_free(header);
                }
                break;
-       case MATCHING_HEADERS_PART:
-       case MATCHING_MESSAGE:
+       case MATCHCRITERIA_HEADERS_PART:
+       case MATCHCRITERIA_MESSAGE:
                return matcherprop_string_match(matcher, buf);
-       case MATCHING_NOT_MESSAGE:
-       case MATCHING_NOT_HEADERS_PART:
+       case MATCHCRITERIA_NOT_MESSAGE:
+       case MATCHCRITERIA_NOT_HEADERS_PART:
                return !matcherprop_string_match(matcher, buf);
        }
        return FALSE;
@@ -811,10 +818,10 @@ static gboolean matcherprop_match_one_header(MatcherProp * matcher,
 static gboolean matcherprop_criteria_headers(MatcherProp * matcher)
 {
        switch(matcher->criteria) {
-       case MATCHING_HEADER:
-       case MATCHING_NOT_HEADER:
-       case MATCHING_HEADERS_PART:
-       case MATCHING_NOT_HEADERS_PART:
+       case MATCHCRITERIA_HEADER:
+       case MATCHCRITERIA_NOT_HEADER:
+       case MATCHCRITERIA_HEADERS_PART:
+       case MATCHCRITERIA_NOT_HEADERS_PART:
                return TRUE;
        default:
                return FALSE;
@@ -824,8 +831,8 @@ static gboolean matcherprop_criteria_headers(MatcherProp * matcher)
 static gboolean matcherprop_criteria_message(MatcherProp * matcher)
 {
        switch(matcher->criteria) {
-       case MATCHING_MESSAGE:
-       case MATCHING_NOT_MESSAGE:
+       case MATCHCRITERIA_MESSAGE:
+       case MATCHCRITERIA_NOT_MESSAGE:
                return TRUE;
        default:
                return FALSE;
@@ -887,8 +894,8 @@ static gboolean matcherlist_match_headers(MatcherList * matchers, FILE * fp)
 static gboolean matcherprop_criteria_body(MatcherProp * matcher)
 {
        switch(matcher->criteria) {
-       case MATCHING_BODY_PART:
-       case MATCHING_NOT_BODY_PART:
+       case MATCHCRITERIA_BODY_PART:
+       case MATCHCRITERIA_NOT_BODY_PART:
                return TRUE;
        default:
                return FALSE;
@@ -903,11 +910,11 @@ static gboolean matcherprop_criteria_body(MatcherProp * matcher)
 static gboolean matcherprop_match_line(MatcherProp * matcher, gchar * line)
 {
        switch(matcher->criteria) {
-       case MATCHING_BODY_PART:
-       case MATCHING_MESSAGE:
+       case MATCHCRITERIA_BODY_PART:
+       case MATCHCRITERIA_MESSAGE:
                return matcherprop_string_match(matcher, line);
-       case MATCHING_NOT_BODY_PART:
-       case MATCHING_NOT_MESSAGE:
+       case MATCHCRITERIA_NOT_BODY_PART:
+       case MATCHCRITERIA_NOT_MESSAGE:
                return !matcherprop_string_match(matcher, line);
        }
        return FALSE;
@@ -1059,42 +1066,42 @@ gboolean matcherlist_match(MatcherList * matchers, MsgInfo * info)
                MatcherProp * matcher = (MatcherProp *) l->data;
 
                switch(matcher->criteria) {
-               case MATCHING_ALL:
-               case MATCHING_UNREAD:
-               case MATCHING_NOT_UNREAD:
-               case MATCHING_NEW:
-               case MATCHING_NOT_NEW:
-               case MATCHING_MARKED:
-               case MATCHING_NOT_MARKED:
-               case MATCHING_DELETED:
-               case MATCHING_NOT_DELETED:
-               case MATCHING_REPLIED:
-               case MATCHING_NOT_REPLIED:
-               case MATCHING_FORWARDED:
-               case MATCHING_NOT_FORWARDED:
-               case MATCHING_SUBJECT:
-               case MATCHING_NOT_SUBJECT:
-               case MATCHING_FROM:
-               case MATCHING_NOT_FROM:
-               case MATCHING_TO:
-               case MATCHING_NOT_TO:
-               case MATCHING_CC:
-               case MATCHING_NOT_CC:
-               case MATCHING_TO_OR_CC:
-               case MATCHING_NOT_TO_AND_NOT_CC:
-               case MATCHING_AGE_GREATER:
-               case MATCHING_AGE_LOWER:
-               case MATCHING_NEWSGROUPS:
-               case MATCHING_NOT_NEWSGROUPS:
-               case MATCHING_INREPLYTO:
-               case MATCHING_NOT_INREPLYTO:
-               case MATCHING_REFERENCES:
-               case MATCHING_NOT_REFERENCES:
-               case MATCHING_SCORE_GREATER:
-               case MATCHING_SCORE_LOWER:
-               case MATCHING_SCORE_EQUAL:
-               case MATCHING_EXECUTE:
-               case MATCHING_NOT_EXECUTE:
+               case MATCHCRITERIA_ALL:
+               case MATCHCRITERIA_UNREAD:
+               case MATCHCRITERIA_NOT_UNREAD:
+               case MATCHCRITERIA_NEW:
+               case MATCHCRITERIA_NOT_NEW:
+               case MATCHCRITERIA_MARKED:
+               case MATCHCRITERIA_NOT_MARKED:
+               case MATCHCRITERIA_DELETED:
+               case MATCHCRITERIA_NOT_DELETED:
+               case MATCHCRITERIA_REPLIED:
+               case MATCHCRITERIA_NOT_REPLIED:
+               case MATCHCRITERIA_FORWARDED:
+               case MATCHCRITERIA_NOT_FORWARDED:
+               case MATCHCRITERIA_SUBJECT:
+               case MATCHCRITERIA_NOT_SUBJECT:
+               case MATCHCRITERIA_FROM:
+               case MATCHCRITERIA_NOT_FROM:
+               case MATCHCRITERIA_TO:
+               case MATCHCRITERIA_NOT_TO:
+               case MATCHCRITERIA_CC:
+               case MATCHCRITERIA_NOT_CC:
+               case MATCHCRITERIA_TO_OR_CC:
+               case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
+               case MATCHCRITERIA_AGE_GREATER:
+               case MATCHCRITERIA_AGE_LOWER:
+               case MATCHCRITERIA_NEWSGROUPS:
+               case MATCHCRITERIA_NOT_NEWSGROUPS:
+               case MATCHCRITERIA_INREPLYTO:
+               case MATCHCRITERIA_NOT_INREPLYTO:
+               case MATCHCRITERIA_REFERENCES:
+               case MATCHCRITERIA_NOT_REFERENCES:
+               case MATCHCRITERIA_SCORE_GREATER:
+               case MATCHCRITERIA_SCORE_LOWER:
+               case MATCHCRITERIA_SCORE_EQUAL:
+               case MATCHCRITERIA_EXECUTE:
+               case MATCHCRITERIA_NOT_EXECUTE:
                        if (matcherprop_match(matcher, info)) {
                                if (!matchers->bool_and) {
                                        return TRUE;
@@ -1133,16 +1140,16 @@ static void matcherprop_print(MatcherProp * matcher)
        }
 
        switch (matcher->matchtype) {
-       case MATCHING_MATCH:
+       case MATCHCRITERIA_MATCH:
                printf("match\n");
                break;
-       case MATCHING_REGEXP:
+       case MATCHCRITERIA_REGEXP:
                printf("regexp\n");
                break;
-       case MATCHING_MATCHCASE:
+       case MATCHCRITERIA_MATCHCASE:
                printf("matchcase\n");
                break;
-       case MATCHING_REGEXPCASE:
+       case MATCHCRITERIA_REGEXPCASE:
                printf("regexpcase\n");
                break;
        }
@@ -1184,26 +1191,26 @@ gchar * matcherprop_to_string(MatcherProp * matcher)
                return NULL;
 
        switch(matcher->criteria) {
-       case MATCHING_AGE_GREATER:
-       case MATCHING_AGE_LOWER:
-       case MATCHING_SCORE_GREATER:
-       case MATCHING_SCORE_LOWER:
-       case MATCHING_SCORE_EQUAL:
+       case MATCHCRITERIA_AGE_GREATER:
+       case MATCHCRITERIA_AGE_LOWER:
+       case MATCHCRITERIA_SCORE_GREATER:
+       case MATCHCRITERIA_SCORE_LOWER:
+       case MATCHCRITERIA_SCORE_EQUAL:
                return g_strdup_printf("%s %i", criteria_str, matcher->value);
                break;
-       case MATCHING_ALL:
-       case MATCHING_UNREAD:
-       case MATCHING_NOT_UNREAD:
-       case MATCHING_NEW:
-       case MATCHING_NOT_NEW:
-       case MATCHING_MARKED:
-       case MATCHING_NOT_MARKED:
-       case MATCHING_DELETED:
-       case MATCHING_NOT_DELETED:
-       case MATCHING_REPLIED:
-       case MATCHING_NOT_REPLIED:
-       case MATCHING_FORWARDED:
-       case MATCHING_NOT_FORWARDED:
+       case MATCHCRITERIA_ALL:
+       case MATCHCRITERIA_UNREAD:
+       case MATCHCRITERIA_NOT_UNREAD:
+       case MATCHCRITERIA_NEW:
+       case MATCHCRITERIA_NOT_NEW:
+       case MATCHCRITERIA_MARKED:
+       case MATCHCRITERIA_NOT_MARKED:
+       case MATCHCRITERIA_DELETED:
+       case MATCHCRITERIA_NOT_DELETED:
+       case MATCHCRITERIA_REPLIED:
+       case MATCHCRITERIA_NOT_REPLIED:
+       case MATCHCRITERIA_FORWARDED:
+       case MATCHCRITERIA_NOT_FORWARDED:
                return g_strdup(criteria_str);
        }
 
@@ -1218,8 +1225,8 @@ gchar * matcherprop_to_string(MatcherProp * matcher)
                return NULL;
 
        switch (matcher->matchtype) {
-       case MATCHING_MATCH:
-       case MATCHING_MATCHCASE:
+       case MATCHTYPE_MATCH:
+       case MATCHTYPE_MATCHCASE:
                count = 0;
                for(p = matcher->expr; *p != 0 ; p++)
                        if (*p == '\"') count ++;
@@ -1250,8 +1257,8 @@ gchar * matcherprop_to_string(MatcherProp * matcher)
                
                break;
 
-       case MATCHING_REGEXP:
-       case MATCHING_REGEXPCASE:
+       case MATCHTYPE_REGEXP:
+       case MATCHTYPE_REGEXPCASE:
 
                if (matcher->header)
                        matcher_str =
@@ -1469,12 +1476,182 @@ gchar * matching_build_command(gchar * cmd, MsgInfo * info)
 }
 
 
+/* ************************************************************ */
+/* ************************************************************ */
+/* ************************************************************ */
+/* ************************************************************ */
 /* ************************************************************ */
 
-/*
-static void matcher_parse              (gchar * str)
+
+static void prefs_scoring_write(FILE * fp, GSList * prefs_scoring)
 {
-       matcher_parser_scan_string(str);
-       matcher_parserparse();
+       GSList * cur;
+
+       for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
+               gchar *scoring_str;
+               ScoringProp * prop;
+
+               prop = (ScoringProp *) cur->data;
+               scoring_str = scoringprop_to_string(prop);
+               if (fputs(scoring_str, fp) == EOF ||
+                   fputc('\n', fp) == EOF) {
+                       FILE_OP_ERROR("scoring config", "fputs || fputc");
+                       g_free(scoring_str);
+                       return;
+               }
+               g_free(scoring_str);
+       }
+}
+
+static void prefs_filtering_write(FILE * fp, GSList * prefs_scoring)
+{
+       GSList * cur;
+
+       for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
+               gchar *filtering_str;
+               FilteringProp * prop;
+
+               prop = (FilteringProp *) cur->data;
+               filtering_str = filteringprop_to_string(prop);
+               
+               if (fputs(filtering_str, fp) == EOF ||
+                   fputc('\n', fp) == EOF) {
+                       FILE_OP_ERROR("filtering config", "fputs || fputc");
+                       g_free(filtering_str);
+                       return;
+               }
+               g_free(filtering_str);
+       }
+}
+
+static gboolean prefs_matcher_write_func(GNode *node, gpointer data)
+{
+       FolderItem *item;
+       FILE * fp = data;
+       gchar * id;
+       GSList * prefs_scoring;
+       GSList * prefs_filtering;
+
+       if (node != NULL) {
+               item = node->data;
+               /* prevent from the warning */
+               if (item->path == NULL)
+                       return FALSE;
+               id = folder_item_get_identifier(item);
+               if (id == NULL)
+                       return FALSE;
+               prefs_scoring = item->prefs->scoring;
+               prefs_filtering = item->prefs->processing;
+       }
+       else {
+               item = NULL;
+               id = g_strdup("global"); /* because it is g_freed */
+               prefs_scoring = global_scoring;
+               prefs_filtering = global_processing;
+       }
+
+       if (prefs_filtering != NULL || prefs_scoring != NULL) {
+               fprintf(fp, "[%s]\n", id);
+
+               prefs_filtering_write(fp, prefs_filtering);
+               prefs_scoring_write(fp, prefs_scoring);
+
+               fputc('\n', fp);
+       }
+
+       g_free(id);
+
+       return FALSE;
+}
+
+static void prefs_matcher_save(FILE * fp)
+{
+       GList * cur;
+
+       for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
+               Folder *folder;
+
+               folder = (Folder *) cur->data;
+               g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
+                               prefs_matcher_write_func, fp);
+       }
+       prefs_matcher_write_func(NULL, fp);
+}
+
+
+void prefs_matcher_write_config(void)
+{
+       gchar *rcpath;
+       PrefFile *pfile;
+       GSList *cur;
+       ScoringProp * prop;
+
+       debug_print(_("Writing matcher configuration...\n"));
+
+       rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+                            MATCHER_RC, NULL);
+
+       if ((pfile = prefs_write_open(rcpath)) == NULL) {
+               g_warning(_("failed to write configuration to file\n"));
+               g_free(rcpath);
+               return;
+       }
+
+
+       prefs_matcher_save(pfile->fp);
+
+       g_free(rcpath);
+
+       if (prefs_write_close(pfile) < 0) {
+               g_warning(_("failed to write configuration to file\n"));
+               return;
+       }
+}
+
+
+
+
+
+
+/* ******************************************************************* */
+
+void prefs_matcher_read_config(void)
+{
+       gchar * rcpath;
+       FILE * f;
+
+       prefs_scoring_clear();
+       prefs_filtering_clear();
+
+       rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC, NULL);
+       f = fopen(rcpath, "r");
+       g_free(rcpath);
+
+       if (f != NULL)
+               matcher_parser_start_parsing(f);
+       else {
+               /* previous version compatibily */
+
+               printf("reading filtering\n");
+               rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+                                    FILTERING_RC, NULL);
+               f = fopen(rcpath, "r");
+               g_free(rcpath);
+               
+               if (f != NULL) {
+                       matcher_parser_start_parsing(f);
+                       fclose(matcher_parserin);
+               }
+               
+               printf("reading scoring\n");
+               rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+                                    SCORING_RC, NULL);
+               f = fopen(rcpath, "r");
+               g_free(rcpath);
+               
+               if (f != NULL) {
+                       matcher_parser_start_parsing(f);
+                       fclose(matcher_parserin);
+               }
+       }
 }
-*/
index 1bae409..50f6fac 100644 (file)
@@ -7,6 +7,77 @@
 #include <glib.h>
 #include "procmsg.h"
 
+struct _MatcherProp {
+       int matchtype;
+       int criteria;
+       gchar * header;
+       gchar * expr;
+       int value;
+       regex_t * preg;
+       int error;
+       gboolean result;
+};
+
+typedef struct _MatcherProp MatcherProp;
+
+struct _MatcherList {
+       GSList * matchers;
+       gboolean bool_and;
+};
+
+typedef struct _MatcherList MatcherList;
+
+
+enum {
+       /* match */
+       MATCHCRITERIA_ALL,
+       MATCHCRITERIA_UNREAD, MATCHCRITERIA_NOT_UNREAD,
+       MATCHCRITERIA_NEW, MATCHCRITERIA_NOT_NEW,
+       MATCHCRITERIA_MARKED, MATCHCRITERIA_NOT_MARKED,
+       MATCHCRITERIA_DELETED, MATCHCRITERIA_NOT_DELETED,
+       MATCHCRITERIA_REPLIED, MATCHCRITERIA_NOT_REPLIED,
+       MATCHCRITERIA_FORWARDED, MATCHCRITERIA_NOT_FORWARDED,
+       MATCHCRITERIA_SUBJECT, MATCHCRITERIA_NOT_SUBJECT,
+       MATCHCRITERIA_FROM, MATCHCRITERIA_NOT_FROM,
+       MATCHCRITERIA_TO, MATCHCRITERIA_NOT_TO,
+       MATCHCRITERIA_CC, MATCHCRITERIA_NOT_CC,
+       MATCHCRITERIA_TO_OR_CC, MATCHCRITERIA_NOT_TO_AND_NOT_CC,
+       MATCHCRITERIA_AGE_GREATER, MATCHCRITERIA_AGE_LOWER,
+       MATCHCRITERIA_NEWSGROUPS, MATCHCRITERIA_NOT_NEWSGROUPS,
+       MATCHCRITERIA_INREPLYTO, MATCHCRITERIA_NOT_INREPLYTO,
+       MATCHCRITERIA_REFERENCES, MATCHCRITERIA_NOT_REFERENCES,
+       MATCHCRITERIA_SCORE_GREATER, MATCHCRITERIA_SCORE_LOWER,
+       MATCHCRITERIA_HEADER, MATCHCRITERIA_NOT_HEADER,
+       MATCHCRITERIA_HEADERS_PART, MATCHCRITERIA_NOT_HEADERS_PART,
+       MATCHCRITERIA_MESSAGE, MATCHCRITERIA_NOT_MESSAGE,
+       MATCHCRITERIA_BODY_PART, MATCHCRITERIA_NOT_BODY_PART,
+       MATCHCRITERIA_EXECUTE, MATCHCRITERIA_NOT_EXECUTE,
+       MATCHCRITERIA_SCORE_EQUAL,
+       /* match type */
+       MATCHTYPE_MATCHCASE,
+       MATCHTYPE_MATCH,
+       MATCHTYPE_REGEXPCASE,
+       MATCHTYPE_REGEXP,
+       /* actions */
+       MATCHACTION_SCORE,
+       MATCHACTION_EXECUTE,
+       MATCHACTION_MOVE,
+       MATCHACTION_COPY,
+       MATCHACTION_DELETE,
+       MATCHACTION_MARK,
+       MATCHACTION_UNMARK,
+       MATCHACTION_MARK_AS_READ,
+       MATCHACTION_MARK_AS_UNREAD,
+       MATCHACTION_FORWARD,
+       MATCHACTION_FORWARD_AS_ATTACHMENT,
+       MATCHACTION_COLOR,
+       MATCHACTION_BOUNCE,
+       /* boolean operations */
+       MATCHERBOOL_OR,
+       MATCHERBOOL_AND,
+};
+
+#if 0
 enum {
        /* msginfo flags */
        MATCHING_ALL,
@@ -79,26 +150,7 @@ enum {
        MATCHING_MATCHCASE,
        MATCHING_REGEXPCASE
 };
-
-struct _MatcherProp {
-       int matchtype;
-       int criteria;
-       gchar * header;
-       gchar * expr;
-       int value;
-       regex_t * preg;
-       int error;
-       gboolean result;
-};
-
-typedef struct _MatcherProp MatcherProp;
-
-struct _MatcherList {
-       GSList * matchers;
-       gboolean bool_and;
-};
-
-typedef struct _MatcherList MatcherList;
+#endif
 
 gchar * get_matchparser_tab_str(gint id);
 MatcherProp * matcherprop_new(gint criteria, gchar * header,
@@ -125,4 +177,9 @@ gchar * matcherprop_to_string(MatcherProp * matcher);
 gchar * matcherlist_to_string(MatcherList * matchers);
 gchar * matching_build_command(gchar * cmd, MsgInfo * info);
 
+
+void prefs_matcher_read_config(void);
+void prefs_matcher_write_config(void);
+
+
 #endif
index 85b4fac..b7ef312 100644 (file)
@@ -6,66 +6,20 @@
 #include "scoring.h"
 #include <glib.h>
 
-#define MATCHER_BUF_SIZE 16384
-
-enum {
-       MATCHTYPE_MATCH,
-       MATCHTYPE_MATCHCASE,
-       MATCHTYPE_REGEXP,
-       MATCHTYPE_REGEXPCASE
-};
-
-enum {
-MATCHCRITERIA_ALL,
-MATCHCRITERIA_UNREAD, MATCHCRITERIA_NOT_UNREAD,
-MATCHCRITERIA_NEW, MATCHCRITERIA_NOT_NEW,
-MATCHCRITERIA_MARKED, MATCHCRITERIA_NOT_MARKED,
-MATCHCRITERIA_DELETED, MATCHCRITERIA_NOT_DELETED,
-MATCHCRITERIA_REPLIED, MATCHCRITERIA_NOT_REPLIED,
-MATCHCRITERIA_FORWARDED, MATCHCRITERIA_NOT_FORWARDED,
-MATCHCRITERIA_SUBJECT, MATCHCRITERIA_NOT_SUBJECT,
-MATCHCRITERIA_FROM, MATCHCRITERIA_NOT_FROM,
-MATCHCRITERIA_TO, MATCHCRITERIA_NOT_TO,
-MATCHCRITERIA_CC, MATCHCRITERIA_NOT_CC,
-MATCHCRITERIA_TO_OR_CC, MATCHCRITERIA_NOT_TO_AND_NOT_CC,
-MATCHCRITERIA_AGE_GREATER, MATCHCRITERIA_AGE_LOWER,
-MATCHCRITERIA_NEWSGROUPS, MATCHCRITERIA_NOT_NEWSGROUPS,
-MATCHCRITERIA_INREPLYTO, MATCHCRITERIA_NOT_INREPLYTO,
-MATCHCRITERIA_REFERENCES, MATCHCRITERIA_NOT_REFERENCES,
-MATCHCRITERIA_SCORE_GREATER, MATCHCRITERIA_SCORE_LOWER,
-MATCHCRITERIA_HEADER, MATCHCRITERIA_NOT_HEADER,
-MATCHCRITERIA_HEADERS_PART, MATCHCRITERIA_NOT_HEADERS_PART,
-MATCHCRITERIA_MESSAGE, MATCHCRITERIA_NOT_MESSAGE,
-MATCHCRITERIA_BODY_PART, MATCHCRITERIA_NOT_BODY_PART,
-MATCHCRITERIA_EXECUTE, MATCHCRITERIA_NOT_EXECUTE
-};
-
-enum {
-       MATCHACTION_SCORE,
-       MATCHACTION_EXECUTE,
-       MATCHACTION_MOVE,
-       MATCHACTION_COPY,
-       MATCHACTION_DELETE,
-       MATCHACTION_MARK,
-       MATCHACTION_UNMARK,
-       MATCHACTION_MARK_AS_READ,
-       MATCHACTION_MARK_AS_UNREAD,
-       MATCHACTION_FORWARD,
-       MATCHACTION_FORWARD_AS_ATTACHMENT
-};
-
-enum {
-       MATCHERBOOL_OR,
-       MATCHERBOOL_AND,
-};     
+// #define MATCHER_BUF_SIZE 16384
 
 extern FILE *matcher_parserin;
 extern int matcher_parserlineno;
 
+
+void matcher_parser_start_parsing(FILE * f);
 int matcher_parserparse(void);
 /* void matcher_parser_init();*/
+
 MatcherList * matcher_parser_get_cond(gchar * str);
+MatcherProp * matcher_parser_get_prop(gchar * str);
 FilteringProp * matcher_parser_get_filtering(gchar * str);
 ScoringProp * matcher_parser_get_scoring(gchar * str);
+/* void matcher_parser_read_config(); */
 
 #endif
index f869273..84bfd4e 100644 (file)
@@ -57,6 +57,7 @@ static void add_char(char ch)
 "~references"  return MATCHER_NOT_REFERENCES;
 "score_greater"        return MATCHER_SCORE_GREATER;
 "score_lower"  return MATCHER_SCORE_LOWER;
+"score_equal"  return MATCHER_SCORE_EQUAL;
 "header"       return MATCHER_HEADER;
 "~header"      return MATCHER_NOT_HEADER;
 "headers_part" return MATCHER_HEADERS_PART;
@@ -81,6 +82,8 @@ static void add_char(char ch)
 "mark_as_unread"       return MATCHER_MARK_AS_UNREAD;
 "forward"             return MATCHER_FORWARD;
 "forward_as_attachment"              return MATCHER_FORWARD_AS_ATTACHMENT;
+"color"         return MATCHER_COLOR;
+"bounce"       return MATCHER_BOUNCE;
 [ \t]+
 "\n"           return MATCHER_EOL;
 "&"            return MATCHER_AND;
index 3dd4f9f..979a544 100644 (file)
@@ -6,6 +6,8 @@
 #include "matcher_parser_lex.h"
 #include "intl.h"
 #include <glib.h>
+#include "defs.h"
+#include "utils.h"
 
 static gint error = 0;
 static gint bool_op = 0;
@@ -28,14 +30,28 @@ static GSList ** prefs_filtering = NULL;
 
 static int matcher_parser_dialog = 0;
 
+
+/* ******************************************************************** */
+
+
+
+void matcher_parser_start_parsing(FILE * f)
+{
+       matcher_parserrestart(f);
+       matcher_parserparse();
+}
 FilteringProp * matcher_parser_get_filtering(gchar * str)
 {
        void * bufstate;
 
+       /* bad coding to enable the sub-grammar matching
+          in yacc */
        matcher_parserlineno = 1;
        matcher_parser_dialog = 1;
        bufstate = matcher_parser_scan_string(str);
-       matcher_parserparse();
+       if (matcher_parserparse() != 0)
+               filtering = NULL;
        matcher_parser_dialog = 0;
        matcher_parser_delete_buffer(bufstate);
        return filtering;
@@ -45,10 +61,13 @@ ScoringProp * matcher_parser_get_scoring(gchar * str)
 {
        void * bufstate;
 
+       /* bad coding to enable the sub-grammar matching
+          in yacc */
        matcher_parserlineno = 1;
        matcher_parser_dialog = 1;
        bufstate = matcher_parser_scan_string(str);
-       matcher_parserparse();
+       if (matcher_parserparse() != 0)
+               scoring = NULL;
        matcher_parser_dialog = 0;
        matcher_parser_delete_buffer(bufstate);
        return scoring;
@@ -58,6 +77,8 @@ MatcherList * matcher_parser_get_cond(gchar * str)
 {
        void * bufstate;
 
+       /* bad coding to enable the sub-grammar matching
+          in yacc */
        matcher_parserlineno = 1;
        matcher_parser_dialog = 1;
        bufstate = matcher_parser_scan_string(str);
@@ -87,6 +108,8 @@ MatcherProp * matcher_parser_get_prop(gchar * str)
 
        g_slist_free(list->matchers);
        g_free(list);
+
+       return prop;
 }
 
 void matcher_parsererror(char * str)
@@ -137,6 +160,7 @@ int matcher_parserwrap(void)
 %token MATCHER_MARK_AS_READ  MATCHER_MARK_AS_UNREAD  MATCHER_FORWARD
 %token MATCHER_FORWARD_AS_ATTACHMENT  MATCHER_EOL  MATCHER_STRING  
 %token MATCHER_OR MATCHER_AND  
+%token MATCHER_COLOR MATCHER_SCORE_EQUAL MATCHER_BOUNCE
 
 %start file
 
@@ -150,7 +174,7 @@ file:
 {
        if (!matcher_parser_dialog) {
                prefs_scoring = &global_scoring;
-               prefs_filtering = &global_filtering;
+               prefs_filtering = &global_processing;
        }
 }
 file_line_list;
@@ -164,7 +188,10 @@ file_line_list
 file_line:
 section_notification
 | instruction
-;
+| error MATCHER_EOL
+{
+       yyerrok;
+};
 
 section_notification:
 MATCHER_SECTION MATCHER_EOL
@@ -176,7 +203,7 @@ MATCHER_SECTION MATCHER_EOL
                item = folder_find_item_from_identifier(folder);
                if (item == NULL) {
                        prefs_scoring = &global_scoring;
-                       prefs_filtering = &global_scoring;
+                       prefs_filtering = &global_processing;
                }
                else {
                        prefs_scoring = &item->prefs->scoring;
@@ -192,12 +219,27 @@ condition end_instr_opt
 ;
 
 end_instr_opt:
-filtering_or_scoring MATCHER_EOL
+filtering_or_scoring end_action
 |
 {
-       if (!matcher_parser_dialog) {
-               yyerror("parse error");
-               return 1;
+       if (matcher_parser_dialog)
+               YYACCEPT;
+       else {
+               matcher_parsererror("parse error");
+               YYERROR;
+       }
+}
+;
+
+end_action:
+MATCHER_EOL
+|
+{
+       if (matcher_parser_dialog)
+               YYACCEPT;
+       else {
+               matcher_parsererror("parse error");
+               YYERROR;
        }
 }
 ;
@@ -548,6 +590,15 @@ MATCHER_ALL
        value = atoi($2);
        prop = matcherprop_new(criteria, NULL, 0, NULL, value);
 }
+| MATCHER_SCORE_EQUAL MATCHER_INTEGER
+{
+       gint criteria = 0;
+       gint value = 0;
+
+       criteria = MATCHCRITERIA_SCORE_EQUAL;
+       value = atoi($2);
+       prop = matcherprop_new(criteria, NULL, 0, NULL, value);
+}
 | MATCHER_HEADER MATCHER_STRING
 {
        header = g_strdup($2);
@@ -656,7 +707,7 @@ MATCHER_EXECUTE MATCHER_STRING
 
        action_type = MATCHACTION_EXECUTE;
        cmd = $2;
-       action = filteringaction_new(action_type, 0, cmd);
+       action = filteringaction_new(action_type, 0, cmd, 0);
 }
 | MATCHER_MOVE MATCHER_STRING
 {
@@ -665,7 +716,7 @@ MATCHER_EXECUTE MATCHER_STRING
 
        action_type = MATCHACTION_MOVE;
        destination = $2;
-       action = filteringaction_new(action_type, 0, destination);
+       action = filteringaction_new(action_type, 0, destination, 0);
 }
 | MATCHER_COPY MATCHER_STRING
 {
@@ -674,42 +725,42 @@ MATCHER_EXECUTE MATCHER_STRING
 
        action_type = MATCHACTION_COPY;
        destination = $2;
-       action = filteringaction_new(action_type, 0, destination);
+       action = filteringaction_new(action_type, 0, destination, 0);
 }
 | MATCHER_DELETE
 {
        gint action_type = 0;
 
        action_type = MATCHACTION_DELETE;
-       action = filteringaction_new(action_type, 0, NULL);
+       action = filteringaction_new(action_type, 0, NULL, 0);
 }
 | MATCHER_MARK
 {
        gint action_type = 0;
 
        action_type = MATCHACTION_MARK;
-       action = filteringaction_new(action_type, 0, NULL);
+       action = filteringaction_new(action_type, 0, NULL, 0);
 }
 | MATCHER_UNMARK
 {
        gint action_type = 0;
 
        action_type = MATCHACTION_UNMARK;
-       action = filteringaction_new(action_type, 0, NULL);
+       action = filteringaction_new(action_type, 0, NULL, 0);
 }
 | MATCHER_MARK_AS_READ
 {
        gint action_type = 0;
 
        action_type = MATCHACTION_MARK_AS_READ;
-       action = filteringaction_new(action_type, 0, NULL);
+       action = filteringaction_new(action_type, 0, NULL, 0);
 }
 | MATCHER_MARK_AS_UNREAD
 {
        gint action_type = 0;
 
        action_type = MATCHACTION_MARK_AS_UNREAD;
-       action = filteringaction_new(action_type, 0, NULL);
+       action = filteringaction_new(action_type, 0, NULL, 0);
 }
 | MATCHER_FORWARD MATCHER_INTEGER MATCHER_STRING
 {
@@ -720,7 +771,7 @@ MATCHER_EXECUTE MATCHER_STRING
        action_type = MATCHACTION_FORWARD;
        account_id = $2;
        destination = $3;
-       action = filteringaction_new(action_type, account_id, destination);
+       action = filteringaction_new(action_type, account_id, destination, 0);
 }
 | MATCHER_FORWARD_AS_ATTACHMENT MATCHER_INTEGER MATCHER_STRING
 {
@@ -731,7 +782,16 @@ MATCHER_EXECUTE MATCHER_STRING
        action_type = MATCHACTION_FORWARD_AS_ATTACHMENT;
        account_id = $2;
        destination = $3;
-       action = filteringaction_new(action_type, account_id, destination);
+       action = filteringaction_new(action_type, account_id, destination, 0);
+}
+| MATCHER_COLOR MATCHER_INTEGER
+{
+       gint action_type = 0;
+       gint color = 0;
+
+       action_type = MATCHACTION_COLOR;
+       color = atoi($2);
+       action = filteringaction_new(action_type, 0, NULL, color);
 }
 ;
 
index cc76d05..a4b2f03 100644 (file)
@@ -202,7 +202,7 @@ gint proc_mbox(FolderItem *dest, const gchar *mbox, GHashTable *folder_table)
                }
 
                if (folder_table) {
-                       if (prefs_filtering == NULL) {
+                       if (global_processing == NULL) {
                                /* old filtering */
                                dropfolder = filter_get_dest_folder
                                        (prefs_common.fltlist, tmp_file);
@@ -225,7 +225,7 @@ gint proc_mbox(FolderItem *dest, const gchar *mbox, GHashTable *folder_table)
                        dropfolder = dest;
 
                /* old filtering */
-               if (prefs_filtering == NULL || folder_table == NULL) {  
+               if (global_processing == NULL || folder_table == NULL) {
                        if ((msgnum = folder_item_add_msg(dropfolder, tmp_file, TRUE)) < 0) {
                                fclose(mbox_fp);
                                unlink(tmp_file);
index f5e3ada..ba1e5aa 100644 (file)
@@ -436,7 +436,7 @@ void messageview_show(MessageView *messageview, MsgInfo *msginfo)
        if (prefs_common.return_receipt
            && (tmpmsginfo->dispositionnotificationto
                || tmpmsginfo->returnreceiptto)
-           && (MSG_IS_UNREAD(tmpmsginfo->flags))) {
+           && (MSG_IS_UNREAD(msginfo->flags))) {
                gint ok;
                
                if (alertpanel(_("Return Receipt"), _("Send return receipt ?"),
index 0dc0bd1..9b728c0 100644 (file)
@@ -50,6 +50,8 @@
 #include "addr_compl.h"
 #include "colorlabel.h"
 
+#include "matcher_parser.h"
+
 static struct Filtering {
        GtkWidget *window;
 
@@ -112,6 +114,8 @@ static void prefs_filtering_action_selection_changed(GtkList *list,
                                          
 static void prefs_filtering_reset_dialog(void);
 
+static FolderItem * cur_item = NULL;
+
 enum {
        ACTION_MOVE = 0,
        ACTION_COPY = 1,
@@ -181,27 +185,27 @@ static gint prefs_filtering_get_matching_from_action(gint action_id)
 {
        switch(action_id) {
        case ACTION_MOVE:
-               return MATCHING_ACTION_MOVE;
+               return MATCHACTION_MOVE;
        case ACTION_COPY:
-               return MATCHING_ACTION_COPY;
+               return MATCHACTION_COPY;
        case ACTION_DELETE:
-               return MATCHING_ACTION_DELETE;
+               return MATCHACTION_DELETE;
        case ACTION_MARK:
-               return MATCHING_ACTION_MARK;
+               return MATCHACTION_MARK;
        case ACTION_UNMARK:
-               return MATCHING_ACTION_UNMARK;
+               return MATCHACTION_UNMARK;
        case ACTION_MARK_AS_READ:
-               return MATCHING_ACTION_MARK_AS_READ;
+               return MATCHACTION_MARK_AS_READ;
        case ACTION_MARK_AS_UNREAD:
-               return MATCHING_ACTION_MARK_AS_UNREAD;
+               return MATCHACTION_MARK_AS_UNREAD;
        case ACTION_FORWARD:
-               return MATCHING_ACTION_FORWARD;
+               return MATCHACTION_FORWARD;
        case ACTION_FORWARD_AS_ATTACHMENT:
-               return MATCHING_ACTION_FORWARD_AS_ATTACHMENT;
+               return MATCHACTION_FORWARD_AS_ATTACHMENT;
        case ACTION_EXECUTE:
-               return MATCHING_EXECUTE;
+               return MATCHACTION_EXECUTE;
        case ACTION_COLOR:
-               return MATCHING_ACTION_COLOR;
+               return MATCHACTION_COLOR;
        default:
                return -1;
        }
@@ -221,7 +225,7 @@ static gchar * action_text [] = {
        N_("Color")
 };
 
-void prefs_filtering_open(void)
+void prefs_filtering_open(FolderItem * item)
 {
        if (prefs_rc_is_readonly(FILTERING_RC))
                return;
@@ -235,6 +239,8 @@ void prefs_filtering_open(void)
        manage_window_set_transient(GTK_WINDOW(filtering.window));
        gtk_widget_grab_focus(filtering.ok_btn);
 
+       cur_item = item;
+
        prefs_filtering_set_dialog();
 
        gtk_widget_show(filtering.window);
@@ -601,11 +607,18 @@ static void prefs_filtering_set_dialog(void)
 {
        GtkCList *clist = GTK_CLIST(filtering.cond_clist);
        GSList *cur;
+       GSList * prefs_filtering;
        
        gtk_clist_freeze(clist);
        gtk_clist_clear(clist);
 
        prefs_filtering_clist_set_row(-1, NULL);
+
+       if (cur_item == NULL)
+               prefs_filtering = global_processing;
+       else
+               prefs_filtering = cur_item->prefs->processing;
+
        for(cur = prefs_filtering ; cur != NULL ; cur = g_slist_next(cur)) {
                FilteringProp * prop = (FilteringProp *) cur->data;
 
@@ -633,6 +646,12 @@ static void prefs_filtering_set_list(void)
        GSList * cur;
        gchar * filtering_str;
        gchar * tmp;
+       GSList * prefs_filtering;
+
+       if (cur_item == NULL)
+               prefs_filtering = global_processing;
+       else
+               prefs_filtering = cur_item->prefs->processing;
 
        for(cur = prefs_filtering ; cur != NULL ; cur = g_slist_next(cur))
                filteringprop_free((FilteringProp *) cur->data);
@@ -642,14 +661,19 @@ static void prefs_filtering_set_list(void)
        while (gtk_clist_get_text(GTK_CLIST(filtering.cond_clist),
                                  row, 0, &filtering_str)) {
                if (strcmp(filtering_str, _("(New)")) != 0) {
-                       tmp = filtering_str;
-                       prop = filteringprop_parse(&tmp);
+                       /* tmp = filtering_str; */
+                       prop = matcher_parser_get_filtering(filtering_str);
                        if (prop != NULL)
-                               prefs_filtering = g_slist_append(prefs_filtering,
-                                                              prop);
+                               prefs_filtering =
+                                       g_slist_append(prefs_filtering, prop);
                }
                row++;
        }
+
+       if (cur_item == NULL)
+               global_processing = prefs_filtering;
+       else
+               cur_item->prefs->processing = prefs_filtering;
 }
 
 static gint prefs_filtering_clist_set_row(gint row, FilteringProp * prop)
@@ -703,9 +727,9 @@ static void prefs_filtering_condition_define(void)
        if (*cond_str != '\0') {
                gchar * tmp;
                
-               tmp = cond_str;
-               matchers = matcherlist_parse(&tmp);
-               if (tmp == NULL)
+               /* tmp = cond_str; */
+               matchers = matcher_parser_get_cond(cond_str);
+               if (matchers == NULL)
                        alertpanel_error(_("Match string is not valid."));
        }
 
@@ -768,10 +792,10 @@ static FilteringProp * prefs_filtering_dialog_to_filtering(void)
        
        action = filteringaction_new(action_type, account_id, destination, labelcolor);
 
-       tmp = cond_str;
-       cond = matcherlist_parse(&tmp);
+       /* tmp = cond_str; */
+       cond = matcher_parser_get_cond(cond_str);
 
-       if (tmp == NULL) {
+       if (cond == NULL) {
                alertpanel_error(_("Match string is not valid."));
                filteringaction_free(action);
                return NULL;
@@ -892,53 +916,53 @@ static void prefs_filtering_select_set(FilteringProp * prop)
                gtk_entry_set_text(GTK_ENTRY(filtering.dest_entry), "");
 
        switch(action->type) {
-       case MATCHING_ACTION_MOVE:
+       case MATCHACTION_MOVE:
                gtk_list_select_item(GTK_LIST(filtering.action_list),
                                     ACTION_MOVE);
                break;
-       case MATCHING_ACTION_COPY:
+       case MATCHACTION_COPY:
                gtk_list_select_item(GTK_LIST(filtering.action_list),
                                     ACTION_COPY);
                break;
-       case MATCHING_ACTION_DELETE:
+       case MATCHACTION_DELETE:
                gtk_list_select_item(GTK_LIST(filtering.action_list),
                                     ACTION_DELETE);
                break;
-       case MATCHING_ACTION_MARK:
+       case MATCHACTION_MARK:
                gtk_list_select_item(GTK_LIST(filtering.action_list),
                                     ACTION_MARK);
                break;
-       case MATCHING_ACTION_UNMARK:
+       case MATCHACTION_UNMARK:
                gtk_list_select_item(GTK_LIST(filtering.action_list),
                                     ACTION_UNMARK);
                break;
-       case MATCHING_ACTION_MARK_AS_READ:
+       case MATCHACTION_MARK_AS_READ:
                gtk_list_select_item(GTK_LIST(filtering.action_list),
                                     ACTION_MARK_AS_READ);
                break;
-       case MATCHING_ACTION_MARK_AS_UNREAD:
+       case MATCHACTION_MARK_AS_UNREAD:
                gtk_list_select_item(GTK_LIST(filtering.action_list),
                                     ACTION_MARK_AS_UNREAD);
                break;
-       case MATCHING_ACTION_FORWARD:
+       case MATCHACTION_FORWARD:
                gtk_list_select_item(GTK_LIST(filtering.action_list),
                                     ACTION_FORWARD);
                list_id = get_list_id_from_account_id(action->account_id);
                gtk_list_select_item(GTK_LIST(filtering.account_list),
                                     list_id);
                break;
-       case MATCHING_ACTION_FORWARD_AS_ATTACHMENT:
+       case MATCHACTION_FORWARD_AS_ATTACHMENT:
                list_id = get_list_id_from_account_id(action->account_id);
                gtk_list_select_item(GTK_LIST(filtering.action_list),
                                     ACTION_FORWARD_AS_ATTACHMENT);
                gtk_list_select_item(GTK_LIST(filtering.account_list),
                                     list_id);
                break;
-       case MATCHING_EXECUTE:
+       case MATCHACTION_EXECUTE:
                gtk_list_select_item(GTK_LIST(filtering.action_list),
                                     ACTION_EXECUTE);
                break;
-       case MATCHING_ACTION_COLOR:
+       case MATCHACTION_COLOR:
                gtk_list_select_item(GTK_LIST(filtering.action_list),
                                     ACTION_COLOR);
                gtk_option_menu_set_history(GTK_OPTION_MENU(filtering.color_optmenu), action->labelcolor);     
@@ -964,9 +988,9 @@ static void prefs_filtering_select(GtkCList *clist, gint row, gint column,
                                row, 0, &filtering_str))
                return;
        
-       tmp = filtering_str;
-       prop = filteringprop_parse(&tmp);
-       if (tmp == NULL)
+       /* tmp = filtering_str; */
+       prop = matcher_parser_get_filtering(filtering_str);
+       if (prop == NULL)
                return;
 
        prefs_filtering_select_set(prop);
@@ -1160,12 +1184,18 @@ static void prefs_filtering_key_pressed(GtkWidget *widget, GdkEventKey *event,
 static void prefs_filtering_ok(void)
 {
        prefs_filtering_set_list();
+       /*
        prefs_filtering_write_config();
+       */
+       prefs_matcher_write_config();
        prefs_filtering_close();
 }
 
 static void prefs_filtering_cancel(void)
 {
+       /*
        prefs_filtering_read_config();
+       */
+       prefs_matcher_read_config();
        prefs_filtering_close();
 }
index 09f1019..e32e774 100644 (file)
@@ -24,6 +24,6 @@
 void prefs_scoring_read_config (void);
 void prefs_scoring_write_config        (void);
 */
-void prefs_filtering_open              (void);
+void prefs_filtering_open(FolderItem * item);
 
 #endif /* __PREFS_FILTERING_H__ */
index 5273303..2bdd768 100644 (file)
@@ -46,6 +46,8 @@
 #include "alertpanel.h"
 #include "folder.h"
 
+#include "matcher_parser.h"
+
 static struct Matcher {
        GtkWidget *window;
 
@@ -679,10 +681,10 @@ static MatcherList * prefs_matcher_get_list(void)
                                  row, 0, &matcher_str)) {
 
                if (strcmp(matcher_str, _("(New)")) != 0) {
-                       tmp = matcher_str;
-                       prop = matcherprop_parse(&tmp);
+                       /* tmp = matcher_str; */
+                       prop = matcher_parser_get_prop(matcher_str);
                        
-                       if (tmp == NULL)
+                       if (prop == NULL)
                                break;
                        
                        matcher_list = g_slist_append(matcher_list, prop);
@@ -700,76 +702,76 @@ static MatcherList * prefs_matcher_get_list(void)
 static gint prefs_matcher_get_criteria_from_matching(gint matching_id)
 {
        switch(matching_id) {
-       case MATCHING_ALL:
+       case MATCHCRITERIA_ALL:
                return CRITERIA_ALL;
-       case MATCHING_NOT_UNREAD:
-       case MATCHING_UNREAD:
+       case MATCHCRITERIA_NOT_UNREAD:
+       case MATCHCRITERIA_UNREAD:
                return CRITERIA_UNREAD;
-       case MATCHING_NOT_NEW:
-       case MATCHING_NEW:
+       case MATCHCRITERIA_NOT_NEW:
+       case MATCHCRITERIA_NEW:
                return CRITERIA_NEW;
-       case MATCHING_NOT_MARKED:
-       case MATCHING_MARKED:
+       case MATCHCRITERIA_NOT_MARKED:
+       case MATCHCRITERIA_MARKED:
                return CRITERIA_MARKED;
-       case MATCHING_NOT_DELETED:
-       case MATCHING_DELETED:
+       case MATCHCRITERIA_NOT_DELETED:
+       case MATCHCRITERIA_DELETED:
                return CRITERIA_DELETED;
                break;
-       case MATCHING_NOT_REPLIED:
-       case MATCHING_REPLIED:
+       case MATCHCRITERIA_NOT_REPLIED:
+       case MATCHCRITERIA_REPLIED:
                return CRITERIA_REPLIED;
-       case MATCHING_NOT_FORWARDED:
-       case MATCHING_FORWARDED:
+       case MATCHCRITERIA_NOT_FORWARDED:
+       case MATCHCRITERIA_FORWARDED:
                return CRITERIA_FORWARDED;
-       case MATCHING_NOT_SUBJECT:
-       case MATCHING_SUBJECT:
+       case MATCHCRITERIA_NOT_SUBJECT:
+       case MATCHCRITERIA_SUBJECT:
                return CRITERIA_SUBJECT;
-       case MATCHING_NOT_FROM:
-       case MATCHING_FROM:
+       case MATCHCRITERIA_NOT_FROM:
+       case MATCHCRITERIA_FROM:
                return CRITERIA_FROM;
-       case MATCHING_NOT_TO:
-       case MATCHING_TO:
+       case MATCHCRITERIA_NOT_TO:
+       case MATCHCRITERIA_TO:
                return CRITERIA_TO;
-       case MATCHING_NOT_CC:
-       case MATCHING_CC:
+       case MATCHCRITERIA_NOT_CC:
+       case MATCHCRITERIA_CC:
                return CRITERIA_CC;
-       case MATCHING_NOT_NEWSGROUPS:
-       case MATCHING_NEWSGROUPS:
+       case MATCHCRITERIA_NOT_NEWSGROUPS:
+       case MATCHCRITERIA_NEWSGROUPS:
                return CRITERIA_NEWSGROUPS;
-       case MATCHING_NOT_INREPLYTO:
-       case MATCHING_INREPLYTO:
+       case MATCHCRITERIA_NOT_INREPLYTO:
+       case MATCHCRITERIA_INREPLYTO:
                return CRITERIA_INREPLYTO;
-       case MATCHING_NOT_REFERENCES:
-       case MATCHING_REFERENCES:
+       case MATCHCRITERIA_NOT_REFERENCES:
+       case MATCHCRITERIA_REFERENCES:
                return CRITERIA_REFERENCES;
-       case MATCHING_NOT_TO_AND_NOT_CC:
-       case MATCHING_TO_OR_CC:
+       case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
+       case MATCHCRITERIA_TO_OR_CC:
                return CRITERIA_TO_OR_CC;
-       case MATCHING_NOT_BODY_PART:
-       case MATCHING_BODY_PART:
+       case MATCHCRITERIA_NOT_BODY_PART:
+       case MATCHCRITERIA_BODY_PART:
                return CRITERIA_BODY_PART;
-       case MATCHING_NOT_MESSAGE:
-       case MATCHING_MESSAGE:
+       case MATCHCRITERIA_NOT_MESSAGE:
+       case MATCHCRITERIA_MESSAGE:
                return CRITERIA_MESSAGE;
                break;
-       case MATCHING_NOT_HEADERS_PART:
-       case MATCHING_HEADERS_PART:
+       case MATCHCRITERIA_NOT_HEADERS_PART:
+       case MATCHCRITERIA_HEADERS_PART:
                return CRITERIA_HEADERS_PART;
-       case MATCHING_NOT_HEADER:
-       case MATCHING_HEADER:
+       case MATCHCRITERIA_NOT_HEADER:
+       case MATCHCRITERIA_HEADER:
                return CRITERIA_HEADER;
-       case MATCHING_AGE_GREATER:
+       case MATCHCRITERIA_AGE_GREATER:
                return CRITERIA_AGE_GREATER;
-       case MATCHING_AGE_LOWER:
+       case MATCHCRITERIA_AGE_LOWER:
                return CRITERIA_AGE_LOWER;
-       case MATCHING_SCORE_GREATER:
+       case MATCHCRITERIA_SCORE_GREATER:
                return CRITERIA_SCORE_GREATER;
-       case MATCHING_SCORE_LOWER:
+       case MATCHCRITERIA_SCORE_LOWER:
                return CRITERIA_SCORE_LOWER;
-       case MATCHING_SCORE_EQUAL:
+       case MATCHCRITERIA_SCORE_EQUAL:
                return CRITERIA_SCORE_EQUAL;
-       case MATCHING_NOT_EXECUTE:
-       case MATCHING_EXECUTE:
+       case MATCHCRITERIA_NOT_EXECUTE:
+       case MATCHCRITERIA_EXECUTE:
                return CRITERIA_EXECUTE;
                break;
        default:
@@ -781,55 +783,55 @@ static gint prefs_matcher_get_matching_from_criteria(gint criteria_id)
 {
        switch (criteria_id) {
        case CRITERIA_ALL:
-               return MATCHING_ALL;
+               return MATCHCRITERIA_ALL;
        case CRITERIA_UNREAD:
-               return MATCHING_UNREAD;
+               return MATCHCRITERIA_UNREAD;
        case CRITERIA_NEW:
-               return MATCHING_NEW;
+               return MATCHCRITERIA_NEW;
        case CRITERIA_MARKED:
-               return MATCHING_MARKED;
+               return MATCHCRITERIA_MARKED;
        case CRITERIA_DELETED:
-               return MATCHING_DELETED;
+               return MATCHCRITERIA_DELETED;
        case CRITERIA_REPLIED:
-               return MATCHING_REPLIED;
+               return MATCHCRITERIA_REPLIED;
        case CRITERIA_FORWARDED:
-               return MATCHING_FORWARDED;
+               return MATCHCRITERIA_FORWARDED;
        case CRITERIA_SUBJECT:
-               return MATCHING_SUBJECT;
+               return MATCHCRITERIA_SUBJECT;
        case CRITERIA_FROM:
-               return MATCHING_FROM;
+               return MATCHCRITERIA_FROM;
        case CRITERIA_TO:
-               return MATCHING_TO;
+               return MATCHCRITERIA_TO;
        case CRITERIA_CC:
-               return MATCHING_CC;
+               return MATCHCRITERIA_CC;
        case CRITERIA_TO_OR_CC:
-               return MATCHING_TO_OR_CC;
+               return MATCHCRITERIA_TO_OR_CC;
        case CRITERIA_NEWSGROUPS:
-               return MATCHING_NEWSGROUPS;
+               return MATCHCRITERIA_NEWSGROUPS;
        case CRITERIA_INREPLYTO:
-               return MATCHING_INREPLYTO;
+               return MATCHCRITERIA_INREPLYTO;
        case CRITERIA_REFERENCES:
-               return MATCHING_REFERENCES;
+               return MATCHCRITERIA_REFERENCES;
        case CRITERIA_AGE_GREATER:
-               return MATCHING_AGE_GREATER;
+               return MATCHCRITERIA_AGE_GREATER;
        case CRITERIA_AGE_LOWER:
-               return MATCHING_AGE_LOWER;
+               return MATCHCRITERIA_AGE_LOWER;
        case CRITERIA_SCORE_GREATER:
-               return MATCHING_SCORE_GREATER;
+               return MATCHCRITERIA_SCORE_GREATER;
        case CRITERIA_SCORE_LOWER:
-               return MATCHING_SCORE_LOWER;
+               return MATCHCRITERIA_SCORE_LOWER;
        case CRITERIA_SCORE_EQUAL:
-               return MATCHING_SCORE_EQUAL;
+               return MATCHCRITERIA_SCORE_EQUAL;
        case CRITERIA_HEADER:
-               return MATCHING_HEADER;
+               return MATCHCRITERIA_HEADER;
        case CRITERIA_HEADERS_PART:
-               return MATCHING_HEADERS_PART;
+               return MATCHCRITERIA_HEADERS_PART;
        case CRITERIA_BODY_PART:
-               return MATCHING_BODY_PART;
+               return MATCHCRITERIA_BODY_PART;
        case CRITERIA_MESSAGE:
-               return MATCHING_MESSAGE;
+               return MATCHCRITERIA_MESSAGE;
        case CRITERIA_EXECUTE:
-               return MATCHING_EXECUTE;
+               return MATCHCRITERIA_EXECUTE;
        default:
                return -1;
        }
@@ -838,44 +840,44 @@ static gint prefs_matcher_get_matching_from_criteria(gint criteria_id)
 static gint prefs_matcher_not_criteria(gint matcher_criteria)
 {
        switch(matcher_criteria) {
-       case MATCHING_UNREAD:
-               return MATCHING_NOT_UNREAD;
-       case MATCHING_NEW:
-               return MATCHING_NOT_NEW;
-       case MATCHING_MARKED:
-               return MATCHING_NOT_MARKED;
-       case MATCHING_DELETED:
-               return MATCHING_NOT_DELETED;
-       case MATCHING_REPLIED:
-               return MATCHING_NOT_REPLIED;
-       case MATCHING_FORWARDED:
-               return MATCHING_NOT_FORWARDED;
-       case MATCHING_SUBJECT:
-               return MATCHING_NOT_SUBJECT;
-       case MATCHING_FROM:
-               return MATCHING_NOT_FROM;
-       case MATCHING_TO:
-               return MATCHING_NOT_TO;
-       case MATCHING_CC:
-               return MATCHING_NOT_CC;
-       case MATCHING_TO_OR_CC:
-               return MATCHING_NOT_TO_AND_NOT_CC;
-       case MATCHING_NEWSGROUPS:
-               return MATCHING_NOT_NEWSGROUPS;
-       case MATCHING_INREPLYTO:
-               return MATCHING_NOT_INREPLYTO;
-       case MATCHING_REFERENCES:
-               return MATCHING_NOT_REFERENCES;
-       case MATCHING_HEADER:
-               return MATCHING_NOT_HEADER;
-       case MATCHING_HEADERS_PART:
-               return MATCHING_NOT_HEADERS_PART;
-       case MATCHING_MESSAGE:
-               return MATCHING_NOT_MESSAGE;
-       case MATCHING_EXECUTE:
-               return MATCHING_NOT_EXECUTE;
-       case MATCHING_BODY_PART:
-               return MATCHING_NOT_BODY_PART;
+       case MATCHCRITERIA_UNREAD:
+               return MATCHCRITERIA_NOT_UNREAD;
+       case MATCHCRITERIA_NEW:
+               return MATCHCRITERIA_NOT_NEW;
+       case MATCHCRITERIA_MARKED:
+               return MATCHCRITERIA_NOT_MARKED;
+       case MATCHCRITERIA_DELETED:
+               return MATCHCRITERIA_NOT_DELETED;
+       case MATCHCRITERIA_REPLIED:
+               return MATCHCRITERIA_NOT_REPLIED;
+       case MATCHCRITERIA_FORWARDED:
+               return MATCHCRITERIA_NOT_FORWARDED;
+       case MATCHCRITERIA_SUBJECT:
+               return MATCHCRITERIA_NOT_SUBJECT;
+       case MATCHCRITERIA_FROM:
+               return MATCHCRITERIA_NOT_FROM;
+       case MATCHCRITERIA_TO:
+               return MATCHCRITERIA_NOT_TO;
+       case MATCHCRITERIA_CC:
+               return MATCHCRITERIA_NOT_CC;
+       case MATCHCRITERIA_TO_OR_CC:
+               return MATCHCRITERIA_NOT_TO_AND_NOT_CC;
+       case MATCHCRITERIA_NEWSGROUPS:
+               return MATCHCRITERIA_NOT_NEWSGROUPS;
+       case MATCHCRITERIA_INREPLYTO:
+               return MATCHCRITERIA_NOT_INREPLYTO;
+       case MATCHCRITERIA_REFERENCES:
+               return MATCHCRITERIA_NOT_REFERENCES;
+       case MATCHCRITERIA_HEADER:
+               return MATCHCRITERIA_NOT_HEADER;
+       case MATCHCRITERIA_HEADERS_PART:
+               return MATCHCRITERIA_NOT_HEADERS_PART;
+       case MATCHCRITERIA_MESSAGE:
+               return MATCHCRITERIA_NOT_MESSAGE;
+       case MATCHCRITERIA_EXECUTE:
+               return MATCHCRITERIA_NOT_EXECUTE;
+       case MATCHCRITERIA_BODY_PART:
+               return MATCHCRITERIA_NOT_BODY_PART;
        default:
                return matcher_criteria;
        }
@@ -938,15 +940,15 @@ static MatcherProp * prefs_matcher_dialog_to_matcher()
 
        if (use_regexp) {
                if (case_sensitive)
-                       matchtype = MATCHING_REGEXP;
+                       matchtype = MATCHTYPE_REGEXP;
                else
-                       matchtype = MATCHING_REGEXPCASE;
+                       matchtype = MATCHTYPE_REGEXPCASE;
        }
        else {
                if (case_sensitive)
-                       matchtype = MATCHING_MATCH;
+                       matchtype = MATCHTYPE_MATCH;
                else
-                       matchtype = MATCHING_MATCHCASE;
+                       matchtype = MATCHTYPE_MATCHCASE;
        }
 
        header = NULL;
@@ -1131,9 +1133,9 @@ static void prefs_matcher_select(GtkCList *clist, gint row, gint column,
                return;
        }
 
-       tmp = matcher_str;
-       prop = matcherprop_parse(&tmp);
-       if (tmp == NULL)
+       //      tmp = matcher_str;
+       prop = matcher_parser_get_prop(matcher_str);
+       if (prop == NULL)
                return;
 
        criteria = prefs_matcher_get_criteria_from_matching(prop->criteria);
@@ -1142,67 +1144,67 @@ static void prefs_matcher_select(GtkCList *clist, gint row, gint column,
                                     criteria);
 
        switch(prop->criteria) {
-       case MATCHING_NOT_UNREAD:
-       case MATCHING_NOT_NEW:
-       case MATCHING_NOT_MARKED:
-       case MATCHING_NOT_DELETED:
-       case MATCHING_NOT_REPLIED:
-       case MATCHING_NOT_FORWARDED:
-       case MATCHING_NOT_SUBJECT:
-       case MATCHING_NOT_FROM:
-       case MATCHING_NOT_TO:
-       case MATCHING_NOT_CC:
-       case MATCHING_NOT_NEWSGROUPS:
-       case MATCHING_NOT_INREPLYTO:
-       case MATCHING_NOT_REFERENCES:
-       case MATCHING_NOT_TO_AND_NOT_CC:
-       case MATCHING_NOT_BODY_PART:
-       case MATCHING_NOT_MESSAGE:
-       case MATCHING_NOT_HEADERS_PART:
-       case MATCHING_NOT_HEADER:
+       case MATCHCRITERIA_NOT_UNREAD:
+       case MATCHCRITERIA_NOT_NEW:
+       case MATCHCRITERIA_NOT_MARKED:
+       case MATCHCRITERIA_NOT_DELETED:
+       case MATCHCRITERIA_NOT_REPLIED:
+       case MATCHCRITERIA_NOT_FORWARDED:
+       case MATCHCRITERIA_NOT_SUBJECT:
+       case MATCHCRITERIA_NOT_FROM:
+       case MATCHCRITERIA_NOT_TO:
+       case MATCHCRITERIA_NOT_CC:
+       case MATCHCRITERIA_NOT_NEWSGROUPS:
+       case MATCHCRITERIA_NOT_INREPLYTO:
+       case MATCHCRITERIA_NOT_REFERENCES:
+       case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
+       case MATCHCRITERIA_NOT_BODY_PART:
+       case MATCHCRITERIA_NOT_MESSAGE:
+       case MATCHCRITERIA_NOT_HEADERS_PART:
+       case MATCHCRITERIA_NOT_HEADER:
                negative_cond = TRUE;
                break;
        }
        
        switch(prop->criteria) {
-       case MATCHING_ALL:
+       case MATCHCRITERIA_ALL:
                break;
 
-       case MATCHING_NOT_SUBJECT:
-       case MATCHING_NOT_FROM:
-       case MATCHING_NOT_TO:
-       case MATCHING_NOT_CC:
-       case MATCHING_NOT_TO_AND_NOT_CC:
-       case MATCHING_NOT_NEWSGROUPS:
-       case MATCHING_NOT_INREPLYTO:
-       case MATCHING_NOT_REFERENCES:
-       case MATCHING_NOT_HEADERS_PART:
-       case MATCHING_NOT_BODY_PART:
-       case MATCHING_NOT_MESSAGE:
-       case MATCHING_SUBJECT:
-       case MATCHING_FROM:
-       case MATCHING_TO:
-       case MATCHING_CC:
-       case MATCHING_TO_OR_CC:
-       case MATCHING_NEWSGROUPS:
-       case MATCHING_INREPLYTO:
-       case MATCHING_REFERENCES:
-       case MATCHING_HEADERS_PART:
-       case MATCHING_BODY_PART:
-       case MATCHING_MESSAGE:
+       case MATCHCRITERIA_NOT_SUBJECT:
+       case MATCHCRITERIA_NOT_FROM:
+       case MATCHCRITERIA_NOT_TO:
+       case MATCHCRITERIA_NOT_CC:
+       case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
+       case MATCHCRITERIA_NOT_NEWSGROUPS:
+       case MATCHCRITERIA_NOT_INREPLYTO:
+       case MATCHCRITERIA_NOT_REFERENCES:
+       case MATCHCRITERIA_NOT_HEADERS_PART:
+       case MATCHCRITERIA_NOT_BODY_PART:
+       case MATCHCRITERIA_NOT_MESSAGE:
+       case MATCHCRITERIA_SUBJECT:
+       case MATCHCRITERIA_FROM:
+       case MATCHCRITERIA_TO:
+       case MATCHCRITERIA_CC:
+       case MATCHCRITERIA_TO_OR_CC:
+       case MATCHCRITERIA_NEWSGROUPS:
+       case MATCHCRITERIA_INREPLYTO:
+       case MATCHCRITERIA_REFERENCES:
+       case MATCHCRITERIA_HEADERS_PART:
+       case MATCHCRITERIA_BODY_PART:
+       case MATCHCRITERIA_MESSAGE:
                gtk_entry_set_text(GTK_ENTRY(matcher.value_entry), prop->expr);
                break;
 
-       case MATCHING_AGE_GREATER:
-       case MATCHING_AGE_LOWER:
-       case MATCHING_SCORE_GREATER:
-       case MATCHING_SCORE_LOWER:
-       case MATCHING_SCORE_EQUAL:
+       case MATCHCRITERIA_AGE_GREATER:
+       case MATCHCRITERIA_AGE_LOWER:
+       case MATCHCRITERIA_SCORE_GREATER:
+       case MATCHCRITERIA_SCORE_LOWER:
+       case MATCHCRITERIA_SCORE_EQUAL:
                gtk_entry_set_text(GTK_ENTRY(matcher.value_entry), itos(prop->value));
                break;
 
-       case MATCHING_NOT_HEADER:
-       case MATCHING_HEADER:
+       case MATCHCRITERIA_NOT_HEADER:
+       case MATCHCRITERIA_HEADER:
                gtk_entry_set_text(GTK_ENTRY(matcher.header_entry), prop->header);
                gtk_entry_set_text(GTK_ENTRY(matcher.value_entry), prop->expr);
                break;
@@ -1214,22 +1216,22 @@ static void prefs_matcher_select(GtkCList *clist, gint row, gint column,
                gtk_list_select_item(GTK_LIST(matcher.predicate_list), 0);
 
        switch(prop->matchtype) {
-       case MATCHING_MATCH:
+       case MATCHTYPE_MATCH:
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.regexp_chkbtn), FALSE);
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.case_chkbtn), TRUE);
                break;
 
-       case MATCHING_MATCHCASE:
+       case MATCHTYPE_MATCHCASE:
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.regexp_chkbtn), FALSE);
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.case_chkbtn), FALSE);
                break;
 
-       case MATCHING_REGEXP:
+       case MATCHTYPE_REGEXP:
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.regexp_chkbtn), TRUE);
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.case_chkbtn), TRUE);
                break;
 
-       case MATCHING_REGEXPCASE:
+       case MATCHTYPE_REGEXPCASE:
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.regexp_chkbtn), TRUE);
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(matcher.case_chkbtn), FALSE);
                break;
index 3a18783..b1d2ec7 100644 (file)
@@ -47,6 +47,8 @@
 #include "folder.h"
 #include "scoring.h"
 
+#include "matcher_parser.h"
+
 static struct Scoring {
        GtkWidget *window;
 
@@ -452,8 +454,8 @@ static void prefs_scoring_set_list(void)
        while (gtk_clist_get_text(GTK_CLIST(scoring.cond_clist),
                                  row, 0, &scoring_str)) {
                if (strcmp(scoring_str, _("(New)")) != 0) {
-                       tmp = scoring_str;
-                       prop = scoringprop_parse(&tmp);
+                       /* tmp = scoring_str; */
+                       prop = matcher_parser_get_scoring(scoring_str);
                        if (prop != NULL)
                                prefs_scoring = g_slist_append(prefs_scoring,
                                                               prop);
@@ -527,9 +529,9 @@ static void prefs_scoring_condition_define(void)
        if (*cond_str != '\0') {
                gchar * tmp;
                
-               tmp = cond_str;
-               matchers = matcherlist_parse(&tmp);
-               if (tmp == NULL)
+               /* tmp = cond_str; */
+               matchers = matcher_parser_get_cond(cond_str);
+               if (matchers == NULL)
                        alertpanel_error(_("Match string is not valid."));
        }
 
@@ -564,10 +566,10 @@ static void prefs_scoring_register_cb(void)
        }
 
        score = atoi(score_str);
-       tmp = cond_str;
-       cond = matcherlist_parse(&tmp);
+       /* tmp = cond_str; */
+       cond = matcher_parser_get_cond(cond_str);
 
-       if (tmp == NULL) {
+       if (cond == NULL) {
                alertpanel_error(_("Match string is not valid."));
                return;
        }
@@ -610,10 +612,10 @@ static void prefs_scoring_substitute_cb(void)
        }
 
        score = atoi(score_str);
-       tmp = cond_str;
-       cond = matcherlist_parse(&tmp);
+       /* tmp = cond_str; */
+       cond = matcher_parser_get_cond(cond_str);
 
-       if (tmp == NULL) {
+       if (cond == NULL) {
                alertpanel_error(_("Match string is not valid."));
                return;
        }
@@ -715,9 +717,9 @@ static void prefs_scoring_select(GtkCList *clist, gint row, gint column,
                                row, 0, &scoring_str))
                return;
 
-       tmp = scoring_str;
-       prop = scoringprop_parse(&tmp);
-       if (tmp == NULL)
+       /* tmp = scoring_str; */
+       prop = matcher_parser_get_scoring(scoring_str);
+       if (prop == NULL)
                return;
 
        prefs_scoring_select_set_dialog(prop);
@@ -741,8 +743,9 @@ static void prefs_scoring_key_pressed(GtkWidget *widget, GdkEventKey *event,
 
 static void prefs_scoring_ok(void)
 {
+       prefs_common_save_config();
        prefs_scoring_set_list();
-       prefs_scoring_write_config();
+       prefs_matcher_write_config();
        if (cur_item != NULL)
                prefs_folder_item_save_config(cur_item);
        gtk_widget_hide(scoring.window);
@@ -750,6 +753,6 @@ static void prefs_scoring_ok(void)
 
 static void prefs_scoring_cancel(void)
 {
-       prefs_scoring_read_config();
+       prefs_matcher_read_config();
        gtk_widget_hide(scoring.window);
 }
index 4f7ea3d..6f075a3 100644 (file)
@@ -15,8 +15,9 @@
 #define PREFSBUFSIZE           1024
 
 
-GSList * global_scoring;
+GSList * global_scoring = NULL;
 
+#if 0
 ScoringProp * scoringprop_parse(gchar ** str)
 {
        gchar * tmp;
@@ -41,7 +42,7 @@ ScoringProp * scoringprop_parse(gchar ** str)
                return NULL;
        }
 
-       if (key != MATCHING_SCORE) {
+       if (key != MATCHACTION_SCORE) {
                matcherlist_free(matchers);
                * str = NULL;
                return NULL;
@@ -60,7 +61,7 @@ ScoringProp * scoringprop_parse(gchar ** str)
        * str = tmp;
        return scoring;
 }
-
+#endif
 
 ScoringProp * scoringprop_new(MatcherList * matchers, int score)
 {
@@ -138,52 +139,6 @@ static void scoringprop_print(ScoringProp * prop)
   if score is = MAX_SCORE (-999), no more match is done in the list
  */
 
-/*
-void prefs_scoring_read_config(void)
-{
-       gchar *rcpath;
-       FILE *fp;
-       gchar buf[PREFSBUFSIZE];
-
-       debug_print(_("Reading headers configuration...\n"));
-
-       rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, SCORING_RC, NULL);
-       if ((fp = fopen(rcpath, "r")) == NULL) {
-               if (ENOENT != errno) FILE_OP_ERROR(rcpath, "fopen");
-               g_free(rcpath);
-               prefs_scoring = NULL;
-               return;
-       }
-       g_free(rcpath);
-
-       while (prefs_scoring != NULL) {
-               ScoringProp * scoring = (ScoringProp *) prefs_scoring->data;
-               scoringprop_free(scoring);
-               prefs_scoring = g_slist_remove(prefs_scoring, scoring);
-       }
-
-       while (fgets(buf, sizeof(buf), fp) != NULL) {
-               ScoringProp * scoring;
-               gchar * tmp;
-
-               g_strchomp(buf);
-
-               if ((*buf != '#') && (*buf != '\0')) {
-                       tmp = buf;
-                       scoring = scoringprop_parse(&tmp);
-                       if (tmp != NULL) {
-                               prefs_scoring = g_slist_append(prefs_scoring,
-                                                              scoring);
-                       }
-                       else {
-                               g_warning(_("syntax error : %s\n"), buf);
-                       }
-               }
-       }
-
-       fclose(fp);
-}
-*/
 
 gchar * scoringprop_to_string(ScoringProp * prop)
 {
@@ -203,89 +158,10 @@ gchar * scoringprop_to_string(ScoringProp * prop)
        return scoring_str;
 }
 
-/*
-void prefs_scoring_write_config(void)
-{
-       gchar *rcpath;
-       PrefFile *pfile;
-       GSList *cur;
-       ScoringProp * prop;
-
-       debug_print(_("Writing scoring configuration...\n"));
-
-       rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, SCORING_RC, NULL);
-
-       if ((pfile = prefs_write_open(rcpath)) == NULL) {
-               g_warning(_("failed to write configuration to file\n"));
-               g_free(rcpath);
-               return;
-       }
-
-       for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
-               gchar *scoring_str;
-
-               prop = (ScoringProp *) cur->data;
-               scoring_str = scoringprop_to_string(prop);
-               if (fputs(scoring_str, pfile->fp) == EOF ||
-                   fputc('\n', pfile->fp) == EOF) {
-                       FILE_OP_ERROR(rcpath, "fputs || fputc");
-                       prefs_write_close_revert(pfile);
-                       g_free(rcpath);
-                       g_free(scoring_str);
-                       return;
-               }
-               g_free(scoring_str);
-       }
-
-       g_free(rcpath);
-
-       if (prefs_write_close(pfile) < 0) {
-               g_warning(_("failed to write configuration to file\n"));
-               return;
-       }
-}
-*/
-
-void prefs_scoring_free(GSList * prefs_scoring)
-{
-       while (prefs_scoring != NULL) {
-               ScoringProp * scoring = (ScoringProp *) prefs_scoring->data;
-               scoringprop_free(scoring);
-               prefs_scoring = g_slist_remove(prefs_scoring, scoring);
-       }
-}
-
-static gboolean prefs_scoring_free_func(GNode *node, gpointer data)
-{
-       FolderItem *item = node->data;
-
-       if(!item->prefs)
-               return FALSE;
-
-       prefs_scoring_free(item->prefs->scoring);
-       item->prefs->scoring = NULL;
-
-       return FALSE;
-}
-
-static void prefs_scoring_clear()
-{
-       GList * cur;
-
-       for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
-               Folder *folder;
-
-               folder = (Folder *) cur->data;
-               g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
-                               prefs_scoring_free_func, NULL);
-       }
-
-       prefs_scoring_free(global_scoring);
-       global_scoring = NULL;
-}
 
 void prefs_scoring_read_config(void)
 {
+       /*
        gchar *rcpath;
        FILE *fp;
        gchar buf[PREFSBUFSIZE];
@@ -343,7 +219,6 @@ void prefs_scoring_read_config(void)
                                                               scoring);
                        }
                        else {
-                               /* debug */
                                g_warning(_("syntax error : %s\n"), buf);
                        }
                }
@@ -355,8 +230,10 @@ void prefs_scoring_read_config(void)
                item->prefs->scoring = prefs_scoring;
 
        fclose(fp);
+       */
 }
 
+/*
 static void prefs_scoring_write(FILE * fp, GSList * prefs_scoring)
 {
        GSList * cur;
@@ -412,7 +289,9 @@ static void prefs_scoring_save(FILE * fp)
                                prefs_scoring_write_func, fp);
        }
 }
+*/
 
+/*
 void prefs_scoring_write_config(void)
 {
        gchar *rcpath;
@@ -440,3 +319,43 @@ void prefs_scoring_write_config(void)
                return;
        }
 }
+*/
+
+
+void prefs_scoring_free(GSList * prefs_scoring)
+{
+       while (prefs_scoring != NULL) {
+               ScoringProp * scoring = (ScoringProp *) prefs_scoring->data;
+               scoringprop_free(scoring);
+               prefs_scoring = g_slist_remove(prefs_scoring, scoring);
+       }
+}
+
+static gboolean prefs_scoring_free_func(GNode *node, gpointer data)
+{
+       FolderItem *item = node->data;
+
+       if(!item->prefs)
+               return FALSE;
+
+       prefs_scoring_free(item->prefs->scoring);
+       item->prefs->scoring = NULL;
+
+       return FALSE;
+}
+
+void prefs_scoring_clear()
+{
+       GList * cur;
+
+       for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
+               Folder *folder;
+
+               folder = (Folder *) cur->data;
+               g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
+                               prefs_scoring_free_func, NULL);
+       }
+
+       prefs_scoring_free(global_scoring);
+       global_scoring = NULL;
+}
index e8627ac..e9ab3b1 100644 (file)
@@ -33,6 +33,7 @@ void prefs_scoring_write_config(void);
 void prefs_scoring_read_config(void);
 gchar * scoringprop_to_string(ScoringProp * prop);
 
+void prefs_scoring_clear();
 void prefs_scoring_free(GSList * prefs_scoring);
 
 #endif
index ee8f682..d5539e4 100644 (file)
@@ -2219,13 +2219,6 @@ static void summary_display_msg(SummaryView *summaryview, GtkCTreeNode *row,
                summaryview->newmsgs--;
        if (MSG_IS_UNREAD(msginfo->flags) && !MSG_IS_IGNORE_THREAD(msginfo->flags))
                summaryview->unread--;
-       if (MSG_IS_NEW(msginfo->flags) || MSG_IS_UNREAD(msginfo->flags)) {
-               MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_NEW | MSG_UNREAD);
-               CHANGE_FLAGS(msginfo);
-               summary_set_row_marks(summaryview, row);
-               gtk_clist_thaw(GTK_CLIST(ctree));
-               summary_status_show(summaryview);
-       }
 
        if (new_window) {
                MessageView *msgview;
@@ -2249,6 +2242,14 @@ static void summary_display_msg(SummaryView *summaryview, GtkCTreeNode *row,
                gtkut_ctree_node_move_if_on_the_edge(ctree, row);
        }
 
+       if (MSG_IS_NEW(msginfo->flags) || MSG_IS_UNREAD(msginfo->flags)) {
+               MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_NEW | MSG_UNREAD);
+               CHANGE_FLAGS(msginfo);
+               summary_set_row_marks(summaryview, row);
+               gtk_clist_thaw(GTK_CLIST(ctree));
+               summary_status_show(summaryview);
+       }
+
        if (GTK_WIDGET_VISIBLE(summaryview->headerwin->window))
                header_window_show(summaryview->headerwin, msginfo);
 
@@ -3499,7 +3500,7 @@ static void summary_unthread_for_exec_func(GtkCTree *ctree, GtkCTreeNode *node,
 
 void summary_filter(SummaryView *summaryview)
 {
-       if (!prefs_common.fltlist && !prefs_filtering) {
+       if (!prefs_common.fltlist && !global_processing) {
                alertpanel_error(_("No filter rules defined."));
                return;
        }
@@ -3512,7 +3513,7 @@ void summary_filter(SummaryView *summaryview)
 
        gtk_clist_freeze(GTK_CLIST(summaryview->ctree));
 
-       if (prefs_filtering == NULL) {
+       if (global_processing == NULL) {
                gtk_ctree_pre_recursive(GTK_CTREE(summaryview->ctree), NULL,
                                        GTK_CTREE_FUNC(summary_filter_func),
                                        summaryview);
@@ -3559,7 +3560,7 @@ static void summary_filter_func(GtkCTree *ctree, GtkCTreeNode *node,
        gchar *file;
        FolderItem *dest;
 
-       if (prefs_filtering == NULL) {
+       if (global_processing == NULL) {
                /* old filtering */
                file = procmsg_get_message_file_path(msginfo);
                dest = filter_get_dest_folder(prefs_common.fltlist, file);
@@ -3570,7 +3571,7 @@ static void summary_filter_func(GtkCTree *ctree, GtkCTreeNode *node,
                        summary_move_row_to(summaryview, node, dest);
        }
        else
-               filter_msginfo_move_or_delete(prefs_filtering, msginfo,
+               filter_msginfo_move_or_delete(global_processing, msginfo,
                                              summaryview->folder_table);
 }