Report the percentage of file complete for the filter.

2000-10-11  Not Zed  <NotZed@HelixCode.com>

	* filter-driver.c (filter_driver_filter_mbox): Report the
	percentage of file complete for the filter.

2000-10-10  Not Zed  <NotZed@HelixCode.com>

	* filter-driver.c (filter_driver_run): Why on earth does this code
	ref all these objects for?  This is not right at all.
	(filter_driver_run): Changed source type to a string.
	(filter_driver_run): REmove the very weird exception copying
	stuff - just ref it instead.
	(do_score):
	(do_colour):
	(do_stop):
	(do_copy):
	(mark_forward):
	(do_delete): Removed bogus 'terminated' testing.  This is NOT
	NEEDED HERE.  It is tested after every rule/action, and
	termination only makes sense at that point.
	(filter_driver_filter_message): new funciton (renamed), filter
	only a message.
	(filter_driver_filter_mbox): Filter a whole mbox.
	(filter_driver_run): If we aren't given an info, create a simple
	one based on the message headers.
	(filter_driver_filter_message): Renamed from filter_driver_run().
	(filter_driver_set_status_func): Set the status callback function.
	(filter_driver_set_default_folder): Set the default folder for
	filtering.
	(report_status): Internal function to report the status of a given
	event.
	(do_copy): Removed a pointless cache lookup - duh, we do it in
	open_folder anyway (infact, we do it in camel too!!).
	(filter_driver_filter_message): Removed pointless re-refing of
	arguments.  Why would anyone think this could be any use at all?
	(filter_driver_filter_folder): New function to filter a whole
	folder.

	* filter-editor.c (rule_add): api fixes.
	(rule_edit):
	(rule_up):
	(rule_down):
	(set_sensitive): This didn't take into account the source, now it
	does.
	(select_source): Fix for api changes.  Changed the rather generic
	'number' argument to be 'source', and a string.
	(filter_editor_construct): Changed the 'number' to 'source', and
	set the string appropriately.  Added a warning for one case where
	the glade file is out of sync.

	* score-editor.c (score_editor_construct):
	(rule_edit):
	(rule_delete):
	(rule_up):
	(rule_down):
	(set_sensitive): api fixes.

	* vfolder-editor.c (set_sensitive): Api fixes.
	(vfolder_editor_construct):
	(rule_edit):
	(vfolder_editor_construct):

	* rule-context.h (RCNextRuleFunc): Added a source argument.

	* rule-context.c (rule_context_next_rule): Added source argument.
	(rule_context_find_rule): Added source argument.
	(rule_context_get_rank_rule): Added source argument.
	(rule_context_get_rank_rule_with_source): Removed.
	(save): Fixed for changes to RCNextRuleFunc prototype.

	* filter-rule.h: Changed the source to be a string, removed the
	filter_source_t type.

	* filter-rule.c (filter_rule_set_source): New function to set the
	source of a rule.  What idiot ran this code through indent?
	(filter_rule_find_list): Added a source argument.
	(filter_rule_next_list): Added a source argument.
	(get_widget): Fixed the wording.  You dont remove search parts,
	you can only remove the last one.  Why you even need to mention
	they are search 'criteria' is beyond me.  Whoever added the
	scrolled window needs to be shot, its the single most awful GUI
	feature ever invented (ranks with the close button next to
	maximise).
	(xml_encode): Save source as a string (if present).
	(xml_decode): Likewise for loading & fixed a small memleak.
	(filter_rule_finalise): Free source.

svn path=/trunk/; revision=5884

1 files changed, 293 insertions, 293 deletions

diff --git a/filter/filter-rule.c b/filter/filter-rule.c
index 33dc290c80..11c5e1adde 100644
--- a/filter/filter-rule.c
+++ b/filter/filter-rule.c
@@ -30,14 +30,14 @@
 
 #define d(x)
 
-static xmlNodePtr xml_encode (FilterRule *);
-static int xml_decode (FilterRule *, xmlNodePtr, RuleContext *);
-static void build_code (FilterRule *, GString *out);
-static GtkWidget *get_widget (FilterRule *fr, struct _RuleContext *f);
+static xmlNodePtr xml_encode(FilterRule *);
+static int xml_decode(FilterRule *, xmlNodePtr, RuleContext *);
+static void build_code(FilterRule *, GString * out);
+static GtkWidget *get_widget(FilterRule * fr, struct _RuleContext *f);
 
