Sylpheed

/*

 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client

 * Copyright (C) 1999-2008 Hiroyuki Yamamoto

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include "defs.h"

#include <glib.h>

#include <glib/gi18n.h>

#include <gtk/gtk.h>

#include <gdk/gdkkeysyms.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include "main.h"

#include "prefs.h"

#include "prefs_filter.h"

#include "prefs_filter_edit.h"

#include "prefs_common.h"

#include "mainwindow.h"

#include "foldersel.h"

#include "colorlabel.h"

#include "manage_window.h"

#include "procheader.h"

#include "menu.h"

#include "filter.h"

#include "utils.h"

#include "gtkutils.h"

#include "stock_pixmap.h"

#include "alertpanel.h"

#include "folder.h"

static struct FilterRuleEditWindow {

        GtkWidget *window;

        GtkWidget *name_entry;

        GtkWidget *bool_op_optmenu;

        GtkWidget *cond_scrolled_win;

        FilterCondEdit cond_edit;

        GtkWidget *action_scrolled_win;

        GtkWidget *action_vbox;

        GSList *action_hbox_list;

        GtkWidget *ok_btn;

        GtkWidget *cancel_btn;

        FilterRule *new_rule;

        gboolean edit_finished;

} rule_edit_window;

static struct FilterEditHeaderListDialog {

        GtkWidget *window;

        GtkWidget *clist;

        GtkWidget *entry;

        gboolean finished;

        gboolean ok;

} edit_header_list_dialog;

static void prefs_filter_edit_create                (void);

static void prefs_filter_edit_clear                (void);

static void prefs_filter_edit_rule_to_dialog        (FilterRule        *rule,

                                                 const gchar        *default_name);

static void prefs_filter_edit_update_header_list(FilterCondEdit        *cond_list);

static void prefs_filter_edit_set_action_hbox_menu_sensitive

                                                (ActionHBox        *hbox,

                                                 ActionMenuType         type,

                                                 gboolean         sensitive);

static void prefs_filter_edit_set_action_hbox_menus_sensitive

                                                (void);

static void prefs_filter_edit_get_action_hbox_menus_selection

                                                (gboolean        *selection);

static ActionMenuType prefs_filter_edit_get_action_hbox_type

                                                (ActionHBox        *hbox);

static void prefs_filter_edit_insert_action_hbox(ActionHBox        *hbox,

                                                 gint                 pos);

static void prefs_filter_edit_remove_cond_hbox        (FilterCondEdit        *cond_edit,

                                                 CondHBox        *hbox);

static void prefs_filter_edit_remove_action_hbox(ActionHBox        *hbox);

static void prefs_filter_edit_add_rule_action        (FilterRule        *rule);

static void prefs_filter_edit_set_cond_header_menu

                                                (FilterCondEdit        *cond_edit,

                                                 CondHBox        *hbox);

static void prefs_filter_edit_activate_cond_header

                                                (FilterCondEdit        *cond_edit,

                                                 const gchar        *header);

static void prefs_filter_edit_edit_header_list        (FilterCondEdit        *cond_edit);

static FilterRule *prefs_filter_edit_dialog_to_rule        (void);

/* callback functions */

static gint prefs_filter_edit_deleted                (GtkWidget        *widget,

                                                 GdkEventAny        *event,

                                                 gpointer         data);

static gboolean prefs_filter_edit_key_pressed        (GtkWidget        *widget,

                                                 GdkEventKey        *event,

                                                 gpointer         data);

static void prefs_filter_edit_ok                (void);

static void prefs_filter_edit_cancel                (void);

static void prefs_filter_cond_activated_cb        (GtkWidget        *widget,

                                                 gpointer         data);

static void prefs_filter_match_activated_cb        (GtkWidget        *widget,

                                                 gpointer         data);

static void prefs_filter_action_activated_cb        (GtkWidget        *widget,

                                                 gpointer         data);

static void prefs_filter_action_select_dest_cb        (GtkWidget        *widget,

                                                 gpointer         data);

static void prefs_filter_cond_del_cb                (GtkWidget        *widget,

                                                 gpointer         data);

static void prefs_filter_cond_add_cb                (GtkWidget        *widget,

                                                 gpointer         data);

static void prefs_filter_action_del_cb                (GtkWidget        *widget,

                                                 gpointer         data);

static void prefs_filter_action_add_cb                (GtkWidget        *widget,

                                                 gpointer         data);

FilterRule *prefs_filter_edit_open(FilterRule *rule, const gchar *header,

                                   const gchar *key)

