Initial import of Sylpheed (GTK2 version).

git-svn-id: svn://sylpheed.sraoss.jp/sylpheed/trunk@1 ee746299-78ed-0310-b773-934348b2243d

1 files changed, 2035 insertions, 0 deletions

diff --git a/src/prefs_filter_edit.c b/src/prefs_filter_edit.c
new file mode 100644
index 00000000..d1dc7d90
--- /dev/null
+++ b/src/prefs_filter_edit.c
@@ -0,0 +1,2035 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2004 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 <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "intl.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"
+
+typedef enum
+{
+	PF_COND_HEADER,
+	PF_COND_TO_OR_CC,
+	PF_COND_ANY_HEADER,
+	PF_COND_BODY,
+	PF_COND_CMD_TEST,
+	PF_COND_SIZE,
+	PF_COND_AGE,
+	PF_COND_ACCOUNT,
+	PF_COND_EDIT_HEADER,
+	PF_COND_SEPARATOR,
+	PF_COND_NONE
+} CondMenuType;
+
+typedef enum
+{
+	PF_MATCH_CONTAIN,
+	PF_MATCH_NOT_CONTAIN,
+	PF_MATCH_EQUAL,
+	PF_MATCH_NOT_EQUAL,
+	PF_MATCH_REGEX,
+	PF_MATCH_NOT_REGEX,
+	PF_MATCH_NONE
+} MatchMenuType;
+
+typedef enum
+{
+	PF_SIZE_LARGER,
+	PF_SIZE_SMALLER
+} SizeMatchType;
+
+typedef enum
+{
+	PF_AGE_LONGER,
+	PF_AGE_SHORTER
+} AgeMatchType;
+
+typedef enum
+{
+	PF_ACTION_MOVE,
+	PF_ACTION_COPY,
+	PF_ACTION_NOT_RECEIVE,
+	PF_ACTION_DELETE,
+	PF_ACTION_EXEC,
+	PF_ACTION_EXEC_ASYNC,
+	PF_ACTION_MARK,
+	PF_ACTION_COLOR_LABEL,
+	PF_ACTION_MARK_READ,
+	PF_ACTION_FORWARD,
+	PF_ACTION_FORWARD_AS_ATTACHMENT,
+	PF_ACTION_REDIRECT,
+	PF_ACTION_STOP_EVAL,
+	PF_ACTION_SEPARATOR,
+	PF_ACTION_NONE
+} ActionMenuType;
+
+static struct FilterRuleEditWindow {
+	GtkWidget *window;
+
+	GtkWidget *name_entry;
+	GtkWidget *bool_op_optmenu;
+
+	GtkWidget *cond_scrolled_win;
+	GtkWidget *cond_vbox;
+	GSList *cond_hbox_list;
+
+	GtkWidget *action_scrolled_win;
+	GtkWidget *action_vbox;
+	GSList *action_hbox_list;
+
+	GtkWidget *ok_btn;
+	GtkWidget *cancel_btn;
+
+	GSList *hdr_list;
+	GSList *rule_hdr_list;
+
+	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;
+
+typedef struct _CondHBox {
+	GtkWidget *hbox;
+
+	GtkWidget *cond_type_optmenu;
+	GtkWidget *match_type_optmenu;
+	GtkWidget *size_match_optmenu;
+	GtkWidget *age_match_optmenu;
+	GtkWidget *key_entry;
+	GtkWidget *spin_btn;
+	GtkWidget *label;
+
+	GtkWidget *del_btn;
+	GtkWidget *add_btn;
+
+	CondMenuType cur_type;
+	gchar *cur_header_name;
+} CondHBox;
+
+typedef struct _ActionHBox {
+	GtkWidget *hbox;
+
+	GtkWidget *action_type_optmenu;
+	GtkWidget *label;
+	GtkWidget *folder_entry;
+	GtkWidget *cmd_entry;
+	GtkWidget *address_entry;
+	GtkWidget *clabel_optmenu;
+
+	GtkWidget *folder_sel_btn;
+
+	GtkWidget *action_type_menu_items[PF_ACTION_NONE];
+
+	GtkWidget *del_btn;
+	GtkWidget *add_btn;
+} ActionHBox;
+
+static void prefs_filter_edit_create		(void);
+static void prefs_filter_edit_clear		(void);
+static void prefs_filter_edit_rule_to_dialog	(FilterRule	*rule);
+static void prefs_filter_edit_set_header_list	(FilterRule	*rule);
+static void prefs_filter_edit_update_header_list(void);
+
+static CondHBox *prefs_filter_edit_cond_hbox_create	(void);
+static ActionHBox *prefs_filter_edit_action_hbox_create	(void);
+static void prefs_filter_edit_cond_hbox_set		(CondHBox	*hbox,
+							 FilterCond	*cond);
+static void prefs_filter_edit_action_hbox_set		(ActionHBox	*hbox,
+							 FilterAction	*action);
+
+static void prefs_filter_edit_cond_hbox_select	(CondHBox	*hbox,
+						 CondMenuType	 type,
+						 const gchar	*header_name);
+
+static void prefs_filter_edit_set_cond_hbox_widgets	(CondHBox	*hbox,
+							 CondMenuType	 type);
+static void prefs_filter_edit_set_action_hbox_widgets	(ActionHBox	*hbox,
+							 ActionMenuType	 type);
+
+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_cond_hbox	(CondHBox	*hbox,
+						 gint		 pos);
+static void prefs_filter_edit_insert_action_hbox(ActionHBox	*hbox,
+						 gint		 pos);
+static void prefs_filter_edit_remove_cond_hbox	(CondHBox	*hbox);
+static void prefs_filter_edit_remove_action_hbox(ActionHBox	*hbox);
+
+static void prefs_filter_edit_add_rule_cond	(FilterRule	*rule);
+static void prefs_filter_edit_add_rule_action	(FilterRule	*rule);
+
+static void prefs_filter_edit_set_cond_header_menu
+						(CondHBox	*hbox);
+
+static void prefs_filter_edit_activate_cond_header
+						(const gchar	*header);
+
+static void prefs_filter_edit_edit_header_list		(void);
+
+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_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)
+{
+	FilterRule *new_rule;
+
+	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);
+	prefs_filter_edit_rule_to_dialog(rule);
+	if (header)
+		prefs_filter_edit_activate_cond_header(header);
+	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();
+
+	prefs_filter_edit_clear();
+	prefs_filter_set_msg_header_list(NULL);
+	gtk_widget_hide(rule_edit_window.window);
+
+	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);
+
+	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_button_set_create(&confirm_area, &ok_btn, _("OK"),
+				&cancel_btn, _("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();
+	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);
+
+	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_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;
+}
+
+static void prefs_filter_edit_clear(void)
+{
+	while (rule_edit_window.cond_hbox_list) {
+		CondHBox *hbox =
+			(CondHBox *)rule_edit_window.cond_hbox_list->data;
+		prefs_filter_edit_remove_cond_hbox(hbox);
+	}
+	while (rule_edit_window.action_hbox_list) {
+		ActionHBox *hbox =
+			(ActionHBox *)rule_edit_window.action_hbox_list->data;
+		prefs_filter_edit_remove_action_hbox(hbox);
+	}
+
+	g_slist_free(rule_edit_window.hdr_list);
+	rule_edit_window.hdr_list = NULL;
+	procheader_header_list_destroy(rule_edit_window.rule_hdr_list);
+	rule_edit_window.rule_hdr_list = NULL;
+}
+
+static void prefs_filter_edit_rule_to_dialog(FilterRule *rule)
+{
+	gint index = 0;
+	static gint count = 1;
+
+	if (rule && rule->name)
+		gtk_entry_set_text(GTK_ENTRY(rule_edit_window.name_entry),
+				   rule->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 = 0;
+	}
+	if (index >= 0) {
+		gtk_option_menu_set_history
+			(GTK_OPTION_MENU(rule_edit_window.bool_op_optmenu),
+			 index);
+	}
+
+	prefs_filter_edit_add_rule_cond(rule);
+	prefs_filter_edit_add_rule_action(rule);
+}
+
+static void prefs_filter_edit_set_header_list(FilterRule *rule)
+{
+	GSList *list;
+	GSList *rule_hdr_list = NULL;
+	GSList *cur;
+	FilterCond *cond;
+
+	g_slist_free(rule_edit_window.hdr_list);
+	rule_edit_window.hdr_list = NULL;
+	procheader_header_list_destroy(rule_edit_window.rule_hdr_list);
+	rule_edit_window.rule_hdr_list = NULL;
+
+	list = prefs_filter_get_header_list();
+	rule_edit_window.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);
+	}
+
+	rule_edit_window.rule_hdr_list = rule_hdr_list;
+
+	rule_edit_window.hdr_list =
+		procheader_merge_header_list(list, rule_hdr_list);
+}
+
+static void prefs_filter_edit_update_header_list(void)
+{
+	GSList *list;
+
+	g_slist_free(rule_edit_window.hdr_list);
+	rule_edit_window.hdr_list = NULL;
+
+	list = prefs_filter_get_header_list();
+	rule_edit_window.hdr_list = list;
+
+	rule_edit_window.hdr_list =
+		procheader_merge_header_list(list,
+					     rule_edit_window.rule_hdr_list);
+}
+
+static CondHBox *prefs_filter_edit_cond_hbox_create(void)
+{
+	CondHBox *cond_hbox;
+	GtkWidget *hbox;
+	GtkWidget *cond_type_optmenu;
+	GtkWidget *match_type_optmenu;
+	GtkWidget *size_match_optmenu;
+	GtkWidget *age_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_pixmap;
+	GtkWidget *add_pixmap;
+
+	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();
+	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);
+	/* 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);
+
+	menu = gtk_menu_new();
+	MENUITEM_ADD(menu, menuitem, _("contains"),
+		     PF_MATCH_CONTAIN);
+	MENUITEM_ADD(menu, menuitem, _("doesn't contain"),
+		     PF_MATCH_NOT_CONTAIN);
+	MENUITEM_ADD(menu, menuitem, _("is"),
+		     PF_MATCH_EQUAL);
+	MENUITEM_ADD(menu, menuitem, _("is not"),
+		     PF_MATCH_NOT_EQUAL);
+	MENUITEM_ADD(menu, menuitem, _("match to regex"),
+		     PF_MATCH_REGEX);
+	MENUITEM_ADD(menu, menuitem, _("doesn't match to regex"),
+		     PF_MATCH_NOT_REGEX);
+	gtk_option_menu_set_menu(GTK_OPTION_MENU(match_type_optmenu), menu);
+
+	size_match_optmenu = gtk_option_menu_new();
+	gtk_box_pack_start(GTK_BOX(hbox), size_match_optmenu, FALSE, FALSE, 0);
+
+	menu = gtk_menu_new();
+	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_box_pack_start(GTK_BOX(hbox), age_match_optmenu, FALSE, FALSE, 0);
+
+	menu = gtk_menu_new();
+	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);
+
+	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, 100);
+	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_pixmap = stock_pixmap_widget(rule_edit_window.window,
+					 STOCK_PIXMAP_REMOVE);
+	gtk_widget_show(del_pixmap);
+
+	del_btn = gtk_button_new();
+	gtk_container_add(GTK_CONTAINER(del_btn), del_pixmap);
+	gtk_widget_show(del_btn);
+	gtk_box_pack_end(GTK_BOX(hbox), del_btn, FALSE, FALSE, 0);
+
+	add_pixmap = stock_pixmap_widget(rule_edit_window.window,
+					 STOCK_PIXMAP_ADD);
+	gtk_widget_show(add_pixmap);
+
+	add_btn = gtk_button_new();
+	gtk_container_add(GTK_CONTAINER(add_btn), add_pixmap);
+	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->key_entry = key_entry;
+	cond_hbox->spin_btn = spin_btn;
+	cond_hbox->label = label;
+	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;
+
+	prefs_filter_edit_set_cond_header_menu(cond_hbox);
+	gtk_option_menu_set_history(GTK_OPTION_MENU(cond_type_optmenu), 0);
+
+	return cond_hbox;
+}
+
+static 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_pixmap;
+	GtkWidget *folder_sel_btn;
+	GtkWidget *clabel_optmenu;
+	GtkWidget *del_btn;
+	GtkWidget *add_btn;
+	GtkWidget *del_pixmap;
+	GtkWidget *add_pixmap;
+
+	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();
+	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_pixmap = stock_pixmap_widget(rule_edit_window.window,
+					    STOCK_PIXMAP_DIR_OPEN);
+	gtk_widget_show(folder_pixmap);
+
+	folder_sel_btn = gtk_button_new();
+	gtk_container_add(GTK_CONTAINER(folder_sel_btn), folder_pixmap);
+	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_pixmap = stock_pixmap_widget(rule_edit_window.window,
+					 STOCK_PIXMAP_REMOVE);
+	gtk_widget_show(del_pixmap);
+
+	del_btn = gtk_button_new();
+	gtk_container_add(GTK_CONTAINER(del_btn), del_pixmap);
+	gtk_widget_show(del_btn);
+	gtk_box_pack_end(GTK_BOX(hbox), del_btn, FALSE, FALSE, 0);
+
+	add_pixmap = stock_pixmap_widget(rule_edit_window.window,
+					 STOCK_PIXMAP_ADD);
+	gtk_widget_show(add_pixmap);
+
+	add_btn = gtk_button_new();
+	gtk_container_add(GTK_CONTAINER(add_btn), add_pixmap);
+	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;
+}
+
+static 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;
+
+	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_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;
+		}
+		break;
+	default:
+		break;
+	}
+
+	if (cond_type == PF_COND_HEADER)
+		cond_index = procheader_find_header_list
+			(rule_edit_window.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);
+}
+
+static void prefs_filter_edit_action_hbox_set(ActionHBox *hbox,
+					      FilterAction *action)
+{
+	GtkOptionMenu *type_optmenu = GTK_OPTION_MENU(hbox->action_type_optmenu);
+	GtkWidget *menu;
+	ActionMenuType type = PF_ACTION_NONE;
+
+	menu = gtk_option_menu_get_menu(type_optmenu);
+
+	switch (action->type) {
+	case FLT_ACTION_MOVE:
+		type = PF_ACTION_MOVE; break;
+	case FLT_ACTION_COPY:
+		type = PF_ACTION_COPY; break;
+	case FLT_ACTION_NOT_RECEIVE:
+		type = PF_ACTION_NOT_RECEIVE; break;
+	case FLT_ACTION_DELETE:
+		type = PF_ACTION_DELETE; break;
+	case FLT_ACTION_EXEC:
+		type = PF_ACTION_EXEC; break;
+	case FLT_ACTION_MARK:
+		type = PF_ACTION_MARK; break;
+	case FLT_ACTION_COLOR_LABEL:
+		type = PF_ACTION_COLOR_LABEL; break;
+	case FLT_ACTION_MARK_READ:
+		type = PF_ACTION_MARK_READ; break;
+	case FLT_ACTION_STOP_EVAL:
+		type = PF_ACTION_STOP_EVAL; break;
+	default:
+		break;
+	}
+
+	switch (type) {
+	case PF_ACTION_MOVE:
+	case PF_ACTION_COPY:
+		gtk_entry_set_text(GTK_ENTRY(hbox->folder_entry),
+				   action->str_value ? action->str_value : "");
+		break;
+	case PF_ACTION_EXEC:
+		gtk_entry_set_text(GTK_ENTRY(hbox->cmd_entry),
+				   action->str_value ? action->str_value : "");
+		break;
+	case PF_ACTION_COLOR_LABEL:
+		gtk_option_menu_set_history
+			(GTK_OPTION_MENU(hbox->clabel_optmenu),
+			 action->int_value - 1);
+		break;
+	default:
+		break;
+	}
+
+	prefs_filter_edit_set_action_hbox_widgets(hbox, type);
+}
+
+static void prefs_filter_edit_cond_hbox_select(CondHBox *hbox,
+					       CondMenuType type,
+					       const gchar *header_name)
+{
+	gint index;
+	GtkOptionMenu *cond_type_optmenu =
+		GTK_OPTION_MENU(hbox->cond_type_optmenu);
+	GtkWidget *menu;
+
+	if (type == PF_COND_HEADER) {
+		if (header_name)
+			index = procheader_find_header_list
+				(rule_edit_window.hdr_list, header_name);
+		else
+			index = 0;
+	} else
+		index = menu_find_option_menu_index
+			(cond_type_optmenu, GINT_TO_POINTER(type), NULL);
+
+	if (index < 0)
+		index = 0;
+
+	menu = gtk_option_menu_get_menu(cond_type_optmenu);
+	gtk_option_menu_set_history(cond_type_optmenu, index);
+}
+
+static void prefs_filter_edit_set_cond_hbox_widgets(CondHBox *hbox,
+						    CondMenuType type)
+{
+	switch (type) {
+	case PF_COND_HEADER:
+	case PF_COND_TO_OR_CC:
+	case PF_COND_ANY_HEADER:
+	case PF_COND_BODY:
+		gtk_widget_show(hbox->match_type_optmenu);
+		gtk_widget_hide(hbox->size_match_optmenu);
+		gtk_widget_hide(hbox->age_match_optmenu);
+		gtk_widget_show(hbox->key_entry);
+		gtk_widget_hide(hbox->spin_btn);
+		gtk_widget_hide(hbox->label);
+		break;
+	case PF_COND_CMD_TEST:
+		gtk_widget_hide(hbox->match_type_optmenu);
+		gtk_widget_hide(hbox->size_match_optmenu);
+		gtk_widget_hide(hbox->age_match_optmenu);
+		gtk_widget_show(hbox->key_entry);
+		gtk_widget_hide(hbox->spin_btn);
+		gtk_widget_hide(hbox->label);
+		break;
+	case PF_COND_SIZE:
+		gtk_widget_hide(hbox->match_type_optmenu);
+		gtk_widget_show(hbox->size_match_optmenu);
+		gtk_widget_hide(hbox->age_match_optmenu);
+		gtk_widget_hide(hbox->key_entry);
+		gtk_widget_show(hbox->spin_btn);
+		gtk_widget_show(hbox->label);
+		break;
+	case PF_COND_AGE:
+		gtk_widget_hide(hbox->match_type_optmenu);
+		gtk_widget_hide(hbox->size_match_optmenu);
+		gtk_widget_show(hbox->age_match_optmenu);
+		gtk_widget_hide(hbox->key_entry);
+		gtk_widget_show(hbox->spin_btn);
+		gtk_widget_hide(hbox->label);
+		break;
+	case PF_COND_ACCOUNT:
+		gtk_widget_hide(hbox->match_type_optmenu);
+		gtk_widget_hide(hbox->size_match_optmenu);
+		gtk_widget_hide(hbox->age_match_optmenu);
+		gtk_widget_hide(hbox->key_entry);
+		/* gtk_widget_show(hbox->account_optmenu); */
+		gtk_widget_hide(hbox->spin_btn);
+		gtk_widget_hide(hbox->label);
+		break;
+	default:
+		break;
+	}
+}
+
+static void prefs_filter_edit_set_action_hbox_widgets(ActionHBox *hbox,
+						      ActionMenuType type)
+{
+	GtkOptionMenu *type_optmenu = GTK_OPTION_MENU(hbox->action_type_optmenu);
+	gint index;
+
+	switch (type) {
+	case PF_ACTION_MOVE:
+	case PF_ACTION_COPY:
+		gtk_widget_show(hbox->label);
+		gtk_label_set_text(GTK_LABEL(hbox->label), _("folder:"));
+		gtk_widget_show(hbox->folder_entry);
+		gtk_widget_show(hbox->folder_sel_btn);
+		gtk_widget_hide(hbox->cmd_entry);
+		gtk_widget_hide(hbox->address_entry);
+		gtk_widget_hide(hbox->clabel_optmenu);
+		break;
+	case PF_ACTION_NOT_RECEIVE:
+	case PF_ACTION_DELETE:
+	case PF_ACTION_MARK:
+	case PF_ACTION_MARK_READ:
+	case PF_ACTION_STOP_EVAL:
+		gtk_widget_hide(hbox->label);
+		gtk_widget_hide(hbox->folder_entry);
+		gtk_widget_hide(hbox->folder_sel_btn);
+		gtk_widget_hide(hbox->cmd_entry);
+		gtk_widget_hide(hbox->address_entry);
+		gtk_widget_hide(hbox->clabel_optmenu);
+		break;
+	case PF_ACTION_EXEC:
+	case PF_ACTION_EXEC_ASYNC:
+		gtk_widget_hide(hbox->label);
+		gtk_widget_hide(hbox->folder_entry);
+		gtk_widget_hide(hbox->folder_sel_btn);
+		gtk_widget_show(hbox->cmd_entry);
+		gtk_widget_hide(hbox->address_entry);
+		gtk_widget_hide(hbox->clabel_optmenu);
+		break;
+	case PF_ACTION_COLOR_LABEL:
+		gtk_widget_hide(hbox->label);
+		gtk_widget_hide(hbox->folder_entry);
+		gtk_widget_hide(hbox->folder_sel_btn);
+		gtk_widget_hide(hbox->cmd_entry);
+		gtk_widget_hide(hbox->address_entry);
+		gtk_widget_show(hbox->clabel_optmenu);
+		break;
+	case PF_ACTION_FORWARD:
+	case PF_ACTION_FORWARD_AS_ATTACHMENT:
+	case PF_ACTION_REDIRECT:
+		gtk_widget_show(hbox->label);
+		gtk_label_set_text(GTK_LABEL(hbox->label), _("address:"));
+		gtk_widget_hide(hbox->folder_entry);
+		gtk_widget_hide(hbox->folder_sel_btn);
+		gtk_widget_hide(hbox->cmd_entry);
+		gtk_widget_show(hbox->address_entry);
+		gtk_widget_hide(hbox->clabel_optmenu);
+		break;
+	default:
+		break;
+	}
+
+	index = menu_find_option_menu_index(type_optmenu, GINT_TO_POINTER(type),
+					    NULL);
+	gtk_option_menu_set_history(type_optmenu, index);
+	prefs_filter_edit_set_action_hbox_menus_sensitive();
+}
+
+static void prefs_filter_edit_set_action_hbox_menu_sensitive
+	(ActionHBox *hbox, ActionMenuType type, gboolean sensitive)
+{
+	GtkWidget *menuitem;
+
+	menuitem = hbox->action_type_menu_items[type];
+	if (menuitem)
+		gtk_widget_set_sensitive(menuitem, sensitive);
+}
+
+static void prefs_filter_edit_set_action_hbox_menus_sensitive(void)
+{
+	GSList *cur;
+	ActionHBox *cur_hbox;
+	ActionMenuType menu_type;
+	ActionMenuType cur_type;
+	gboolean action_menu_selection[PF_ACTION_NONE];
+	gboolean action_menu_sensitive[PF_ACTION_NONE];
+
+	prefs_filter_edit_get_action_hbox_menus_selection
+		(action_menu_selection);
+
+	for (cur = rule_edit_window.action_hbox_list; cur != NULL;
+	     cur = cur->next) {
+		cur_hbox = (ActionHBox *)cur->data;
+		menu_type = prefs_filter_edit_get_action_hbox_type(cur_hbox);
+		for (cur_type = PF_ACTION_MOVE; cur_type < PF_ACTION_NONE;
+		     cur_type++)
+			action_menu_sensitive[cur_type] = TRUE;
+
+		for (cur_type = PF_ACTION_MOVE; cur_type < PF_ACTION_NONE;
+		     cur_type++) {
+			switch (cur_type) {
+			case PF_ACTION_MOVE:
+			case PF_ACTION_NOT_RECEIVE:
+			case PF_ACTION_DELETE:
+				if (action_menu_selection[cur_type] == TRUE &&
+				    menu_type != cur_type) {
+					action_menu_sensitive[PF_ACTION_MOVE] = FALSE;
+					action_menu_sensitive[PF_ACTION_NOT_RECEIVE] = FALSE;
+					action_menu_sensitive[PF_ACTION_DELETE] = FALSE;
+				}
+				break;
+			case PF_ACTION_MARK:
+			case PF_ACTION_COLOR_LABEL:
+			case PF_ACTION_MARK_READ:
+			case PF_ACTION_STOP_EVAL:
+				if (action_menu_selection[cur_type] == TRUE &&
+				    menu_type != cur_type)
+					action_menu_sensitive[cur_type] = FALSE;
+				break;
+			default:
+				break;
+			}
+		}
+
+		for (cur_type = PF_ACTION_MOVE; cur_type < PF_ACTION_NONE;
+		     cur_type++) {
+			prefs_filter_edit_set_action_hbox_menu_sensitive
+				(cur_hbox, cur_type,
+				 action_menu_sensitive[cur_type]);
+		}
+	}
+}
+
+static void prefs_filter_edit_get_action_hbox_menus_selection(gboolean *selection)
+{
+	GSList *cur;
+	ActionHBox *cur_hbox;
+	ActionMenuType menu_type;
+	ActionMenuType cur_type;
+
+	for (cur_type = PF_ACTION_MOVE; cur_type < PF_ACTION_NONE; cur_type++)
+		selection[cur_type] = FALSE;
+
+	for (cur = rule_edit_window.action_hbox_list; cur != NULL;
+	     cur = cur->next) {
+		cur_hbox = (ActionHBox *)cur->data;
+		menu_type = prefs_filter_edit_get_action_hbox_type(cur_hbox);
+		if (menu_type >= PF_ACTION_MOVE && menu_type < PF_ACTION_NONE)
+			selection[menu_type] = TRUE;
+	}
+}
+
+static ActionMenuType prefs_filter_edit_get_action_hbox_type(ActionHBox *hbox)
+{
+	GtkWidget *menuitem;
+	ActionMenuType type;
+
+	g_return_val_if_fail(hbox != NULL, PF_ACTION_NONE);
+
+	menuitem = gtk_menu_get_active
+		(GTK_MENU(gtk_option_menu_get_menu
+			(GTK_OPTION_MENU(hbox->action_type_optmenu))));
+	type = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem),
+						 MENU_VAL_ID));
+
+	return type;
+}
+
+static void prefs_filter_edit_insert_cond_hbox(CondHBox *hbox, gint pos)
+{
+	g_return_if_fail(hbox != NULL);
+
+	if (!rule_edit_window.cond_hbox_list) {
+		gtk_widget_set_sensitive(hbox->del_btn, FALSE);
+	} else if (rule_edit_window.cond_hbox_list &&
+		   !rule_edit_window.cond_hbox_list->next) {
+		CondHBox *top_hbox =
+			(CondHBox *)rule_edit_window.cond_hbox_list->data;
+		gtk_widget_set_sensitive(top_hbox->del_btn, TRUE);
+	}
+
+	gtk_box_pack_start(GTK_BOX(rule_edit_window.cond_vbox),
+			   hbox->hbox, FALSE, FALSE, 0);
+	if (pos >= 0) {
+		gtk_box_reorder_child(GTK_BOX(rule_edit_window.cond_vbox),
+				      hbox->hbox, pos);
+	}
+
+	rule_edit_window.cond_hbox_list =
+		g_slist_insert(rule_edit_window.cond_hbox_list, hbox, pos);
+}
+
+static void prefs_filter_edit_insert_action_hbox(ActionHBox *hbox, gint pos)
+{
+	g_return_if_fail(hbox != NULL);
+
+	if (!rule_edit_window.action_hbox_list) {
+		gtk_widget_set_sensitive(hbox->del_btn, FALSE);
+	} else if (rule_edit_window.action_hbox_list &&
+		   !rule_edit_window.action_hbox_list->next) {
+		ActionHBox *top_hbox =
+			(ActionHBox *)rule_edit_window.action_hbox_list->data;
+		gtk_widget_set_sensitive(top_hbox->del_btn, TRUE);
+	}
+
+	gtk_box_pack_start(GTK_BOX(rule_edit_window.action_vbox),
+			   hbox->hbox, FALSE, FALSE, 0);
+	if (pos >= 0) {
+		gtk_box_reorder_child(GTK_BOX(rule_edit_window.action_vbox),
+				      hbox->hbox, pos);
+	}
+
+	rule_edit_window.action_hbox_list =
+		g_slist_insert(rule_edit_window.action_hbox_list, hbox, pos);
+}
+
+static void prefs_filter_edit_remove_cond_hbox(CondHBox *hbox)
+{
+	g_return_if_fail(hbox != NULL);
+	g_return_if_fail(rule_edit_window.cond_hbox_list != NULL);
+
+	rule_edit_window.cond_hbox_list =
+		g_slist_remove(rule_edit_window.cond_hbox_list, hbox);
+	gtk_widget_destroy(hbox->hbox);
+	g_free(hbox);
+
+	if (rule_edit_window.cond_hbox_list &&
+	    !rule_edit_window.cond_hbox_list->next) {
+		hbox = (CondHBox *)rule_edit_window.cond_hbox_list->data;
+		gtk_widget_set_sensitive(hbox->del_btn, FALSE);
+	}
+}
+
+static void prefs_filter_edit_remove_action_hbox(ActionHBox *hbox)
+{
+	g_return_if_fail(hbox != NULL);
+	g_return_if_fail(rule_edit_window.action_hbox_list != NULL);
+
+	rule_edit_window.action_hbox_list =
+		g_slist_remove(rule_edit_window.action_hbox_list, hbox);
+	gtk_widget_destroy(hbox->hbox);
+	g_free(hbox);
+
+	prefs_filter_edit_set_action_hbox_menus_sensitive();
+
+	if (rule_edit_window.action_hbox_list &&
+	    !rule_edit_window.action_hbox_list->next) {
+		hbox = (ActionHBox *)rule_edit_window.action_hbox_list->data;
+		gtk_widget_set_sensitive(hbox->del_btn, FALSE);
+	}
+}
+
+static void prefs_filter_edit_add_rule_cond(FilterRule *rule)
+{
+	CondHBox *hbox;
+	GSList *cur;
+	FilterCond *cond;
+
+	if (!rule || !rule->cond_list) {
+		hbox = prefs_filter_edit_cond_hbox_create();
+		prefs_filter_edit_set_cond_hbox_widgets(hbox, PF_COND_HEADER);
+		prefs_filter_edit_insert_cond_hbox(hbox, -1);
+		return;
+	}
+
+	for (cur = rule->cond_list; cur != NULL; cur = cur->next) {
+		cond = (FilterCond *)cur->data;
+
+		hbox = prefs_filter_edit_cond_hbox_create();
+		prefs_filter_edit_cond_hbox_set(hbox, cond);
+		prefs_filter_edit_insert_cond_hbox(hbox, -1);
+	}
+}
+
+static void prefs_filter_edit_add_rule_action(FilterRule *rule)
+{
+	ActionHBox *hbox;
+	GSList *cur;
+
+	if (!rule || !rule->action_list) {
+		hbox = prefs_filter_edit_action_hbox_create();
+		prefs_filter_edit_insert_action_hbox(hbox, -1);
+		prefs_filter_edit_set_action_hbox_widgets(hbox, PF_ACTION_MOVE);
+		return;
+	}
+
+	for (cur = rule->action_list; cur != NULL; cur = cur->next) {
+		FilterAction *action = (FilterAction *)cur->data;
+
+		hbox = prefs_filter_edit_action_hbox_create();
+		prefs_filter_edit_insert_action_hbox(hbox, -1);
+		prefs_filter_edit_action_hbox_set(hbox, action);
+	}
+}
+
+static void prefs_filter_edit_set_cond_header_menu(CondHBox *hbox)
+{
+	GSList *cur;
+	GtkWidget *menu;
+	GtkWidget *menuitem;
+	gint pos = 0;
+	GList *child;
+
+	menu = gtk_option_menu_get_menu
+		(GTK_OPTION_MENU(hbox->cond_type_optmenu));
+
+	/* destroy header items */
+	child = GTK_MENU_SHELL(menu)->children;
+	while (child != NULL) {
+		GList *next = child->next;
+		menuitem = GTK_WIDGET(child->data);
+		if (!g_object_get_data(G_OBJECT(menuitem), "header_str"))
+			break;
+		gtk_widget_destroy(menuitem);
+		child = next;
+	}
+
+	for (cur = rule_edit_window.hdr_list; cur != NULL;
+	     cur = cur->next, pos++) {
+		Header *header = (Header *)cur->data;
+
+		menuitem = gtk_menu_item_new_with_label(header->name);
+		gtk_widget_show(menuitem);
+		gtk_menu_insert(GTK_MENU(menu), menuitem, pos);
+		g_object_set_data(G_OBJECT(menuitem), MENU_VAL_ID,
+				  GINT_TO_POINTER(PF_COND_HEADER));
+		g_object_set_data(G_OBJECT(menuitem), "header_str",
+				  header->name);
+		g_signal_connect(G_OBJECT(menuitem), "activate",
+				 G_CALLBACK(prefs_filter_cond_activated_cb),
+				 hbox);
+	}
+
+	if (hbox->cur_type == PF_COND_HEADER)
+		prefs_filter_edit_cond_hbox_select
+			(hbox, hbox->cur_type, hbox->cur_header_name);
+}
+
+static void prefs_filter_edit_activate_cond_header(const gchar *header)
+{
+	gint index;
+	CondHBox *hbox;
+	GtkWidget *menu;
+	GtkWidget *menuitem;
+	GList *cur;
+	gchar *menu_header;
+
+	g_return_if_fail(header != NULL);
+	g_return_if_fail(rule_edit_window.cond_hbox_list != NULL);
+
+	hbox = (CondHBox *)rule_edit_window.cond_hbox_list->data;
+	menu = gtk_option_menu_get_menu
+		(GTK_OPTION_MENU(hbox->cond_type_optmenu));
+
+	for (cur = GTK_MENU_SHELL(menu)->children, index = 0;
+	     cur != NULL; cur = cur->next, index++) {
+		menuitem = GTK_WIDGET(cur->data);
+		menu_header = g_object_get_data(G_OBJECT(menuitem),
+						"header_str");
+		if (!menu_header)
+			break;
+		if (!g_strcasecmp(menu_header, header)) {
+			gtk_option_menu_set_history
+				(GTK_OPTION_MENU(hbox->cond_type_optmenu),
+				 index);
+			gtk_menu_item_activate(GTK_MENU_ITEM(menuitem));
+			break;
+		}
+	}
+}
+
+static gint edit_header_list_dialog_deleted(GtkWidget *widget,
+					    GdkEventAny *event, gpointer data)
+{
+	edit_header_list_dialog.finished = TRUE;
+	return TRUE;
+}
+
+static gboolean edit_header_list_dialog_key_pressed(GtkWidget *widget,
+						    GdkEventKey *event,
+						    gpointer data)
+{
+	if (event && event->keyval == GDK_Escape)
+		edit_header_list_dialog.finished = TRUE;
+	return FALSE;
+}
+
+static void edit_header_list_dialog_add(void)
+{
+	GtkCList *clist = GTK_CLIST(edit_header_list_dialog.clist);
+	const gchar *text;
+	gchar *ctext[1];
+	gint row;
+	gchar *row_text;
+
+	text = gtk_entry_get_text(GTK_ENTRY(edit_header_list_dialog.entry));
+	if (text[0] == '\0') return;
+
+	for (row = 0; gtk_clist_get_text(clist, row, 0, &row_text) != 0;
+	     row++) {
+		if (g_strcasecmp(row_text, text) == 0) return;
+	}
+
+	ctext[0] = (gchar *)text;
+	gtk_clist_append(clist, ctext);
+}
+
+static void edit_header_list_dialog_delete(void)
+{
+	GtkCList *clist = GTK_CLIST(edit_header_list_dialog.clist);
+	gint row;
+
+	if (!clist->selection) return;
+
+	row = GPOINTER_TO_INT(clist->selection->data);
+	gtk_clist_remove(clist, row);
+}
+
+static void edit_header_list_dialog_ok(void)
+{
+	edit_header_list_dialog.finished = TRUE;
+	edit_header_list_dialog.ok = TRUE;
+}
+
+static void edit_header_list_dialog_cancel(void)
+{
+	edit_header_list_dialog.finished = TRUE;
+}
+
+static void prefs_filter_edit_edit_header_list_dialog_create(void)
+{
+	GtkWidget *window;
+	GtkWidget *vbox;
+	GtkWidget *hbox;
+
+	GtkWidget *vbox2;
+	GtkWidget *scrwin;
+	GtkWidget *clist;
+
+	GtkWidget *entry_hbox;
+	GtkWidget *label;
+	GtkWidget *entry;
+
+	GtkWidget *btn_vbox;
+	GtkWidget *add_btn;
+	GtkWidget *del_btn;
+
+	GtkWidget *confirm_area;
+	GtkWidget *ok_btn;
+	GtkWidget *cancel_btn;
+
+	gchar *title[1];
+
+	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+	gtk_container_set_border_width(GTK_CONTAINER(window), 8);
+	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_window_set_title(GTK_WINDOW(window), _("Edit header list"));
+
+	g_signal_connect(G_OBJECT(window), "delete_event",
+			 G_CALLBACK(edit_header_list_dialog_deleted), NULL);
+	g_signal_connect(G_OBJECT(window), "key_press_event",
+			 G_CALLBACK(edit_header_list_dialog_key_pressed), NULL);
+
+	vbox = gtk_vbox_new(FALSE, 6);
+	gtk_container_add(GTK_CONTAINER(window), vbox);
+
+	hbox = gtk_hbox_new(FALSE, 8);
+	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
+
+	vbox2 = gtk_vbox_new(FALSE, 8);
+	gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 0);
+
+	scrwin = gtk_scrolled_window_new(NULL, NULL);
+	gtk_widget_set_size_request(scrwin, 120, 160);
+	gtk_box_pack_start(GTK_BOX(vbox2), scrwin, TRUE, TRUE, 0);
+	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrwin),
+				       GTK_POLICY_AUTOMATIC,
+				       GTK_POLICY_AUTOMATIC);
+
+	title[0] = _("Headers");
+	clist = gtk_clist_new_with_titles(1, title);
+	gtk_container_add(GTK_CONTAINER(scrwin), clist);
+	gtk_clist_set_column_width(GTK_CLIST(clist), 0, 80);
+	gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_BROWSE);
+	GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(clist)->column[0].button,
+			       GTK_CAN_FOCUS);
+
+	entry_hbox = gtk_hbox_new(FALSE, 8);
+	gtk_box_pack_start(GTK_BOX(vbox), entry_hbox, FALSE, TRUE, 0);
+
+	label = gtk_label_new(_("Header:"));
+	gtk_box_pack_start(GTK_BOX(entry_hbox), label, FALSE, FALSE, 0);
+
+	entry = gtk_entry_new();
+	gtk_box_pack_start(GTK_BOX(entry_hbox), entry, TRUE, TRUE, 0);
+
+	btn_vbox = gtk_vbox_new(FALSE, 8);
+	gtk_box_pack_start(GTK_BOX(hbox), btn_vbox, FALSE, FALSE, 0);
+
+	add_btn = gtk_button_new_with_label(_("Add"));
+	gtk_box_pack_start(GTK_BOX(btn_vbox), add_btn, FALSE, FALSE, 0);
+
+	del_btn = gtk_button_new_with_label(_(" Delete "));
+	gtk_box_pack_start(GTK_BOX(btn_vbox), del_btn, FALSE, FALSE, 0);
+
+	gtkut_button_set_create(&confirm_area, &ok_btn, _("OK"),
+				&cancel_btn, _("Cancel"), NULL, NULL);
+	gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
+	gtk_widget_grab_default(ok_btn);
+
+	g_signal_connect(G_OBJECT(add_btn), "clicked",
+			 G_CALLBACK(edit_header_list_dialog_add), NULL);
+	g_signal_connect(G_OBJECT(del_btn), "clicked",
+			 G_CALLBACK(edit_header_list_dialog_delete), NULL);
+	g_signal_connect(G_OBJECT(ok_btn), "clicked",
+			 G_CALLBACK(edit_header_list_dialog_ok), NULL);
+	g_signal_connect(G_OBJECT(cancel_btn), "clicked",
+			 G_CALLBACK(edit_header_list_dialog_cancel), NULL);
+
+	manage_window_set_transient(GTK_WINDOW(window));
+
+	gtk_widget_show_all(window);
+
+	edit_header_list_dialog.window = window;
+	edit_header_list_dialog.clist = clist;
+	edit_header_list_dialog.entry = entry;
+	edit_header_list_dialog.finished = FALSE;
+	edit_header_list_dialog.ok = FALSE;
+}
+
+static void prefs_filter_edit_edit_header_list_dialog_set(void)
+{
+	GtkCList *clist = GTK_CLIST(edit_header_list_dialog.clist);
+	GSList *list;
+	GSList *cur;
+	gchar *text[1];
+
+	gtk_clist_freeze(clist);
+
+	list = prefs_filter_get_user_header_list();
+	for (cur = list; cur != NULL; cur = cur->next) {
+		Header *header = (Header *)cur->data;
+		text[0] = header->name;
+		gtk_clist_append(clist, text);
+	}
+
+	gtk_clist_thaw(clist);
+}
+
+static GSList *prefs_filter_edit_edit_header_list_dialog_get(void)
+{
+	GtkCList *clist = GTK_CLIST(edit_header_list_dialog.clist);
+	gint row;
+	gchar *text;
+	GSList *list = NULL;
+
+	for (row = 0; gtk_clist_get_text(clist, row, 0, &text) != 0; row++)
+		list = procheader_add_header_list(list, text, NULL);
+
+	return list;
+}
+
+static void prefs_filter_edit_edit_header_list(void)
+{
+	GSList *list;
+	GSList *cur;
+
+	prefs_filter_edit_edit_header_list_dialog_create();
+	prefs_filter_edit_edit_header_list_dialog_set();
+
+	while (edit_header_list_dialog.finished == FALSE)
+		gtk_main_iteration();
+
+	if (edit_header_list_dialog.ok == TRUE) {
+		list = prefs_filter_edit_edit_header_list_dialog_get();
+		prefs_filter_set_user_header_list(list);
+		prefs_filter_edit_update_header_list();
+		for (cur = rule_edit_window.cond_hbox_list; cur != NULL;
+		     cur = cur->next) {
+			CondHBox *hbox = (CondHBox *)cur->data;
+			prefs_filter_edit_set_cond_header_menu(hbox);
+		}
+	}
+
+	gtk_widget_destroy(edit_header_list_dialog.window);
+	edit_header_list_dialog.window = NULL;
+	edit_header_list_dialog.clist = NULL;
+	edit_header_list_dialog.entry = NULL;
+	edit_header_list_dialog.finished = FALSE;
+	edit_header_list_dialog.ok = FALSE;
+}
+
+static FilterRule *prefs_filter_edit_dialog_to_rule(void)
+{
+	FilterRule *rule = NULL;
+	GSList *cur;
+	const gchar *rule_name;
+	FilterBoolOp bool_op = FLT_OR;
+	GSList *cond_list = NULL;
+	GSList *action_list = NULL;
+	GtkWidget *bool_op_menuitem;
+	gchar *error_msg = NULL;
+
+	rule_name = gtk_entry_get_text(GTK_ENTRY(rule_edit_window.name_entry));
+	if (!rule_name || *rule_name == '\0') {
+		error_msg = _("Rule name is not specified.");
+		goto error;
+	}
+
+	bool_op_menuitem = gtk_menu_get_active
+		(GTK_MENU(gtk_option_menu_get_menu
+			(GTK_OPTION_MENU(rule_edit_window.bool_op_optmenu))));
+	bool_op = GPOINTER_TO_INT
+		(g_object_get_data(G_OBJECT(bool_op_menuitem), MENU_VAL_ID));
+
+	for (cur = rule_edit_window.cond_hbox_list; cur != NULL;
+	     cur = cur->next) {
+		CondHBox *hbox = (CondHBox *)cur->data;
+		GtkWidget *cond_type_menuitem;
+		CondMenuType cond_menu_type;
+		MatchMenuType match_menu_type;
+		const gchar *header_name;
+		const gchar *key_str;
+		gint int_value;
+		FilterCond *cond = NULL;
+		FilterMatchType match_type = FLT_CONTAIN;
+		FilterMatchFlag match_flag = 0;
+		SizeMatchType size_type;
+		AgeMatchType age_type;
+
+		cond_type_menuitem = gtk_menu_get_active
+			(GTK_MENU(gtk_option_menu_get_menu
+				(GTK_OPTION_MENU(hbox->cond_type_optmenu))));
+		cond_menu_type = GPOINTER_TO_INT
+			(g_object_get_data
+				(G_OBJECT(cond_type_menuitem), MENU_VAL_ID));
+
+		match_menu_type = menu_get_option_menu_active_index
+			(GTK_OPTION_MENU(hbox->match_type_optmenu));
+
+		key_str = gtk_entry_get_text(GTK_ENTRY(hbox->key_entry));
+
+		switch (match_menu_type) {
+		case PF_MATCH_CONTAIN:
+			match_type = FLT_CONTAIN;
+			break;
+		case PF_MATCH_NOT_CONTAIN:
+			match_type = FLT_CONTAIN;
+			match_flag |= FLT_NOT_MATCH;
+			break;
+		case PF_MATCH_EQUAL:
+			match_type = FLT_EQUAL;
+			break;
+		case PF_MATCH_NOT_EQUAL:
+			match_type = FLT_EQUAL;
+			match_flag |= FLT_NOT_MATCH;
+			break;
+		case PF_MATCH_REGEX:
+			match_type = FLT_REGEX;
+			break;
+		case PF_MATCH_NOT_REGEX:
+			match_type = FLT_REGEX;
+			match_flag |= FLT_NOT_MATCH;
+			break;
+		default:
+			break;
+		}
+
+		switch (cond_menu_type) {
+		case PF_COND_HEADER:
+			header_name = g_object_get_data
+				(G_OBJECT(cond_type_menuitem), "header_str");
+			cond = filter_cond_new(FLT_COND_HEADER,
+					       match_type, match_flag,
+					       header_name, key_str);
+			break;
+		case PF_COND_TO_OR_CC:
+			cond = filter_cond_new(FLT_COND_TO_OR_CC, match_type,
+					       match_flag, NULL, key_str);
+			break;
+		case PF_COND_ANY_HEADER:
+			cond = filter_cond_new(FLT_COND_ANY_HEADER, match_type,
+					       match_flag, NULL, key_str);
+			break;
+		case PF_COND_BODY:
+			cond = filter_cond_new(FLT_COND_BODY, match_type,
+					       match_flag, NULL, key_str);
+			break;
+		case PF_COND_CMD_TEST:
+			if (key_str && *key_str)
+				cond = filter_cond_new(FLT_COND_CMD_TEST,
+						       0, 0, NULL, key_str);
+			else
+				error_msg = _("Command is not specified.");
+			break;
+		case PF_COND_SIZE:
+			size_type = menu_get_option_menu_active_index
+				 (GTK_OPTION_MENU(hbox->size_match_optmenu));
+			match_flag = size_type == PF_SIZE_LARGER
+				? 0 : FLT_NOT_MATCH;
+			int_value = gtk_spin_button_get_value_as_int
+				(GTK_SPIN_BUTTON(hbox->spin_btn));
+			cond = filter_cond_new(FLT_COND_SIZE_GREATER,
+					       0, match_flag, NULL,
+					       itos(int_value));
+			break;
+		case PF_COND_AGE:
+			age_type = menu_get_option_menu_active_index
+				 (GTK_OPTION_MENU(hbox->age_match_optmenu));
+			match_flag = age_type == PF_AGE_LONGER
+				? 0 : FLT_NOT_MATCH;
+			int_value = gtk_spin_button_get_value_as_int
+				(GTK_SPIN_BUTTON(hbox->spin_btn));
+			cond = filter_cond_new(FLT_COND_AGE_GREATER,
+					       0, match_flag, NULL,
+					       itos(int_value));
+			break;
+		case PF_COND_ACCOUNT:
+		case PF_COND_EDIT_HEADER:
+		default:
+			break;
+		}
+
+		if (cond)
+			cond_list = g_slist_append(cond_list, cond);
+		else {
+			if (!error_msg)
+				error_msg = _("Invalid condition exists.");
+			goto error;
+		}
+	}
+
+	for (cur = rule_edit_window.action_hbox_list; cur != NULL;
+	     cur = cur->next) {
+		ActionHBox *hbox = (ActionHBox *)cur->data;
+		ActionMenuType action_menu_type;
+		const gchar *str;
+		guint color;
+		FilterAction *action = NULL;
+
+		action_menu_type = prefs_filter_edit_get_action_hbox_type(hbox);
+
+		switch (action_menu_type) {
+		case PF_ACTION_MOVE:
+			str = gtk_entry_get_text(GTK_ENTRY(hbox->folder_entry));
+			if (str && *str)
+				action = filter_action_new(FLT_ACTION_MOVE,
+							   str);
+			else
+				error_msg = _("Destination folder is not specified.");
+			break;
+		case PF_ACTION_COPY:
+			str = gtk_entry_get_text(GTK_ENTRY(hbox->folder_entry));
+			if (str && *str)
+				action = filter_action_new(FLT_ACTION_COPY,
+							   str);
+			else
+				error_msg = _("Destination folder is not specified.");
+			break;
+		case PF_ACTION_NOT_RECEIVE:
+			action = filter_action_new(FLT_ACTION_NOT_RECEIVE,
+						   NULL);
+			break;
+		case PF_ACTION_DELETE:
+			action = filter_action_new(FLT_ACTION_DELETE, NULL);
+			break;
+		case PF_ACTION_EXEC:
+			str = gtk_entry_get_text(GTK_ENTRY(hbox->cmd_entry));
+			if (str && *str)
+				action = filter_action_new(FLT_ACTION_EXEC,
+							   str);
+			else
+				error_msg = _("Command is not specified.");
+			break;
+		case PF_ACTION_EXEC_ASYNC:
+			str = gtk_entry_get_text(GTK_ENTRY(hbox->cmd_entry));
+			if (str && *str)
+				action = filter_action_new
+					(FLT_ACTION_EXEC_ASYNC, str);
+			else
+				error_msg = _("Command is not specified.");
+			break;
+		case PF_ACTION_MARK:
+			action = filter_action_new(FLT_ACTION_MARK, NULL);
+			break;
+		case PF_ACTION_COLOR_LABEL:
+			color = colorlabel_get_color_menu_active_item
+				(gtk_option_menu_get_menu
+				 (GTK_OPTION_MENU(hbox->clabel_optmenu)));
+			action = filter_action_new(FLT_ACTION_COLOR_LABEL,
+						   itos(color));
+			break;
+		case PF_ACTION_MARK_READ:
+			action = filter_action_new(FLT_ACTION_MARK_READ, NULL);
+			break;
+		case PF_ACTION_FORWARD:
+		case PF_ACTION_FORWARD_AS_ATTACHMENT:
+		case PF_ACTION_REDIRECT:
+			break;
+		case PF_ACTION_STOP_EVAL:
+			action = filter_action_new(FLT_ACTION_STOP_EVAL, NULL);
+			break;
+		case PF_ACTION_SEPARATOR:
+		default:
+			break;
+		}
+
+		if (action)
+			action_list = g_slist_append(action_list, action);
+		else {
+			if (!error_msg)
+				error_msg = _("Invalid action exists.");
+			goto error;
+		}
+	}
+
+error:
+	if (error_msg || !cond_list || !action_list) {
+		if (!error_msg) {
+			if (!cond_list)
+				error_msg = _("Condition not exist.");
+			else
+				error_msg = _("Action not exist.");
+		}
+		alertpanel_error("%s", error_msg);
+		if (cond_list)
+			filter_cond_list_free(cond_list);
+		if (action_list)
+			filter_action_list_free(action_list);
+		return NULL;
+	}
+
+	rule = filter_rule_new(rule_name, bool_op, cond_list, action_list);
+
+	return rule;
+}
+
+/* callback functions */
+
+static gint prefs_filter_edit_deleted(GtkWidget *widget, GdkEventAny *event,
+				      gpointer data)
+{
+	prefs_filter_edit_cancel();
+	return TRUE;
+}
+
+static gboolean prefs_filter_edit_key_pressed(GtkWidget *widget,
+					      GdkEventKey *event,
+					      gpointer data)
+{
+	if (event && event->keyval == GDK_Escape)
+		prefs_filter_edit_cancel();
+	return FALSE;
+}
+
+static void prefs_filter_edit_ok(void)
+{
+	FilterRule *rule;
+
+	rule = prefs_filter_edit_dialog_to_rule();
+	if (rule) {
+		rule_edit_window.new_rule = rule;
+		rule_edit_window.edit_finished = TRUE;
+	}
+}
+
+static void prefs_filter_edit_cancel(void)
+{
+	rule_edit_window.new_rule = NULL;
+	rule_edit_window.edit_finished = TRUE;
+}
+
+static void prefs_filter_cond_activated_cb(GtkWidget *widget, gpointer data)
+{
+	CondHBox *hbox = (CondHBox *)data;
+	CondMenuType type;
+
+	type = GPOINTER_TO_INT
+		(g_object_get_data(G_OBJECT(widget), MENU_VAL_ID));
+
+	if (type == PF_COND_EDIT_HEADER) {
+		prefs_filter_edit_edit_header_list();
+		prefs_filter_edit_cond_hbox_select
+			(hbox, hbox->cur_type, hbox->cur_header_name);
+	} else {
+		hbox->cur_type = type;
+		g_free(hbox->cur_header_name);
+		hbox->cur_header_name = NULL;
+
+		prefs_filter_edit_set_cond_hbox_widgets(hbox, type);
+		if (type == PF_COND_HEADER) {
+			gchar *header_name;
+			gchar *header_field;
+
+			header_name = (gchar *)g_object_get_data
+				(G_OBJECT(widget), "header_str");
+			header_field = prefs_filter_get_msg_header_field
+				(header_name);
+			if (header_field)
+				gtk_entry_set_text(GTK_ENTRY(hbox->key_entry),
+						   header_field);
+			hbox->cur_header_name = g_strdup(header_name);
+		}
+	}
+}
+
+static void prefs_filter_action_activated_cb(GtkWidget *widget, gpointer data)
+{
+	ActionHBox *hbox = (ActionHBox *)data;
+	ActionMenuType type;
+
+	type = GPOINTER_TO_INT
+		(g_object_get_data(G_OBJECT(widget), MENU_VAL_ID));
+	prefs_filter_edit_set_action_hbox_widgets(hbox, type);
+}
+
+static void prefs_filter_action_select_dest_cb(GtkWidget *widget, gpointer data)
+{
+	ActionHBox *hbox = (ActionHBox *)data;
+
+	FolderItem *dest;
+	gchar *id;
+
+	dest = foldersel_folder_sel(NULL, FOLDER_SEL_COPY, NULL);
+	if (!dest || !dest->path) return;
+
+	id = folder_item_get_identifier(dest);
+	if (id) {
+		gtk_entry_set_text(GTK_ENTRY(hbox->folder_entry), id);
+		g_free(id);
+	}
+}
+
+static void prefs_filter_cond_del_cb(GtkWidget *widget, gpointer data)
+{
+	CondHBox *hbox = (CondHBox *)data;
+
+	if (rule_edit_window.cond_hbox_list &&
+	    rule_edit_window.cond_hbox_list->next)
+		prefs_filter_edit_remove_cond_hbox(hbox);
+}
+
+static void prefs_filter_cond_add_cb(GtkWidget *widget, gpointer data)
+{
+	CondHBox *hbox = (CondHBox *)data;
+	CondHBox *new_hbox;
+	gint index;
+
+	index = g_slist_index(rule_edit_window.cond_hbox_list, hbox);
+	g_return_if_fail(index >= 0);
+	new_hbox = prefs_filter_edit_cond_hbox_create();
+	prefs_filter_edit_set_cond_hbox_widgets(new_hbox, PF_COND_HEADER);
+	prefs_filter_edit_insert_cond_hbox(new_hbox, index + 1);
+}
+
+static void prefs_filter_action_del_cb(GtkWidget *widget, gpointer data)
+{
+	ActionHBox *hbox = (ActionHBox *)data;
+
+	if (rule_edit_window.action_hbox_list &&
+	    rule_edit_window.action_hbox_list->next)
+		prefs_filter_edit_remove_action_hbox(hbox);
+}
+
+static void prefs_filter_action_add_cb(GtkWidget *widget, gpointer data)
+{
+	ActionHBox *hbox = (ActionHBox *)data;
+	ActionHBox *new_hbox;
+	gboolean action_menu_selection[PF_ACTION_NONE];
+	gint index;
+
+	prefs_filter_edit_get_action_hbox_menus_selection(action_menu_selection);
+
+	index = g_slist_index(rule_edit_window.action_hbox_list, hbox);
+	g_return_if_fail(index >= 0);
+	new_hbox = prefs_filter_edit_action_hbox_create();
+	prefs_filter_edit_insert_action_hbox(new_hbox, index + 1);
+	if (action_menu_selection[PF_ACTION_MOVE] == TRUE ||
+	    action_menu_selection[PF_ACTION_NOT_RECEIVE] == TRUE ||
+	    action_menu_selection[PF_ACTION_DELETE] == TRUE)
+		prefs_filter_edit_set_action_hbox_widgets(new_hbox,
+							  PF_ACTION_COPY);
+	else
+		prefs_filter_edit_set_action_hbox_widgets(new_hbox,
+							  PF_ACTION_MOVE);
+}