-static void filter_rule_class_init (FilterRuleClass *class);
-static void filter_rule_init (FilterRule *gspaper);
-static void filter_rule_finalise (GtkObject *obj);
+static void filter_rule_class_init(FilterRuleClass * class);
+static void filter_rule_init(FilterRule * gspaper);
+static void filter_rule_finalise(GtkObject * obj);
 
 #define _PRIVATE(x) (((FilterRule *)(x))->priv)
 
@@ -53,73 +53,73 @@ enum {
 
 static guint signals[LAST_SIGNAL] = { 0 };
 
-guint
-filter_rule_get_type (void)
+guint filter_rule_get_type(void)
 {
 	static guint type = 0;
-	
+
 	if (!type) {
 		GtkTypeInfo type_info = {
 			"FilterRule",
 			sizeof(FilterRule),
 			sizeof(FilterRuleClass),
-			(GtkClassInitFunc)filter_rule_class_init,
-			(GtkObjectInitFunc)filter_rule_init,
-			(GtkArgSetFunc)NULL,
-			(GtkArgGetFunc)NULL
+			(GtkClassInitFunc) filter_rule_class_init,
+			(GtkObjectInitFunc) filter_rule_init,
+			(GtkArgSetFunc) NULL,
+			(GtkArgGetFunc) NULL
 		};
-		
-		type = gtk_type_unique (gtk_object_get_type (), &type_info);
+
+		type = gtk_type_unique(gtk_object_get_type(), &type_info);
 	}
-	
+
 	return type;
 }
 
 static void
-filter_rule_class_init (FilterRuleClass *class)
+filter_rule_class_init(FilterRuleClass * class)
 {
 	GtkObjectClass *object_class;
-	
-	object_class = (GtkObjectClass *)class;
-	parent_class = gtk_type_class (gtk_object_get_type ());
-	
+
+	object_class = (GtkObjectClass *) class;
+	parent_class = gtk_type_class(gtk_object_get_type());
+
 	object_class->finalize = filter_rule_finalise;
-	
+
 	/* override methods */
 	class->xml_encode = xml_encode;
 	class->xml_decode = xml_decode;
 	class->build_code = build_code;
 	class->get_widget = get_widget;
-	
+
 	/* signals */
-	
-	gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL);
+
+	gtk_object_class_add_signals(object_class, signals, LAST_SIGNAL);
 }
 
 static void
-filter_rule_init (FilterRule *o)
+filter_rule_init(FilterRule * o)
 {
-	o->priv = g_malloc0 (sizeof (*o->priv));
+	o->priv = g_malloc0(sizeof(*o->priv));
 }
 
 static void
-unref_list (GList *l)
+unref_list(GList * l)
 {
 	while (l) {
-		gtk_object_unref (GTK_OBJECT (l->data));
-		l = g_list_next (l);
+		gtk_object_unref(GTK_OBJECT(l->data));
+		l = g_list_next(l);
 	}
 }
 
 static void
-filter_rule_finalise (GtkObject *obj)
+filter_rule_finalise(GtkObject * obj)
 {
-	FilterRule *o = (FilterRule *)obj;
-	
-	g_free (o->name);
-	unref_list (o->parts);
-	
-        ((GtkObjectClass *)(parent_class))->finalize (obj);
+	FilterRule *o = (FilterRule *) obj;
+
+	g_free(o->name);
+	g_free(o->source);
+	unref_list(o->parts);
+
+	((GtkObjectClass *) (parent_class))->finalize(obj);
 }
 
 /**
@@ -130,206 +130,196 @@ filter_rule_finalise (GtkObject *obj)
  * Return value: A new #FilterRule object.
  **/
 FilterRule *
-filter_rule_new (void)
+filter_rule_new(void)
 {
-	FilterRule *o = (FilterRule *)gtk_type_new (filter_rule_get_type ());
+	FilterRule *o = (FilterRule *) gtk_type_new(filter_rule_get_type());
+
 	return o;
 }
 
 void
-filter_rule_set_name (FilterRule *fr, const char *name)
+filter_rule_set_name(FilterRule * fr, const char *name)
+{
+	g_free(fr->name);
+	fr->name = g_strdup(name);
+}
+
+void
+filter_rule_set_source(FilterRule * fr, const char *source)
 {
-	g_free (fr->name);
-	fr->name = g_strdup (name);
+	g_free(fr->source);
+	fr->source = g_strdup(source);
 }
 
-xmlNodePtr
-filter_rule_xml_encode (FilterRule *fr)
+xmlNodePtr filter_rule_xml_encode(FilterRule * fr)
 {
-	return ((FilterRuleClass *)((GtkObject *)fr)->klass)->xml_encode (fr);
+	return ((FilterRuleClass *) ((GtkObject *) fr)->klass)->xml_encode(fr);
 }
 
 static xmlNodePtr