{

        static gboolean lock = FALSE;

        FilterRule *new_rule;

        if (lock)

                return NULL;

        lock = TRUE;

        if (!rule_edit_window.window)

                prefs_filter_edit_create();

        manage_window_set_transient(GTK_WINDOW(rule_edit_window.window));

        prefs_filter_edit_set_header_list(&rule_edit_window.cond_edit, rule);

        prefs_filter_edit_rule_to_dialog(rule, key);

        if (header)

                prefs_filter_edit_activate_cond_header

                        (&rule_edit_window.cond_edit, header);

        GTK_EVENTS_FLUSH();

        gtk_widget_show(rule_edit_window.window);

        rule_edit_window.new_rule = NULL;

        rule_edit_window.edit_finished = FALSE;

        while (rule_edit_window.edit_finished == FALSE)

                gtk_main_iteration();

        gtk_widget_hide(rule_edit_window.window);

        prefs_filter_edit_clear();

        prefs_filter_set_msg_header_list(NULL);

        new_rule = rule_edit_window.new_rule;

        rule_edit_window.new_rule = NULL;

        if (new_rule)

                debug_print("new rule created: %s\n", new_rule->name);

        lock = FALSE;

        return new_rule;

}

static void prefs_filter_edit_create(void)

{

        GtkWidget *window;

        GtkWidget *vbox;

        GtkWidget *hbox;

        GtkWidget *label;

        GtkWidget *name_entry;

        GtkWidget *bool_op_optmenu;

        GtkWidget *menu;

        GtkWidget *menuitem;

        GtkWidget *cond_scrolled_win;

        GtkWidget *cond_vbox;

        GtkWidget *action_scrolled_win;

        GtkWidget *action_vbox;

        GtkWidget *ok_btn;

        GtkWidget *cancel_btn;

        GtkWidget *confirm_area;

        window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

        gtk_container_set_border_width(GTK_CONTAINER(window), 8);

        gtk_widget_set_size_request(window, 632, 405);

        gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);

        gtk_window_set_modal(GTK_WINDOW(window), TRUE);

        gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, FALSE);

        gtk_widget_realize(window);

        vbox = gtk_vbox_new(FALSE, 6);

        gtk_widget_show(vbox);

        gtk_container_add(GTK_CONTAINER(window), vbox);

        gtkut_stock_button_set_create(&confirm_area, &ok_btn, GTK_STOCK_OK,

                                      &cancel_btn, GTK_STOCK_CANCEL,

                                      NULL, NULL);

        gtk_widget_show(confirm_area);

        gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);

        gtk_widget_grab_default(ok_btn);

        gtk_window_set_title(GTK_WINDOW(window),

                             _("Filter rule"));

        g_signal_connect(G_OBJECT(window), "delete_event",

                         G_CALLBACK(prefs_filter_edit_deleted), NULL);

        g_signal_connect(G_OBJECT(window), "key_press_event",

                         G_CALLBACK(prefs_filter_edit_key_pressed), NULL);

        MANAGE_WINDOW_SIGNALS_CONNECT (window);

        g_signal_connect(G_OBJECT(ok_btn), "clicked",

                         G_CALLBACK(prefs_filter_edit_ok), NULL);

        g_signal_connect(G_OBJECT(cancel_btn), "clicked",

                         G_CALLBACK(prefs_filter_edit_cancel), NULL);

        hbox = gtk_hbox_new(FALSE, 4);

        gtk_widget_show(hbox);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        label = gtk_label_new(_("Name:"));

        gtk_widget_show(label);

        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

        name_entry = gtk_entry_new();

        gtk_widget_show(name_entry);

        gtk_box_pack_start(GTK_BOX(hbox), name_entry, TRUE, TRUE, 0);

        hbox = gtk_hbox_new(FALSE, 4);

        gtk_widget_show(hbox);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        bool_op_optmenu = gtk_option_menu_new();

        gtk_widget_show(bool_op_optmenu);

        gtk_box_pack_start(GTK_BOX(hbox), bool_op_optmenu, FALSE, FALSE, 0);

        menu = gtk_menu_new();

        gtk_widget_show(menu);

        MENUITEM_ADD(menu, menuitem,

                     _("If any of the following condition matches"), FLT_OR);

        MENUITEM_ADD(menu, menuitem,

                     _("If all of the following conditions match"), FLT_AND);

        gtk_option_menu_set_menu(GTK_OPTION_MENU(bool_op_optmenu), menu);

        gtk_option_menu_set_history(GTK_OPTION_MENU(bool_op_optmenu), FLT_AND);

        cond_scrolled_win = gtk_scrolled_window_new(NULL, NULL);

        gtk_widget_show(cond_scrolled_win);

        gtk_widget_set_size_request(cond_scrolled_win, -1, 125);

        gtk_box_pack_start(GTK_BOX(vbox), cond_scrolled_win, TRUE, TRUE, 0);

        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(cond_scrolled_win),

                                       GTK_POLICY_AUTOMATIC,

                                       GTK_POLICY_AUTOMATIC);

        cond_vbox = gtk_vbox_new(FALSE, 2);

        gtk_widget_show(cond_vbox);

        gtk_container_set_border_width(GTK_CONTAINER(cond_vbox), 2);

        gtk_scrolled_window_add_with_viewport

                (GTK_SCROLLED_WINDOW(cond_scrolled_win), cond_vbox);

        hbox = gtk_hbox_new(FALSE, 4);

        gtk_widget_show(hbox);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        label = gtk_label_new(_("Perform the following actions:"));

        gtk_widget_show(label);

        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

        action_scrolled_win = gtk_scrolled_window_new(NULL, NULL);

        gtk_widget_show(action_scrolled_win);

        gtk_box_pack_start(GTK_BOX(vbox), action_scrolled_win, TRUE, TRUE, 0);

        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(action_scrolled_win),

                                       GTK_POLICY_AUTOMATIC,

                                       GTK_POLICY_AUTOMATIC);

        action_vbox = gtk_vbox_new(FALSE, 2);

        gtk_widget_show(action_vbox);

        gtk_container_set_border_width(GTK_CONTAINER(action_vbox), 2);

        gtk_scrolled_window_add_with_viewport

                (GTK_SCROLLED_WINDOW(action_scrolled_win), action_vbox);

        rule_edit_window.window = window;

        rule_edit_window.name_entry = name_entry;

        rule_edit_window.bool_op_optmenu = bool_op_optmenu;

        rule_edit_window.cond_scrolled_win = cond_scrolled_win;

        rule_edit_window.cond_edit.cond_vbox = cond_vbox;

        rule_edit_window.action_scrolled_win = action_scrolled_win;

        rule_edit_window.action_vbox = action_vbox;

        rule_edit_window.ok_btn = ok_btn;

        rule_edit_window.cancel_btn = cancel_btn;

}

FilterCondEdit *prefs_filter_edit_cond_edit_create(void)

{

        FilterCondEdit *cond_edit;

        GtkWidget *cond_vbox;

        cond_edit = g_new(FilterCondEdit, 1);

        cond_vbox = gtk_vbox_new(FALSE, 2);

        gtk_widget_show(cond_vbox);

        gtk_container_set_border_width(GTK_CONTAINER(cond_vbox), 2);

        cond_edit->cond_vbox = cond_vbox;

        cond_edit->cond_hbox_list = NULL;

        cond_edit->hdr_list = NULL;

        cond_edit->rule_hdr_list = NULL;

        cond_edit->add_hbox = NULL;

        return cond_edit;

}

void prefs_filter_edit_clear_cond_edit(FilterCondEdit *cond_edit)

{

        while (cond_edit->cond_hbox_list) {

                CondHBox *hbox = (CondHBox *)cond_edit->cond_hbox_list->data;

                prefs_filter_edit_remove_cond_hbox(cond_edit, hbox);

        }

        procheader_header_list_destroy(cond_edit->hdr_list);

        cond_edit->hdr_list = NULL;

        procheader_header_list_destroy(cond_edit->rule_hdr_list);

        cond_edit->rule_hdr_list = NULL;

}

static void prefs_filter_edit_clear(void)

{

        prefs_filter_edit_clear_cond_edit(&rule_edit_window.cond_edit);

        while (rule_edit_window.action_hbox_list) {

                ActionHBox *hbox =

                        (ActionHBox *)rule_edit_window.action_hbox_list->data;

                prefs_filter_edit_remove_action_hbox(hbox);

        }

}

static void prefs_filter_edit_rule_to_dialog(FilterRule *rule,

                                             const gchar *default_name)

{

        gint index = 1;

        static gint count = 1;

        if (rule && rule->name)

                gtk_entry_set_text(GTK_ENTRY(rule_edit_window.name_entry),

                                   rule->name);

        else if (default_name)

                gtk_entry_set_text(GTK_ENTRY(rule_edit_window.name_entry),

                                   default_name);

        else {

                gchar rule_name[32];

                g_snprintf(rule_name, sizeof(rule_name), "Rule %d", count++);

                gtk_entry_set_text(GTK_ENTRY(rule_edit_window.name_entry),

                                   rule_name);

        }

        if (rule) {

                index = menu_find_option_menu_index

                        (GTK_OPTION_MENU(rule_edit_window.bool_op_optmenu),

                         GINT_TO_POINTER(rule->bool_op), NULL);

                if (index < 0)

                        index = 1;

        }

        if (index >= 0) {

                gtk_option_menu_set_history

                        (GTK_OPTION_MENU(rule_edit_window.bool_op_optmenu),

                         index);

        }

        gtkut_scrolled_window_reset_position

                (GTK_SCROLLED_WINDOW(rule_edit_window.cond_scrolled_win));

        gtkut_scrolled_window_reset_position

                (GTK_SCROLLED_WINDOW(rule_edit_window.action_scrolled_win));

        prefs_filter_edit_add_rule_cond(&rule_edit_window.cond_edit, rule);

        prefs_filter_edit_add_rule_action(rule);

}