-xml_encode (FilterRule *fr)
+xml_encode(FilterRule * fr)
 {
 	xmlNodePtr node, set, work;
 	GList *l;
-	
-	node = xmlNewNode (NULL, "rule");
+
+	node = xmlNewNode(NULL, "rule");
 	switch (fr->grouping) {
 	case FILTER_GROUP_ALL:
-		xmlSetProp (node, "grouping", "all");
+		xmlSetProp(node, "grouping", "all");
 		break;
 	case FILTER_GROUP_ANY:
-		xmlSetProp (node, "grouping", "any");
+		xmlSetProp(node, "grouping", "any");
 		break;
 	}
-	
-	switch (fr->source) {
-	case FILTER_SOURCE_INCOMING:
-		xmlSetProp (node, "source", "incoming");
-		break;
-	case FILTER_SOURCE_DEMAND:
-		xmlSetProp (node, "source", "ondemand");
-		break;
-	case FILTER_SOURCE_OUTGOING:
-		xmlSetProp (node, "source", "outgoing");
-		break;
+
+	if (fr->source) {
+		xmlSetProp(node, "source", "incoming");
 	}
-	
+
 	if (fr->name) {
-		work = xmlNewNode (NULL, "title");
-		xmlNodeSetContent (work, fr->name);
-		xmlAddChild (node, work);
+		work = xmlNewNode(NULL, "title");
+		xmlNodeSetContent(work, fr->name);
+		xmlAddChild(node, work);
 	}
-	set = xmlNewNode (NULL, "partset");
-	xmlAddChild (node, set);
+	set = xmlNewNode(NULL, "partset");
+	xmlAddChild(node, set);
 	l = fr->parts;
 	while (l) {
-		work = filter_part_xml_encode ((FilterPart *)l->data);
-		xmlAddChild (set, work);
-		l = g_list_next (l);
+		work = filter_part_xml_encode((FilterPart *) l->data);
+		xmlAddChild(set, work);
+		l = g_list_next(l);
 	}
 	return node;
 }
 
 static void
-load_set (xmlNodePtr node, FilterRule *fr, RuleContext *f)
+load_set(xmlNodePtr node, FilterRule * fr, RuleContext * f)
 {
 	xmlNodePtr work;
 	char *rulename;
 	FilterPart *part;
-	
+
 	work = node->childs;
 	while (work) {
-		if (!strcmp (work->name, "part")) {
-			rulename = xmlGetProp (work, "name");
-			part = rule_context_find_part (f, rulename);
+		if (!strcmp(work->name, "part")) {
+			rulename = xmlGetProp(work, "name");
+			part = rule_context_find_part(f, rulename);
 			if (part) {
-				part = filter_part_clone (part);
-				filter_part_xml_decode (part, work);
-				filter_rule_add_part (fr, part);
+				part = filter_part_clone(part);
+				filter_part_xml_decode(part, work);
+				filter_rule_add_part(fr, part);
 			} else {
-				g_warning ("cannot find rule part '%s'\n", rulename);
+				g_warning("cannot find rule part '%s'\n", rulename);
 			}
-			xmlFree (rulename);
+			xmlFree(rulename);
 		} else {
-			g_warning ("Unknwon xml node in part: %s", work->name);
+			g_warning("Unknwon xml node in part: %s", work->name);
 		}
 		work = work->next;
 	}
 }
 
 int
-filter_rule_xml_decode (FilterRule *fr, xmlNodePtr node, RuleContext *f)
+filter_rule_xml_decode(FilterRule * fr, xmlNodePtr node, RuleContext * f)
 {
-	return ((FilterRuleClass *)((GtkObject *)fr)->klass)->xml_decode (fr, node, f);
+	return ((FilterRuleClass *) ((GtkObject *) fr)->klass)->xml_decode(fr, node, f);
 }
 
 static int
-xml_decode (FilterRule *fr, xmlNodePtr node, RuleContext *f)
+xml_decode(FilterRule * fr, xmlNodePtr node, RuleContext * f)
 {
 	xmlNodePtr work;
 	char *grouping;
 	char *source;
-	
+
 	if (fr->name) {
-		g_free (fr->name);
+		g_free(fr->name);
 		fr->name = NULL;
 	}
-	
-	grouping = xmlGetProp (node, "grouping");
-	if (!strcmp (grouping, "any"))
+
+	grouping = xmlGetProp(node, "grouping");
+	if (!strcmp(grouping, "any"))
 		fr->grouping = FILTER_GROUP_ANY;
 	else
 		fr->grouping = FILTER_GROUP_ALL;
-	
-	/* FIXME: free source and grouping? */
-	source = xmlGetProp (node, "source");
-	if (!source) /*default to incoming*/
-		fr->source = FILTER_SOURCE_INCOMING;
-	else if (!strcmp (source, "outgoing"))
-		fr->source = FILTER_SOURCE_OUTGOING;
-	else if (!strcmp (source, "ondemand"))
-		fr->source = FILTER_SOURCE_DEMAND;
-	else if (!strcmp (source, "incoming"))
-		fr->source = FILTER_SOURCE_INCOMING;
-	else {
-		g_warning ("Unknown filter source type \"%s\"", source);
-		fr->source = FILTER_SOURCE_INCOMING;
+	xmlFree(grouping);
+
+	source = xmlGetProp(node, "source");
+	if (source) {
+		fr->source = source;
 	}
-	
+
 	work = node->childs;
 	while (work) {
-		if (!strcmp (work->name, "partset")) {
-			load_set (work, fr, f);
-		} else if (!strcmp (work->name, "title")) {
+		if (!strcmp(work->name, "partset")) {
+			load_set(work, fr, f);
+		} else if (!strcmp(work->name, "title")) {
 			if (!fr->name)
-				fr->name = xmlNodeGetContent (work);
+				fr->name = xmlNodeGetContent(work);
 		}
 		work = work->next;
 	}
-	
+
 	return 0;
 }
 
 void
-filter_rule_add_part (FilterRule *fr, FilterPart *fp)
+filter_rule_add_part(FilterRule * fr, FilterPart * fp)
 {
-	fr->parts = g_list_append (fr->parts, fp);
+	fr->parts = g_list_append(fr->parts, fp);
 }
 
 void
-filter_rule_remove_part (FilterRule *fr, FilterPart *fp)
+filter_rule_remove_part(FilterRule * fr, FilterPart * fp)
 {
-	fr->parts = g_list_remove (fr->parts, fp);
+	fr->parts = g_list_remove(fr->parts, fp);
 }
 
 void
-filter_rule_replace_part (FilterRule *fr, FilterPart *fp, FilterPart *new)
+filter_rule_replace_part(FilterRule * fr, FilterPart * fp, FilterPart * new)
 {
 	GList *l;
-	
-	l = g_list_find (fr->parts, fp);
+
+	l = g_list_find(fr->parts, fp);
 	if (l) {
 		l->data = new;
 	} else {
-		fr->parts = g_list_append (fr->parts, new);
+		fr->parts = g_list_append(fr->parts, new);
 	}
 }
 
 void
-filter_rule_build_code (FilterRule *fr, GString *out)
+filter_rule_build_code(FilterRule * fr, GString * out)
 {
-	return ((FilterRuleClass *)((GtkObject *)fr)->klass)->build_code (fr, out);
+	return ((FilterRuleClass *) ((GtkObject *) fr)->klass)->build_code(fr, out);
 }
 
 static void
-build_code (FilterRule *fr, GString *out)
+build_code(FilterRule * fr, GString * out)
 {
 	switch (fr->grouping) {
 	case FILTER_GROUP_ALL:
-		g_string_append (out, " (and\n  ");
+		g_string_append(out, " (and\n  ");
 		break;
 	case FILTER_GROUP_ANY:
-		g_string_append (out, " (or\n  ");
+		g_string_append(out, " (or\n  ");
 		break;
 	default:
-		g_warning ("Invalid grouping");
+		g_warning("Invalid grouping");
 	}
-	
-	filter_part_build_code_list (fr->parts, out);
-	g_string_append (out, ")\n");
+
+	filter_part_build_code_list(fr->parts, out);
+	g_string_append(out, ")\n");
 }
 
 static void
-match_all (GtkWidget *widget, FilterRule *fr)
+match_all(GtkWidget * widget, FilterRule * fr)
 {
 	fr->grouping = FILTER_GROUP_ALL;
 }
 
 static void
-match_any (GtkWidget *widget, FilterRule *fr)
+match_any(GtkWidget * widget, FilterRule * fr)
 {
 	fr->grouping = FILTER_GROUP_ANY;
 }
@@ -342,30 +332,30 @@ struct _part_data {
 };
 
 static void
-option_activate (GtkMenuItem *item, struct _part_data *data)
+option_activate(GtkMenuItem * item, struct _part_data *data)
 {
-	FilterPart *part = gtk_object_get_data (GTK_OBJECT (item), "part");
+	FilterPart *part = gtk_object_get_data(GTK_OBJECT(item), "part");
 	FilterPart *newpart;
-	
+
 	/* dont update if we haven't changed */
-	if (!strcmp (part->title, data->part->title))
+	if (!strcmp(part->title, data->part->title))
 		return;
-	
+
 	/* here we do a widget shuffle, throw away the old widget/rulepart,
 	   and create another */
 	if (data->partwidget)
-		gtk_container_remove (GTK_CONTAINER (data->container), data->partwidget);
-	newpart = filter_part_clone (part);
-	filter_rule_replace_part (data->fr, data->part, newpart);
-	gtk_object_unref (GTK_OBJECT (data->part));
+		gtk_container_remove(GTK_CONTAINER(data->container), data->partwidget);
+	newpart = filter_part_clone(part);
+	filter_rule_replace_part(data->fr, data->part, newpart);
+	gtk_object_unref(GTK_OBJECT(data->part));
 	data->part = newpart;
-	data->partwidget = filter_part_get_widget (newpart);
+	data->partwidget = filter_part_get_widget(newpart);
 	if (data->partwidget)
-		gtk_box_pack_start (GTK_BOX (data->container), data->partwidget, FALSE, FALSE, 0);
+		gtk_box_pack_start(GTK_BOX(data->container), data->partwidget, FALSE, FALSE, 0);
 }
 
 static GtkWidget *
-get_rule_part_widget (RuleContext *f, FilterPart *newpart, FilterRule *fr)
+get_rule_part_widget(RuleContext * f, FilterPart * newpart, FilterRule * fr)
 {
 	FilterPart *part = NULL;
 	GtkWidget *menu;
@@ -376,48 +366,48 @@ get_rule_part_widget (RuleContext *f, FilterPart *newpart, FilterRule *fr)
 	int index = 0, current = 0;
 	struct _part_data *data;
 	gchar *s;
-	
-	data = g_malloc0 (sizeof (*data));
+
+	data = g_malloc0(sizeof(*data));
 	data->fr = fr;
 	data->f = f;
 	data->part = newpart;
-	
-	hbox = gtk_hbox_new (FALSE, 0);
+
+	hbox = gtk_hbox_new(FALSE, 0);
 	/* only set to automatically clean up the memory */
-	gtk_object_set_data_full (GTK_OBJECT (hbox), "data", data, g_free);
-	
-	p = filter_part_get_widget (newpart);
-	
+	gtk_object_set_data_full(GTK_OBJECT(hbox), "data", data, g_free);
+
+	p = filter_part_get_widget(newpart);
+
 	data->partwidget = p;
 	data->container = hbox;
-	
-	menu = gtk_menu_new ();
+
+	menu = gtk_menu_new();
 	/* sigh, this is a little ugly */
-	while ((part = rule_context_next_part (f, part))) {
-		s = e_utf8_to_gtk_string (menu, part->title);
-		item = gtk_menu_item_new_with_label (s);
-		g_free (s);
-		gtk_object_set_data (GTK_OBJECT (item), "part", part);
-		gtk_signal_connect (GTK_OBJECT (item), "activate", option_activate, data);
-		gtk_menu_append (GTK_MENU (menu), item);
-		gtk_widget_show (item);
-		if (!strcmp (newpart->title, part->title)) {
+	while ((part = rule_context_next_part(f, part))) {
+		s = e_utf8_to_gtk_string(menu, part->title);
+		item = gtk_menu_item_new_with_label(s);
+		g_free(s);
+		gtk_object_set_data(GTK_OBJECT(item), "part", part);
+		gtk_signal_connect(GTK_OBJECT(item), "activate", option_activate, data);
+		gtk_menu_append(GTK_MENU(menu), item);
+		gtk_widget_show(item);
+		if (!strcmp(newpart->title, part->title)) {
 			current = index;
 		}
 		index++;
 	}
-	
-	omenu = gtk_option_menu_new ();
-	gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
-	gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), current);
-	gtk_widget_show (omenu);
-	
-	gtk_box_pack_start (GTK_BOX (hbox), omenu, FALSE, FALSE, 0);
+
+	omenu = gtk_option_menu_new();
+	gtk_option_menu_set_menu(GTK_OPTION_MENU(omenu), menu);
+	gtk_option_menu_set_history(GTK_OPTION_MENU(omenu), current);
+	gtk_widget_show(omenu);
+
+	gtk_box_pack_start(GTK_BOX(hbox), omenu, FALSE, FALSE, 0);
 	if (p) {
-		gtk_box_pack_start (GTK_BOX (hbox), p, FALSE, FALSE, 0);
+		gtk_box_pack_start(GTK_BOX(hbox), p, FALSE, FALSE, 0);
 	}
-	gtk_widget_show_all (hbox);
-	
+	gtk_widget_show_all(hbox);
+
 	return hbox;
 }
 
@@ -428,59 +418,59 @@ struct _rule_data {
 };
 
 static void
-less_parts (GtkWidget *button, struct _rule_data *data)
+less_parts(GtkWidget * button, struct _rule_data *data)
 {
 	GList *l;
 	FilterPart *part;
 	GtkWidget *w;
-	
+
 	l = data->fr->parts;
-	if (g_list_length (l) < 2)
+	if (g_list_length(l) < 2)
 		return;
-	
+
 	/* remove the last one from the list */
-	l = g_list_last (l);
+	l = g_list_last(l);
 	part = l->data;
-	filter_rule_remove_part (data->fr, part);
-	gtk_object_unref ((GtkObject *)part);
-	
+	filter_rule_remove_part(data->fr, part);
+	gtk_object_unref((GtkObject *) part);
+
 	/* and from the display */
-	l = g_list_last (GTK_BOX(data->parts)->children);
-	w = ((GtkBoxChild *)l->data)->widget;
-	gtk_container_remove (GTK_CONTAINER (data->parts), w);
+	l = g_list_last(GTK_BOX(data->parts)->children);
+	w = ((GtkBoxChild *) l->data)->widget;
+	gtk_container_remove(GTK_CONTAINER(data->parts), w);
 }
 
 static void
-more_parts (GtkWidget *button, struct _rule_data *data)
+more_parts(GtkWidget * button, struct _rule_data *data)
 {
 	FilterPart *new;
 	GtkWidget *w;
-	
+
 	/* create a new rule entry, use the first type of rule */
-	new = rule_context_next_part (data->f, NULL);
+	new = rule_context_next_part(data->f, NULL);
 	if (new) {
-		new = filter_part_clone (new);
-		filter_rule_add_part (data->fr, new);
-		w = get_rule_part_widget (data->f, new, data->fr);
-		gtk_box_pack_start (GTK_BOX (data->parts), w, FALSE, FALSE, 0);
+		new = filter_part_clone(new);
+		filter_rule_add_part(data->fr, new);
+		w = get_rule_part_widget(data->f, new, data->fr);
+		gtk_box_pack_start(GTK_BOX(data->parts), w, FALSE, FALSE, 0);
 	}
 }
 
 static void
-name_changed (GtkEntry *entry, FilterRule *fr)
+name_changed(GtkEntry * entry, FilterRule * fr)
 {
-	g_free (fr->name);
-	fr->name = e_utf8_gtk_entry_get_text (entry);
+	g_free(fr->name);
+	fr->name = e_utf8_gtk_entry_get_text(entry);
 }
 
 GtkWidget *
-filter_rule_get_widget (FilterRule *fr, struct _RuleContext *f)
+filter_rule_get_widget(FilterRule * fr, struct _RuleContext *f)
 {
-	return ((FilterRuleClass *)((GtkObject *)fr)->klass)->get_widget (fr, f);
+	return ((FilterRuleClass *) ((GtkObject *) fr)->klass)->get_widget(fr, f);
 }
 
 static GtkWidget *
-get_widget (FilterRule *fr, struct _RuleContext *f)
+get_widget(FilterRule * fr, struct _RuleContext *f)
 {
 	GtkWidget *vbox, *parts, *inframe;
 	GtkWidget *hbox;
@@ -496,139 +486,149 @@ get_widget (FilterRule *fr, struct _RuleContext *f)
 	FilterPart *part;
 	char *string;
 	struct _rule_data *data;
-	
+
 	/* this stuff should probably be a table, but the
 	   rule parts need to be a vbox */
-	vbox = gtk_vbox_new (FALSE, 3);
-	
-	label = gtk_label_new (_("Rule name: "));
-	name = gtk_entry_new ();
-	
+	vbox = gtk_vbox_new(FALSE, 3);
+
+	label = gtk_label_new(_("Rule name: "));
+	name = gtk_entry_new();
+
 	if (!fr->name)
-		fr->name = g_strdup (_("untitled"));
-	
+		fr->name = g_strdup(_("untitled"));
+
 	if (fr->name)
-		e_utf8_gtk_entry_set_text (GTK_ENTRY (name), fr->name);
-	
-	hbox = gtk_hbox_new (FALSE, 3);
-	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
-	gtk_box_pack_start (GTK_BOX (hbox), name, TRUE, TRUE, 0);
-	gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 3);
-	gtk_signal_connect (GTK_OBJECT (name), "changed", name_changed, fr);
-	
-	frame = gtk_frame_new (_("If"));
-	inframe = gtk_vbox_new (FALSE, 3);
-	gtk_container_add (GTK_CONTAINER (frame), inframe);
-	
+		e_utf8_gtk_entry_set_text(GTK_ENTRY(name), fr->name);
+
+	hbox = gtk_hbox_new(FALSE, 3);
+	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+	gtk_box_pack_start(GTK_BOX(hbox), name, TRUE, TRUE, 0);
+	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
+	gtk_signal_connect(GTK_OBJECT(name), "changed", name_changed, fr);
+
+	frame = gtk_frame_new(_("If"));
+	inframe = gtk_vbox_new(FALSE, 3);
+	gtk_container_add(GTK_CONTAINER(frame), inframe);
+
 	/* this is the parts list, it should probably be inside a scrolling list */
-	parts = gtk_vbox_new (FALSE, 3);
-	
+	parts = gtk_vbox_new(FALSE, 3);
+
 	/* data for the parts part of the display */
-	data = g_malloc0 (sizeof (*data));
+	data = g_malloc0(sizeof(*data));
 	data->f = f;
 	data->fr = fr;
 	data->parts = parts;
-	
+
 	/* only set to automatically clean up the memory */
-	gtk_object_set_data_full (GTK_OBJECT (vbox), "data", data, g_free);
-	
-	hbox = gtk_hbox_new (FALSE, 3);
-	label = gtk_label_new (_("Execute actions"));
-	
-	menu = gtk_menu_new ();
-	
-	string = e_utf8_to_gtk_string (menu, _("if all criteria are met"));
-	item = gtk_menu_item_new_with_label (string);
-	g_free (string);
-	gtk_signal_connect (GTK_OBJECT (item), "activate", match_all, fr);
-	gtk_menu_append (GTK_MENU (menu), item);
-	gtk_widget_show (item);
-	
-	string = e_utf8_to_gtk_string (menu, _("if any criteria are met"));
-	item = gtk_menu_item_new_with_label (string);
-	g_free (string);
-	gtk_signal_connect (GTK_OBJECT (item), "activate", match_any, fr);
-	gtk_menu_append (GTK_MENU (menu), item);
-	gtk_widget_show (item);
-	
-	omenu = gtk_option_menu_new ();
-	gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
-	gtk_option_menu_set_history (GTK_OPTION_MENU (omenu),
-				     fr->grouping == FILTER_GROUP_ALL ? 0 : 1);
-	gtk_widget_show (omenu);
-	
-	pixmap = gnome_stock_new_with_icon (GNOME_STOCK_PIXMAP_ADD);
-	button = gnome_pixmap_button (pixmap, _("Add criterion"));
-	gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
-	gtk_signal_connect (GTK_OBJECT (button), "clicked", more_parts, data);
-	gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 3);
-	
-	pixmap = gnome_stock_new_with_icon (GNOME_STOCK_PIXMAP_REMOVE);
-	button = gnome_pixmap_button (pixmap, _("Remove criterion"));
-	gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
-	gtk_signal_connect (GTK_OBJECT (button), "clicked", less_parts, data);
-	gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 3);
-	
-	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
-	gtk_box_pack_start (GTK_BOX (hbox), omenu, FALSE, FALSE, 0);
-	
-	gtk_box_pack_start (GTK_BOX (inframe), hbox, FALSE, FALSE, 3);
-	
+	gtk_object_set_data_full(GTK_OBJECT(vbox), "data", data, g_free);
+
+	hbox = gtk_hbox_new(FALSE, 3);
+	label = gtk_label_new(_("Execute actions"));
+
+	menu = gtk_menu_new();
+
+	string = e_utf8_to_gtk_string(menu, _("if all criteria are met"));
+	item = gtk_menu_item_new_with_label(string);
+	g_free(string);
+	gtk_signal_connect(GTK_OBJECT(item), "activate", match_all, fr);
+	gtk_menu_append(GTK_MENU(menu), item);
+	gtk_widget_show(item);
+
+	string = e_utf8_to_gtk_string(menu, _("if any criteria are met"));
+	item = gtk_menu_item_new_with_label(string);
+	g_free(string);
+	gtk_signal_connect(GTK_OBJECT(item), "activate", match_any, fr);
+	gtk_menu_append(GTK_MENU(menu), item);
+	gtk_widget_show(item);
+
+	omenu = gtk_option_menu_new();
+	gtk_option_menu_set_menu(GTK_OPTION_MENU(omenu), menu);
+	gtk_option_menu_set_history(GTK_OPTION_MENU(omenu), fr->grouping == FILTER_GROUP_ALL ? 0 : 1);
+	gtk_widget_show(omenu);
+
+	pixmap = gnome_stock_new_with_icon(GNOME_STOCK_PIXMAP_ADD);
+	button = gnome_pixmap_button(pixmap, _("More criterion"));
+	gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
+	gtk_signal_connect(GTK_OBJECT(button), "clicked", more_parts, data);
+	gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 3);
+
+	pixmap = gnome_stock_new_with_icon(GNOME_STOCK_PIXMAP_REMOVE);
+	button = gnome_pixmap_button(pixmap, _("Fewer criterion"));
+	gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
+	gtk_signal_connect(GTK_OBJECT(button), "clicked", less_parts, data);
+	gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 3);
+
+	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+	gtk_box_pack_start(GTK_BOX(hbox), omenu, FALSE, FALSE, 0);
+
+	gtk_box_pack_start(GTK_BOX(inframe), hbox, FALSE, FALSE, 3);
+
 	l = fr->parts;
 	while (l) {
 		part = l->data;
-		w = get_rule_part_widget (f, part, fr);
-		gtk_box_pack_start (GTK_BOX (parts), w, FALSE, FALSE, 3);
-		l = g_list_next (l);
+		w = get_rule_part_widget(f, part, fr);
+		gtk_box_pack_start(GTK_BOX(parts), w, FALSE, FALSE, 3);
+		l = g_list_next(l);
 	}