void prefs_filter_edit_set_header_list(FilterCondEdit *cond_edit,

                                       FilterRule *rule)

{

        GSList *list;

        GSList *rule_hdr_list = NULL;

        GSList *cur;

        FilterCond *cond;

        procheader_header_list_destroy(cond_edit->hdr_list);

        cond_edit->hdr_list = NULL;

        procheader_header_list_destroy(cond_edit->rule_hdr_list);

        cond_edit->rule_hdr_list = NULL;

        list = prefs_filter_get_header_list();

        cond_edit->hdr_list = list;

        if (!rule)

                return;

        for (cur = rule->cond_list; cur != NULL; cur = cur->next) {

                cond = (FilterCond *)cur->data;

                if (cond->type == FLT_COND_HEADER &&

                    procheader_find_header_list

                        (rule_hdr_list, cond->header_name) < 0)

                        rule_hdr_list = procheader_add_header_list

                                (rule_hdr_list, cond->header_name, NULL);

        }

        cond_edit->rule_hdr_list = rule_hdr_list;

        cond_edit->hdr_list = procheader_merge_header_list_dup(list,

                                                               rule_hdr_list);

        procheader_header_list_destroy(list);

}

static void prefs_filter_edit_update_header_list(FilterCondEdit *cond_edit)

{

        GSList *list;

        procheader_header_list_destroy(cond_edit->hdr_list);

        cond_edit->hdr_list = NULL;

        list = prefs_filter_get_header_list();

        cond_edit->hdr_list = procheader_merge_header_list_dup

                (list, cond_edit->rule_hdr_list);

        procheader_header_list_destroy(list);

}

CondHBox *prefs_filter_edit_cond_hbox_create(FilterCondEdit *cond_edit)

{

        CondHBox *cond_hbox;

        GtkWidget *hbox;

        GtkWidget *cond_type_optmenu;

        GtkWidget *match_type_optmenu;

        GtkWidget *size_match_optmenu;

        GtkWidget *age_match_optmenu;

        GtkWidget *status_match_optmenu;

        GtkWidget *menu;

        GtkWidget *menuitem;

        GtkWidget *key_entry;

        GtkObject *spin_btn_adj;

        GtkWidget *spin_btn;

        GtkWidget *label;

        GtkWidget *del_btn;

        GtkWidget *add_btn;

        GtkWidget *del_img;

        GtkWidget *add_img;

        GtkWidget *match_menu_in_addr;

        GtkWidget *match_menu_not_in_addr;

        cond_hbox = g_new0(CondHBox, 1);

        hbox = gtk_hbox_new(FALSE, 4);

        gtk_widget_show(hbox);

        cond_type_optmenu = gtk_option_menu_new();

        gtk_widget_show(cond_type_optmenu);

        gtk_box_pack_start(GTK_BOX(hbox), cond_type_optmenu, FALSE, FALSE, 0);

#define COND_MENUITEM_ADD(str, action)                                            \

{                                                                            \

        MENUITEM_ADD(menu, menuitem, str, action);                            \

        g_signal_connect(G_OBJECT(menuitem), "activate",                    \

                         G_CALLBACK(prefs_filter_cond_activated_cb),            \

                         cond_hbox);                                            \

}

        menu = gtk_menu_new();

        gtk_widget_show(menu);

        MENUITEM_ADD(menu, menuitem, NULL,        PF_COND_SEPARATOR);

        COND_MENUITEM_ADD(_("To or Cc"),          PF_COND_TO_OR_CC);

        COND_MENUITEM_ADD(_("Any header"),        PF_COND_ANY_HEADER);

        COND_MENUITEM_ADD(_("Edit header..."),    PF_COND_EDIT_HEADER);

        MENUITEM_ADD(menu, menuitem, NULL,        PF_COND_SEPARATOR);

        COND_MENUITEM_ADD(_("Message body"),      PF_COND_BODY);

        COND_MENUITEM_ADD(_("Result of command"), PF_COND_CMD_TEST);

        COND_MENUITEM_ADD(_("Size"),              PF_COND_SIZE);

        COND_MENUITEM_ADD(_("Age"),               PF_COND_AGE);

        MENUITEM_ADD(menu, menuitem, NULL,        PF_COND_SEPARATOR);

        COND_MENUITEM_ADD(_("Unread"),            PF_COND_UNREAD);

        COND_MENUITEM_ADD(_("Marked"),            PF_COND_MARK);

        COND_MENUITEM_ADD(_("Has color label"),   PF_COND_COLOR_LABEL);

        COND_MENUITEM_ADD(_("Has attachment"),    PF_COND_MIME);

        /* COND_MENUITEM_ADD(_("Account"),           PF_COND_ACCOUNT); */

        gtk_option_menu_set_menu(GTK_OPTION_MENU(cond_type_optmenu), menu);

#undef COND_MENUITEM_ADD

        match_type_optmenu = gtk_option_menu_new();

        gtk_widget_show(match_type_optmenu);

        gtk_box_pack_start(GTK_BOX(hbox), match_type_optmenu, FALSE, FALSE, 0);

#define MATCH_MENUITEM_ADD(str, action)                                            \

{                                                                            \

        MENUITEM_ADD(menu, menuitem, str, action);                            \

        g_signal_connect(G_OBJECT(menuitem), "activate",                    \

                         G_CALLBACK(prefs_filter_match_activated_cb),            \

                         cond_hbox);                                            \

}

        menu = gtk_menu_new();

        gtk_widget_show(menu);

        MATCH_MENUITEM_ADD(_("contains"),               PF_MATCH_CONTAIN);

        MATCH_MENUITEM_ADD(_("doesn't contain"),        PF_MATCH_NOT_CONTAIN);

        MATCH_MENUITEM_ADD(_("is"),                     PF_MATCH_EQUAL);

        MATCH_MENUITEM_ADD(_("is not"),                 PF_MATCH_NOT_EQUAL);

#if defined(USE_ONIGURUMA) || defined(HAVE_REGCOMP)

        MATCH_MENUITEM_ADD(_("match to regex"),         PF_MATCH_REGEX);

        MATCH_MENUITEM_ADD(_("doesn't match to regex"), PF_MATCH_NOT_REGEX);

#endif

        MATCH_MENUITEM_ADD(_("is in addressbook"),      PF_MATCH_IN_ADDRESSBOOK);

        match_menu_in_addr = menuitem;

        MATCH_MENUITEM_ADD(_("is not in addressbook"),  PF_MATCH_NOT_IN_ADDRESSBOOK);

        match_menu_not_in_addr = menuitem;

        gtk_option_menu_set_menu(GTK_OPTION_MENU(match_type_optmenu), menu);

#undef MATCH_MENUITEM_ADD

        size_match_optmenu = gtk_option_menu_new();

        gtk_widget_show(size_match_optmenu);

        gtk_box_pack_start(GTK_BOX(hbox), size_match_optmenu, FALSE, FALSE, 0);

        menu = gtk_menu_new();

        gtk_widget_show(menu);

        MENUITEM_ADD(menu, menuitem, _("is larger than"), PF_SIZE_LARGER);

        MENUITEM_ADD(menu, menuitem, _("is smaller than"), PF_SIZE_SMALLER);

        gtk_option_menu_set_menu(GTK_OPTION_MENU(size_match_optmenu), menu);

        age_match_optmenu = gtk_option_menu_new();

        gtk_widget_show(age_match_optmenu);

        gtk_box_pack_start(GTK_BOX(hbox), age_match_optmenu, FALSE, FALSE, 0);

        menu = gtk_menu_new();

        gtk_widget_show(menu);

        MENUITEM_ADD(menu, menuitem, _("is longer than"), PF_AGE_LONGER);

        MENUITEM_ADD(menu, menuitem, _("is shorter than"), PF_AGE_SHORTER);

        gtk_option_menu_set_menu(GTK_OPTION_MENU(age_match_optmenu), menu);

        status_match_optmenu = gtk_option_menu_new();

        gtk_widget_show(status_match_optmenu);

        gtk_box_pack_start(GTK_BOX(hbox), status_match_optmenu,

                           FALSE, FALSE, 0);

        menu = gtk_menu_new();

        gtk_widget_show(menu);

        MENUITEM_ADD(menu, menuitem, _("matches to status"), PF_STATUS_MATCH);

        MENUITEM_ADD(menu, menuitem, _("doesn't match to status"),

                     PF_STATUS_NOT_MATCH);

        gtk_option_menu_set_menu(GTK_OPTION_MENU(status_match_optmenu), menu);

        key_entry = gtk_entry_new();

        gtk_widget_show(key_entry);

        gtk_box_pack_start(GTK_BOX(hbox), key_entry, TRUE, TRUE, 0);

        spin_btn_adj = gtk_adjustment_new(0, 0, 99999, 1, 10, 0);

        spin_btn = gtk_spin_button_new(GTK_ADJUSTMENT(spin_btn_adj), 1, 0);

        gtk_box_pack_start(GTK_BOX(hbox), spin_btn, FALSE, FALSE, 0);

        gtk_widget_set_size_request(spin_btn, 64, -1);

        gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin_btn), TRUE);

        label = gtk_label_new(_("KB"));

        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

        del_img = gtk_image_new_from_stock

                (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU);

        gtk_widget_show(del_img);

        del_btn = gtk_button_new();

        gtk_container_add(GTK_CONTAINER(del_btn), del_img);

        gtk_widget_show(del_btn);

        gtk_box_pack_end(GTK_BOX(hbox), del_btn, FALSE, FALSE, 0);

        add_img = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU);

        gtk_widget_show(add_img);

        add_btn = gtk_button_new();

        gtk_container_add(GTK_CONTAINER(add_btn), add_img);

        gtk_widget_show(add_btn);

        gtk_box_pack_end(GTK_BOX(hbox), add_btn, FALSE, FALSE, 0);

        g_signal_connect(G_OBJECT(del_btn), "clicked",

                         G_CALLBACK(prefs_filter_cond_del_cb), cond_hbox);

        g_signal_connect(G_OBJECT(add_btn), "clicked",

                         G_CALLBACK(prefs_filter_cond_add_cb), cond_hbox);

        cond_hbox->hbox = hbox;

        cond_hbox->cond_type_optmenu = cond_type_optmenu;

        cond_hbox->match_type_optmenu = match_type_optmenu;

        cond_hbox->size_match_optmenu = size_match_optmenu;

        cond_hbox->age_match_optmenu = age_match_optmenu;

        cond_hbox->status_match_optmenu = status_match_optmenu;

        cond_hbox->key_entry = key_entry;

        cond_hbox->spin_btn = spin_btn;

        cond_hbox->label = label;

        cond_hbox->match_menu_in_addr = match_menu_in_addr;

        cond_hbox->match_menu_not_in_addr = match_menu_not_in_addr;

        cond_hbox->del_btn = del_btn;

        cond_hbox->add_btn = add_btn;

        cond_hbox->cur_type = PF_COND_HEADER;

        cond_hbox->cur_header_name = NULL;

        cond_hbox->cond_edit = cond_edit;

        prefs_filter_edit_set_cond_header_menu(cond_edit, cond_hbox);

        gtk_option_menu_set_history(GTK_OPTION_MENU(cond_type_optmenu), 0);

        return cond_hbox;

}