-	
-	hadj = gtk_adjustment_new (0.0, 0.0, 1.0, 1.0 ,1.0, 1.0);
-	vadj = gtk_adjustment_new (0.0, 0.0, 1.0, 1.0 ,1.0, 1.0);
-	scrolledwindow = gtk_scrolled_window_new (GTK_ADJUSTMENT (hadj), GTK_ADJUSTMENT (vadj));
-	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
-                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
-	
-	gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolledwindow), parts);
-	
-	gtk_box_pack_start (GTK_BOX (inframe), scrolledwindow, FALSE, FALSE, 3);
-	
-	/*gtk_box_pack_start (GTK_BOX (inframe), parts, FALSE, FALSE, 3);*/
-	
-	gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 3);
-	
-	gtk_widget_show_all (vbox);
-	
+
+	hadj = gtk_adjustment_new(0.0, 0.0, 1.0, 1.0, 1.0, 1.0);
+	vadj = gtk_adjustment_new(0.0, 0.0, 1.0, 1.0, 1.0, 1.0);
+	scrolledwindow = gtk_scrolled_window_new(GTK_ADJUSTMENT(hadj), GTK_ADJUSTMENT(vadj));
+	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+
+	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolledwindow), parts);
+
+	gtk_box_pack_start(GTK_BOX(inframe), scrolledwindow, FALSE, FALSE, 3);
+
+	/*gtk_box_pack_start (GTK_BOX (inframe), parts, FALSE, FALSE, 3); */
+
+	gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 3);
+
+	gtk_widget_show_all(vbox);
+
 	return vbox;
 }
 
 FilterRule *