ActionHBox *prefs_filter_edit_action_hbox_create(void)

{

        ActionHBox *action_hbox;

        GtkWidget *hbox;

        GtkWidget *action_type_optmenu;

        GtkWidget *menu;

        GtkWidget *menuitem;

        GtkWidget *label;

        GtkWidget *folder_entry;

        GtkWidget *cmd_entry;

        GtkWidget *address_entry;

        GtkWidget *folder_img;

        GtkWidget *folder_sel_btn;

        GtkWidget *clabel_optmenu;

        GtkWidget *del_btn;

        GtkWidget *add_btn;

        GtkWidget *del_img;

        GtkWidget *add_img;

        action_hbox = g_new0(ActionHBox, 1);

        hbox = gtk_hbox_new(FALSE, 4);

        gtk_widget_show(hbox);

        action_type_optmenu = gtk_option_menu_new();

        gtk_widget_show(action_type_optmenu);

        gtk_box_pack_start(GTK_BOX(hbox), action_type_optmenu, FALSE, FALSE, 0);

        memset(action_hbox->action_type_menu_items, 0,

               sizeof(action_hbox->action_type_menu_items));

#define ACTION_MENUITEM_ADD(str, action)                                      \

{                                                                              \

        MENUITEM_ADD(menu, menuitem, str, action);                              \

        action_hbox->action_type_menu_items[action] = menuitem;                      \

        g_signal_connect(G_OBJECT(menuitem), "activate",                      \

                         G_CALLBACK(prefs_filter_action_activated_cb),              \

                         action_hbox);                                              \

}

        menu = gtk_menu_new();

        gtk_widget_show(menu);

        ACTION_MENUITEM_ADD(_("Move to"),               PF_ACTION_MOVE);

        ACTION_MENUITEM_ADD(_("Copy to"),               PF_ACTION_COPY);

        ACTION_MENUITEM_ADD(_("Don't receive"),         PF_ACTION_NOT_RECEIVE);

        ACTION_MENUITEM_ADD(_("Delete from server"),    PF_ACTION_DELETE);

        MENUITEM_ADD(menu, menuitem, NULL,              PF_ACTION_SEPARATOR);

        ACTION_MENUITEM_ADD(_("Set mark"),              PF_ACTION_MARK);

        ACTION_MENUITEM_ADD(_("Set color"),             PF_ACTION_COLOR_LABEL);

        ACTION_MENUITEM_ADD(_("Mark as read"),          PF_ACTION_MARK_READ);

#if 0

        MENUITEM_ADD(menu, menuitem, NULL,              PF_ACTION_SEPARATOR);

        ACTION_MENUITEM_ADD(_("Forward"),               PF_ACTION_FORWARD);

        ACTION_MENUITEM_ADD(_("Forward as attachment"), PF_ACTION_FORWARD_AS_ATTACHMENT);

        ACTION_MENUITEM_ADD(_("Redirect"),              PF_ACTION_REDIRECT);

#endif

        MENUITEM_ADD(menu, menuitem, NULL,              PF_ACTION_SEPARATOR);

        ACTION_MENUITEM_ADD(_("Execute command"),       PF_ACTION_EXEC);

        MENUITEM_ADD(menu, menuitem, NULL,              PF_ACTION_SEPARATOR);

        ACTION_MENUITEM_ADD(_("Stop rule evaluation"),  PF_ACTION_STOP_EVAL);

        gtk_option_menu_set_menu(GTK_OPTION_MENU(action_type_optmenu), menu);

#undef ACTION_MENUITEM_ADD

        label = gtk_label_new(_("folder:"));

        gtk_widget_show(label);

        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

        folder_entry = gtk_entry_new();

        gtk_widget_show(folder_entry);

        gtk_box_pack_start(GTK_BOX(hbox), folder_entry, TRUE, TRUE, 0);

        folder_img = stock_pixbuf_widget(rule_edit_window.window,

                                         STOCK_PIXMAP_FOLDER_OPEN);

        gtk_widget_show(folder_img);

        folder_sel_btn = gtk_button_new();

        gtk_container_add(GTK_CONTAINER(folder_sel_btn), folder_img);

        gtk_widget_show(folder_sel_btn);

        gtk_box_pack_start(GTK_BOX(hbox), folder_sel_btn, FALSE, FALSE, 0);

        cmd_entry = gtk_entry_new();

        gtk_widget_show(cmd_entry);

        gtk_box_pack_start(GTK_BOX(hbox), cmd_entry, TRUE, TRUE, 0);

        address_entry = gtk_entry_new();

        gtk_widget_show(address_entry);

        gtk_box_pack_start(GTK_BOX(hbox), address_entry, TRUE, TRUE, 0);

        clabel_optmenu = gtk_option_menu_new();

        gtk_widget_show(clabel_optmenu);

        gtk_box_pack_start(GTK_BOX(hbox), clabel_optmenu, FALSE, FALSE, 0);

        menu = colorlabel_create_color_menu();

        gtk_option_menu_set_menu(GTK_OPTION_MENU(clabel_optmenu), menu);

        del_img = gtk_image_new_from_stock

                (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU);

        gtk_widget_show(del_img);

        del_btn = gtk_button_new();

        gtk_container_add(GTK_CONTAINER(del_btn), del_img);

        gtk_widget_show(del_btn);

        gtk_box_pack_end(GTK_BOX(hbox), del_btn, FALSE, FALSE, 0);

        add_img = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU);

        gtk_widget_show(add_img);

        add_btn = gtk_button_new();

        gtk_container_add(GTK_CONTAINER(add_btn), add_img);

        gtk_widget_show(add_btn);

        gtk_box_pack_end(GTK_BOX(hbox), add_btn, FALSE, FALSE, 0);

        g_signal_connect(G_OBJECT(folder_sel_btn), "clicked",

                         G_CALLBACK(prefs_filter_action_select_dest_cb),

                         action_hbox);

        g_signal_connect(G_OBJECT(del_btn), "clicked",

                         G_CALLBACK(prefs_filter_action_del_cb), action_hbox);

        g_signal_connect(G_OBJECT(add_btn), "clicked",

                         G_CALLBACK(prefs_filter_action_add_cb), action_hbox);

        action_hbox->hbox = hbox;

        action_hbox->action_type_optmenu = action_type_optmenu;

        action_hbox->label = label;

        action_hbox->folder_entry = folder_entry;

        action_hbox->cmd_entry = cmd_entry;

        action_hbox->address_entry = address_entry;

        action_hbox->folder_sel_btn = folder_sel_btn;

        action_hbox->clabel_optmenu = clabel_optmenu;

        action_hbox->del_btn = del_btn;

        action_hbox->add_btn = add_btn;

        return action_hbox;

}