-filter_rule_next_list (GList *l, FilterRule *last)
+filter_rule_next_list(GList * l, FilterRule * last, const char *source)
 {
 	GList *node = l;
-	
+
 	if (last != NULL) {
-		node = g_list_find (node, last);
+		node = g_list_find(node, last);
 		if (node == NULL)
 			node = l;
 		else
-			node = g_list_next (node);
+			node = g_list_next(node);
+	}
+
+	if (source) {
+		while (node) {
+			FilterRule *rule = node->data;
+
+			if (rule->source && strcmp(rule->source, source) == 0)
+				break;
+			node = g_list_next(node);
+		}
 	}
-	
+
 	if (node)
 		return node->data;
-	
+
 	return NULL;
 }
 
 FilterRule *
-filter_rule_find_list (GList *l, const char *name)
+filter_rule_find_list(GList * l, const char *name, const char *source)
 {
 	while (l) {
 		FilterRule *rule = l->data;
-		if (!strcmp (rule->name, name))
-			return rule;
-		l = g_list_next (l);
+
+		if (strcmp(rule->name, name) == 0)
+			if (source == NULL || (rule->source != NULL && strcmp(rule->source, source) == 0))
+				return rule;
+		l = g_list_next(l);
 	}
-	
+
 	return NULL;
 }