void prefs_filter_edit_cond_hbox_set(CondHBox *hbox, FilterCond *cond)

{

        GtkOptionMenu *cond_type_optmenu =

                GTK_OPTION_MENU(hbox->cond_type_optmenu);

        GtkOptionMenu *match_type_optmenu =

                GTK_OPTION_MENU(hbox->match_type_optmenu);

        gint cond_index = -1;

        gint match_index = -1;

        CondMenuType cond_type = PF_COND_NONE;

        MatchMenuType match_type = PF_MATCH_NONE;

        SizeMatchType size_type = PF_SIZE_LARGER;

        AgeMatchType age_type = PF_AGE_LONGER;

        StatusMatchType status_type = PF_STATUS_MATCH;

        switch (cond->type) {

        case FLT_COND_HEADER:

                cond_type = PF_COND_HEADER; break;

        case FLT_COND_TO_OR_CC:

                cond_type = PF_COND_TO_OR_CC; break;

        case FLT_COND_ANY_HEADER:

                cond_type = PF_COND_ANY_HEADER; break;

        case FLT_COND_BODY:

                cond_type = PF_COND_BODY; break;

        case FLT_COND_CMD_TEST:

                cond_type = PF_COND_CMD_TEST; break;

        case FLT_COND_SIZE_GREATER:

                cond_type = PF_COND_SIZE;

                if (FLT_IS_NOT_MATCH(cond->match_flag))

                        size_type = PF_SIZE_SMALLER;

                else

                        size_type = PF_SIZE_LARGER;

                break;

        case FLT_COND_AGE_GREATER:

                cond_type = PF_COND_AGE;

                if (FLT_IS_NOT_MATCH(cond->match_flag))

                        age_type = PF_AGE_SHORTER;

                else

                        age_type = PF_AGE_LONGER;

                break;

        case FLT_COND_UNREAD:

                cond_type = PF_COND_UNREAD; break;

        case FLT_COND_MARK:

                cond_type = PF_COND_MARK; break;

        case FLT_COND_COLOR_LABEL:

                cond_type = PF_COND_COLOR_LABEL; break;

        case FLT_COND_MIME:

                cond_type = PF_COND_MIME; break;

        case FLT_COND_ACCOUNT:

                cond_type = PF_COND_ACCOUNT; break;

        default:

                break;

        }

        switch (cond->type) {

        case FLT_COND_HEADER:

        case FLT_COND_TO_OR_CC:

        case FLT_COND_ANY_HEADER:

        case FLT_COND_BODY:

                switch (cond->match_type) {

                case FLT_CONTAIN:

                        if (FLT_IS_NOT_MATCH(cond->match_flag))

                                match_type = PF_MATCH_NOT_CONTAIN;

                        else

                                match_type = PF_MATCH_CONTAIN;

                        break;

                case FLT_EQUAL:

                        if (FLT_IS_NOT_MATCH(cond->match_flag))

                                match_type = PF_MATCH_NOT_EQUAL;

                        else

                                match_type = PF_MATCH_EQUAL;

                        break;

                case FLT_REGEX:

                        if (FLT_IS_NOT_MATCH(cond->match_flag))

                                match_type = PF_MATCH_NOT_REGEX;

                        else

                                match_type = PF_MATCH_REGEX;

                        break;

                case FLT_IN_ADDRESSBOOK:

                        if (FLT_IS_NOT_MATCH(cond->match_flag))

                                match_type = PF_MATCH_NOT_IN_ADDRESSBOOK;

                        else

                                match_type = PF_MATCH_IN_ADDRESSBOOK;

                        break;

                }

                break;

        case FLT_COND_UNREAD:

        case FLT_COND_MARK:

        case FLT_COND_COLOR_LABEL:

        case FLT_COND_MIME:

                if (FLT_IS_NOT_MATCH(cond->match_flag))

                        status_type = PF_STATUS_NOT_MATCH;

                else

                        status_type = PF_STATUS_MATCH;

                break;

        default:

                break;

        }

        if (cond_type == PF_COND_HEADER)

                cond_index = procheader_find_header_list

                        (hbox->cond_edit->hdr_list, cond->header_name);

        else

                cond_index = menu_find_option_menu_index

                        (cond_type_optmenu, GINT_TO_POINTER(cond_type), NULL);

        if (cond_index >= 0) {

                GtkWidget *menuitem;

                if (cond_type == PF_COND_SIZE || cond_type == PF_COND_AGE) {

                        gtk_spin_button_set_value

                                (GTK_SPIN_BUTTON(hbox->spin_btn),

                                 (gfloat)cond->int_value);

                } else {

                        gtk_entry_set_text(GTK_ENTRY(hbox->key_entry),

                                           cond->str_value ?

                                           cond->str_value : "");

                }

                gtk_option_menu_set_history(cond_type_optmenu, cond_index);

                menuitem = gtk_menu_get_active

                        (GTK_MENU(gtk_option_menu_get_menu(cond_type_optmenu)));

                gtk_menu_item_activate(GTK_MENU_ITEM(menuitem));

        }

        match_index = menu_find_option_menu_index

                (match_type_optmenu, GINT_TO_POINTER(match_type), NULL);

        if (match_index >= 0)

                gtk_option_menu_set_history(match_type_optmenu, match_index);

        if (cond_type == PF_COND_SIZE)

                gtk_option_menu_set_history

                        (GTK_OPTION_MENU(hbox->size_match_optmenu), size_type);

        else if (cond_type == PF_COND_AGE)

                gtk_option_menu_set_history

                        (GTK_OPTION_MENU(hbox->age_match_optmenu), age_type);

        else if (cond_type == PF_COND_UNREAD || cond_type == PF_COND_MARK ||

                 cond_type == PF_COND_COLOR_LABEL || cond_type == PF_COND_MIME)

                gtk_option_menu_set_history

                        (GTK_OPTION_MENU(hbox->status_match_optmenu),

                         status_type);