If filter inbox is set on the store, and we're opening inbox '', then

2001-09-18    <NotZed@Ximian.com>

	* providers/local/camel-maildir-folder.c
	(camel_maildir_folder_new): If filter inbox is set on the store,
	and we're opening inbox '', then enable filtering on new messages.

	* providers/local/camel-local-folder.c
	(camel_local_folder_construct): After loading the summary, check
	it, and only abort if that fails.  Also maintain the changes
	count.

	* providers/local/camel-local-summary.c
	(camel_local_summary_load): Remove summary_check code from here.
	(camel_local_summary_check): Sync index/summary here, if we were
	successful.

	* providers/local/camel-spool-folder.c
	(camel_spool_folder_new): If we have filter-new-messages-on-inbox
	set and we just opened inbox, turn on filtering on this folder.
	(camel_spool_folder_construct): Keep track of changes for the
	folder, so that filter-new-messages works right (?)

	* providers/local/camel-spool-store.c (get_folder): Pass 'INBOX'
	as the folder name, not the path.

	* camel-folder-search.c (search_not): Modified patch from
	<peterw@ximian.com> since the summary is messageinfo's, not
	strings.

	** Ok so the problem with the stuff below is that maildir/spool
	'summary_load' throws away all events, including recents, joy eh?

	* providers/local/camel-maildir-summary.c (maildir_summary_check):
	Add new messages to the recent changeinfo.

	* providers/local/camel-spool-summary.c: Mark 'new' message as
	recent, for later processing if required (i.e. 'filter new
	messages').

	* camel-store.c (construct): new function, cascade up construct
	method and check for 'filter' param, and set accordingly for any
	one that might want it.

	* providers/imap/camel-imap-store.c (construct): map the
	param_filter_inbox flag to the store->flags as
	CAMEL_STORE_FILTER_INBOX.

	* camel-store.h (CAMEL_STORE_FILTER_INBOX): new flag to tell it to
	filter inbox.

	* providers/imap/camel-imap-folder.h: Removed do_filtering flag
	from CamelImapFolder.

	* providers/imap/camel-imap-folder.c (imap_update_summary): Remove
	the 'recents' parameter, use the 'changes' parameter instead to
	convey this info.
	(camel_imap_folder_changed): Changed for update_summary api
	change.  Now always just emit the changed event if we have any
	changes to report, filtering code removed, handled upstream.
	(filter_proc):
	(filter_free): Removed old filtering code.
	(camel_imap_folder_new): Set the filter_recent flag on the folder
	if we're the inbox and filtering of inbox is enabled.

	* camel-folder.c (folder_changed): If we have 'recent' messages,
	and are set to filter recents, then freeze the folder and launch a
	thread to do the processing (or similar if threading not enabled).
	(thaw): Make sure we emit the changed signal outside of owning the
	lock and if things have changed.  Also, no longer bother
	downgrading folder_changed events to message_changed events.

	* camel-folder.h (struct _CamelFolder): Added filter_recent flag
	-> signifies all recent messages in folder should be filtered.

	* camel-session.c: (camel_session_thread_msg_new,
	camel_session_thread_msg_free, camel_session_thread_queue,
	camel_session_thread_wait): code to handle async operations as
	part of camel processing.
	(camel_session_finalise): free thread_lock, destroy thread, active
	hash, etc.
	(camel_session_init): init thread, active hash, etc.
	(camel_session_class_init): Init virtual functions.
	(session_thread_msg_new, session_thread_msg_free,
	session_thread_destroy, session_thread_received,
	session_thread_queue, session_thread_wait): default implementation
	of session threads stuff.

2001-09-17    <NotZed@Ximian.com>

	* camel-folder.c (camel_folder_change_info_recent_uid): New
	function to add a 'recent' uid to the change info.
	(camel_folder_change_info_clear): Clear recent list.
	(camel_folder_change_info_free): Free recent list.
	(camel_folder_change_info_new): Setup recent list.

	* camel-folder.h: Added a uid_recent item to the folder_changed
	event data.

	* providers/local/camel-maildir-store.c (scan_dir): Free new in
	the right block.

	* providers/local/camel-local-provider.c: Add local config entries
	to filter on new messages in spool and maildir provider.

	* camel-vee-folder.c (vee_folder_construct): Remove the assertion
	which stops ? in names from being allowed.

svn path=/trunk/; revision=12956

24 files changed, 544 insertions, 146 deletions

diff --git a/camel/ChangeLog b/camel/ChangeLog
index 18bf3b6dac..89b8afddc8 100644
--- a/camel/ChangeLog
+++ b/camel/ChangeLog
@@ -1,3 +1,110 @@
+2001-09-18    <NotZed@Ximian.com>
+
+	* providers/local/camel-maildir-folder.c
+	(camel_maildir_folder_new): If filter inbox is set on the store,
+	and we're opening inbox '', then enable filtering on new messages.
+
+	* providers/local/camel-local-folder.c
+	(camel_local_folder_construct): After loading the summary, check
+	it, and only abort if that fails.  Also maintain the changes
+	count.
+
+	* providers/local/camel-local-summary.c
+	(camel_local_summary_load): Remove summary_check code from here.
+	(camel_local_summary_check): Sync index/summary here, if we were
+	successful.
+
+	* providers/local/camel-spool-folder.c
+	(camel_spool_folder_new): If we have filter-new-messages-on-inbox
+	set and we just opened inbox, turn on filtering on this folder.
+	(camel_spool_folder_construct): Keep track of changes for the
+	folder, so that filter-new-messages works right (?)
+
+	* providers/local/camel-spool-store.c (get_folder): Pass 'INBOX'
+	as the folder name, not the path.
+
+	* camel-folder-search.c (search_not): Modified patch from
+	<peterw@ximian.com> since the summary is messageinfo's, not
+	strings.
+
+	** Ok so the problem with the stuff below is that maildir/spool
+	'summary_load' throws away all events, including recents, joy eh?
+	
+	* providers/local/camel-maildir-summary.c (maildir_summary_check):
+	Add new messages to the recent changeinfo.
+
+	* providers/local/camel-spool-summary.c: Mark 'new' message as
+	recent, for later processing if required (i.e. 'filter new
+	messages').
+
+	* camel-store.c (construct): new function, cascade up construct
+	method and check for 'filter' param, and set accordingly for any
+	one that might want it.
+
+	* providers/imap/camel-imap-store.c (construct): map the
+	param_filter_inbox flag to the store->flags as
+	CAMEL_STORE_FILTER_INBOX.
+
+	* camel-store.h (CAMEL_STORE_FILTER_INBOX): new flag to tell it to
+	filter inbox.
+
+	* providers/imap/camel-imap-folder.h: Removed do_filtering flag
+	from CamelImapFolder.
+
+	* providers/imap/camel-imap-folder.c (imap_update_summary): Remove
+	the 'recents' parameter, use the 'changes' parameter instead to
+	convey this info.
+	(camel_imap_folder_changed): Changed for update_summary api
+	change.  Now always just emit the changed event if we have any
+	changes to report, filtering code removed, handled upstream.
+	(filter_proc): 
+	(filter_free): Removed old filtering code.
+	(camel_imap_folder_new): Set the filter_recent flag on the folder
+	if we're the inbox and filtering of inbox is enabled.
+
+	* camel-folder.c (folder_changed): If we have 'recent' messages,
+	and are set to filter recents, then freeze the folder and launch a
+	thread to do the processing (or similar if threading not enabled).
+	(thaw): Make sure we emit the changed signal outside of owning the
+	lock and if things have changed.  Also, no longer bother
+	downgrading folder_changed events to message_changed events.
+
+	* camel-folder.h (struct _CamelFolder): Added filter_recent flag
+	-> signifies all recent messages in folder should be filtered.
+
+	* camel-session.c: (camel_session_thread_msg_new,
+	camel_session_thread_msg_free, camel_session_thread_queue,
+	camel_session_thread_wait): code to handle async operations as
+	part of camel processing.
+	(camel_session_finalise): free thread_lock, destroy thread, active
+	hash, etc.
+	(camel_session_init): init thread, active hash, etc.
+	(camel_session_class_init): Init virtual functions.
+	(session_thread_msg_new, session_thread_msg_free,
+	session_thread_destroy, session_thread_received,
+	session_thread_queue, session_thread_wait): default implementation
+	of session threads stuff.
+
+2001-09-17    <NotZed@Ximian.com>
+
+	* camel-folder.c (camel_folder_change_info_recent_uid): New
+	function to add a 'recent' uid to the change info.
+	(camel_folder_change_info_clear): Clear recent list.
+	(camel_folder_change_info_free): Free recent list.
+	(camel_folder_change_info_new): Setup recent list.
+
+	* camel-folder.h: Added a uid_recent item to the folder_changed
+	event data.
+
+	* providers/local/camel-maildir-store.c (scan_dir): Free new in
+	the right block.
+
+	* providers/local/camel-local-provider.c: Add local config entries
+	to filter on new messages in spool and maildir provider.
+
+	* camel-vee-folder.c (vee_folder_construct): Remove the assertion
+	which stops ? in names from being allowed.
+
 2001-09-18  Dan Winship  <danw@ximian.com>
 
 	* camel-data-wrapper.c (camel_data_wrapper_is_offline): Virtualize
diff --git a/camel/camel-filter-driver.c b/camel/camel-filter-driver.c
index e7a430cdff..c309776790 100644
--- a/camel/camel-filter-driver.c
+++ b/camel/camel-filter-driver.c
@@ -819,7 +819,7 @@ camel_filter_driver_filter_folder (CamelFilterDriver *driver, CamelFolder *folde
 		report_status (driver, CAMEL_FILTER_STATUS_END, 100, _("Complete"));
 	
 	g_free (source_url);
-	
+
 	return status;
 }
 
diff --git a/camel/camel-folder-search.c b/camel/camel-folder-search.c
index 873934b67d..4d644a256a 100644
--- a/camel/camel-folder-search.c
+++ b/camel/camel-folder-search.c
@@ -499,16 +499,19 @@ search_not(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSe
 				/* 'not' against the whole summary */
 				GHashTable *have = g_hash_table_new(g_str_hash, g_str_equal);
 				char **s;
+				CamelMessageInfo **m;
 
 				s = (char **)v->pdata;
 				for (i=0;i<v->len;i++)
 					g_hash_table_insert(have, s[i], s[i]);
 
 				v = search->summary;
-				s = (char **)v->pdata;
+				m = (CamelMessageInfo **)v->pdata;
 				for (i=0;i<v->len;i++) {
-					if (g_hash_table_lookup(have, s[i]) == NULL)
-						g_ptr_array_add(r->value.ptrarray, s[i]);
+					char *uid = (char *)camel_message_info_uid(m[i]);
+
+					if (g_hash_table_lookup(have, uid) == NULL)
+						g_ptr_array_add(r->value.ptrarray, uid);
 				}
 				g_hash_table_destroy(have);
 			}
diff --git a/camel/camel-folder.c b/camel/camel-folder.c
index dc93443c7c..dd76c36673 100644
--- a/camel/camel-folder.c
+++ b/camel/camel-folder.c
@@ -36,6 +36,8 @@
 #include "e-util/e-memory.h"
 #include "camel-operation.h"
 
+#include "camel-session.h"
+#include "camel-filter-driver.h"
 #include "camel-private.h"
 
 #define d(x) 
@@ -1257,7 +1259,7 @@ freeze (CamelFolder *folder)
 
 	folder->priv->frozen++;
 
-	d(printf ("freeze(%p) = %d\n", folder, folder->priv->frozen));
+	d(printf ("freeze(%p '%s') = %d\n", folder, folder->full_name, folder->priv->frozen));
 	CAMEL_FOLDER_UNLOCK(folder, change_lock);
 }
 
@@ -1281,31 +1283,26 @@ camel_folder_freeze (CamelFolder * folder)
 static void
 thaw (CamelFolder * folder)
 {
-	int i;
-	CamelFolderChangeInfo *info;
+	CamelFolderChangeInfo *info = NULL;
 
 	CAMEL_FOLDER_LOCK(folder, change_lock);
 
 	folder->priv->frozen--;
 
-	d(printf ("thaw(%p) = %d\n", folder, folder->priv->frozen));
+	d(printf ("thaw(%p '%s') = %d\n", folder, folder->full_name, folder->priv->frozen));
 
-	if (folder->priv->frozen == 0) {
-		/* If we have more or less messages, do a folder changed, otherwise just
-		   do a message changed for each one.
-		   TODO: message_changed is now probably irrelevant and not required */
+	if (folder->priv->frozen == 0
+	    && camel_folder_change_info_changed(folder->priv->changed_frozen)) {
 		info = folder->priv->changed_frozen;
-		if (info->uid_added->len > 0 || info->uid_removed->len > 0 || info->uid_changed->len > 10) {
-			camel_object_trigger_event(CAMEL_OBJECT(folder), "folder_changed", info);
-		} else if (info->uid_changed->len > 0) {
-			for (i=0;i<info->uid_changed->len;i++) {
-				camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", info->uid_changed->pdata[i]);
-			}
-		}
-		camel_folder_change_info_clear(info);
+		folder->priv->changed_frozen = camel_folder_change_info_new();
 	}
-
+	
 	CAMEL_FOLDER_UNLOCK(folder, change_lock);
+
+	if (info) {
+		camel_object_trigger_event(CAMEL_OBJECT(folder), "folder_changed", info);
+		camel_folder_change_info_free(info);
+	}
 }
 
 /**
@@ -1344,6 +1341,43 @@ camel_folder_is_frozen (CamelFolder *folder)
 	return CF_CLASS (folder)->is_frozen (folder);
 }
 
+#ifdef ENABLE_THREADS
+struct _folder_filter_msg {
+	CamelSessionThreadMsg msg;
+
+	GPtrArray *recents;
+	CamelFolder *folder;
+	CamelFilterDriver *driver;
+	CamelException ex;
+};
+
+static void
+filter_filter(CamelSession *session, CamelSessionThreadMsg *msg)
+{
+	struct _folder_filter_msg *m = (struct _folder_filter_msg *)msg;
+
+	camel_filter_driver_filter_folder(m->driver, m->folder, NULL, m->recents, FALSE, &m->ex);	
+}
+
+static void
+filter_free(CamelSession *session, CamelSessionThreadMsg *msg)
+{
+	struct _folder_filter_msg *m = (struct _folder_filter_msg *)msg;
+	int i;
+
+	camel_folder_thaw(m->folder);
+	camel_object_unref((CamelObject *)m->folder);
+	camel_object_unref((CamelObject *)m->driver);
+	for (i=0;i<m->recents->len;i++)
+		g_free(m->recents->pdata[i]);
+	g_ptr_array_free(m->recents, TRUE);
+}
+
+static CamelSessionThreadOps filter_ops = {
+	filter_filter,
+	filter_free,
+};
+#endif
 
 /* Event hooks that block emission when frozen */
 static gboolean
@@ -1354,18 +1388,56 @@ folder_changed (CamelObject *obj, gpointer event_data)
 	gboolean ret = TRUE;
 
 	d(printf ("folder_changed(%p, %p), frozen=%d\n", obj, event_data, folder->priv->frozen));
+	d(printf(" added %d remoded %d changed %d recent %d\n",
+		 changed->uid_added->len, changed->uid_removed->len,
+		 changed->uid_changed->len, changed->uid_recent->len));
 
-	if (folder->priv->frozen) {
-		CAMEL_FOLDER_LOCK(folder, change_lock);
+	if (changed != NULL) {
+		CamelSession *session = ((CamelService *)folder->parent_store)->session;
+		CamelFilterDriver *driver;
 
-		if (changed != NULL)
+		CAMEL_FOLDER_LOCK(folder, change_lock);
+		if (folder->filter_recent
+		    && changed->uid_recent->len>0
+		    && (driver = camel_session_get_filter_driver(session, "incoming", NULL))) {
+#ifdef ENABLE_THREADS
+			GPtrArray *recents = g_ptr_array_new();
+			int i;
+			struct _folder_filter_msg *msg;
+
+			(printf("** Have '%d' recent messages, launching thread to process them\n", changed->uid_recent->len));
+			
+			folder->priv->frozen++;
+			msg = camel_session_thread_msg_new(session, &filter_ops, sizeof(*msg));
+			for (i=0;i<changed->uid_recent->len;i++)
+				g_ptr_array_add(recents, g_strdup(changed->uid_recent->pdata[i]));
+			msg->recents = recents;
+			msg->folder = folder;
+			camel_object_ref((CamelObject *)folder);
+			msg->driver = driver;
+			camel_exception_init(&msg->ex);
+			camel_session_thread_queue(session, &msg->msg, 0);
+#else
+			d(printf("Have '%d' recent messages, filtering\n", changed->recent->len));
+			folder->priv->frozen++;
+			camel_filter_driver_filter_folder(driver, folder, NULL, changed->recent, FALSE, NULL);
+			camel_object_unref((CamelObject *)driver);
+			folder->priv->frozen--;
+#endif
+			/* zero out the recent list so we dont reprocess */
+			/* this pokes past abstraction, but changeinfo is our structure anyway */
+			/* the only other alternative is to recognise when trigger is called from	
+			   thaw(), but thats a pita */
+			g_ptr_array_set_size(changed->uid_recent, 0);
+		}
+		if (folder->priv->frozen) {
 			camel_folder_change_info_cat(folder->priv->changed_frozen, changed);
-		else
+			ret = FALSE;
+		}
+		CAMEL_FOLDER_UNLOCK(folder, change_lock);
+	} else {
 			g_warning("Class %s is passing NULL to folder_changed event",
 				  camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
-		ret = FALSE;
-
-		CAMEL_FOLDER_UNLOCK(folder, change_lock);
 	}
 
 	return ret;
@@ -1468,6 +1540,7 @@ camel_folder_change_info_new(void)
 	info->uid_added = g_ptr_array_new();
 	info->uid_removed = g_ptr_array_new();
 	info->uid_changed = g_ptr_array_new();
+	info->uid_recent = g_ptr_array_new();
 	info->priv = g_malloc0(sizeof(*info->priv));
 	info->priv->uid_stored = g_hash_table_new(g_str_hash, g_str_equal);
 	info->priv->uid_source = NULL;
@@ -1648,6 +1721,7 @@ camel_folder_change_info_cat(CamelFolderChangeInfo *info, CamelFolderChangeInfo
 	change_info_cat(info, source->uid_added, camel_folder_change_info_add_uid);
 	change_info_cat(info, source->uid_removed, camel_folder_change_info_remove_uid);
 	change_info_cat(info, source->uid_changed, camel_folder_change_info_change_uid);
+	change_info_cat(info, source->uid_recent, camel_folder_change_info_recent_uid);
 }
 
 /**
@@ -1745,6 +1819,24 @@ camel_folder_change_info_change_uid(CamelFolderChangeInfo *info, const char *uid
 	g_hash_table_insert(p->uid_stored, olduid, info->uid_changed);
 }
 
+void
+camel_folder_change_info_recent_uid(CamelFolderChangeInfo *info, const char *uid)
+{
+	struct _CamelFolderChangeInfoPrivate *p;
+	GPtrArray *olduids;
+	char *olduid;
+	
+	g_assert(info != NULL);
+	
+	p = info->priv;
+
+	/* always add to recent, but dont let anyone else know */	
+	if (!g_hash_table_lookup_extended(p->uid_stored, uid, (void **)&olduid, (void **)&olduids)) {
+		olduid = e_mempool_strdup(p->uid_pool, uid);
+	}
+	g_ptr_array_add(info->uid_recent, olduid);
+}
+
 /**
  * camel_folder_change_info_changed:
  * @info: 
@@ -1758,7 +1850,7 @@ camel_folder_change_info_changed(CamelFolderChangeInfo *info)
 {
 	g_assert(info != NULL);
 	
-	return (info->uid_added->len || info->uid_removed->len || info->uid_changed->len);
+	return (info->uid_added->len || info->uid_removed->len || info->uid_changed->len || info->uid_recent->len);
 }
 
 /**
@@ -1779,6 +1871,7 @@ camel_folder_change_info_clear(CamelFolderChangeInfo *info)
 	g_ptr_array_set_size(info->uid_added, 0);
 	g_ptr_array_set_size(info->uid_removed, 0);
 	g_ptr_array_set_size(info->uid_changed, 0);
+	g_ptr_array_set_size(info->uid_recent, 0);
 	if (p->uid_source) {
 		g_hash_table_destroy(p->uid_source);
 		p->uid_source = NULL;
@@ -1813,5 +1906,6 @@ camel_folder_change_info_free(CamelFolderChangeInfo *info)
 	g_ptr_array_free(info->uid_added, TRUE);
 	g_ptr_array_free(info->uid_removed, TRUE);
 	g_ptr_array_free(info->uid_changed, TRUE);
+	g_ptr_array_free(info->uid_recent, TRUE);
 	g_free(info);
 }
diff --git a/camel/camel-folder.h b/camel/camel-folder.h
index af86a9c5ed..0ff542afb9 100644
--- a/camel/camel-folder.h
+++ b/camel/camel-folder.h
@@ -47,6 +47,7 @@ struct _CamelFolderChangeInfo {
 	GPtrArray *uid_added;
 	GPtrArray *uid_removed;
 	GPtrArray *uid_changed;
+	GPtrArray *uid_recent;
 
 	struct _CamelFolderChangeInfoPrivate *priv;
 };
@@ -65,6 +66,7 @@ struct _CamelFolder
 	guint32 permanent_flags;
 	gboolean has_summary_capability:1;
 	gboolean has_search_capability:1;
+	gboolean filter_recent:1;
 
 };
 
@@ -301,6 +303,7 @@ void			camel_folder_change_info_cat		(CamelFolderChangeInfo *info, CamelFolderCh
 void			camel_folder_change_info_add_uid	(CamelFolderChangeInfo *info, const char *uid);
 void			camel_folder_change_info_remove_uid	(CamelFolderChangeInfo *info, const char *uid);
 void			camel_folder_change_info_change_uid	(CamelFolderChangeInfo *info, const char *uid);
+void			camel_folder_change_info_recent_uid	(CamelFolderChangeInfo *info, const char *uid);
 
 #ifdef __cplusplus
 }
diff --git a/camel/camel-private.h b/camel/camel-private.h
index 4fb5bdb461..34f393b00f 100644
--- a/camel/camel-private.h
+++ b/camel/camel-private.h
@@ -104,6 +104,11 @@ struct _CamelServicePrivate {
 struct _CamelSessionPrivate {
 #ifdef ENABLE_THREADS
 	GMutex *lock;		/* for locking everything basically */
+	GMutex *thread_lock;	/* locking threads */
+
+	int thread_id;
+	GHashTable *thread_active;
+	EThread *thread_queue;
 #endif
 };
 
diff --git a/camel/camel-session.c b/camel/camel-session.c
index a6e70bcd98..06b7bb8799 100644
--- a/camel/camel-session.c
+++ b/camel/camel-session.c
@@ -61,6 +61,12 @@ static char *get_storage_path (CamelSession *session,
 			       CamelService *service,
 			       CamelException *ex);
 
+#ifdef ENABLE_THREADS
+static void *session_thread_msg_new(CamelSession *session, CamelSessionThreadOps *ops, unsigned int size);
+static void session_thread_msg_free(CamelSession *session, CamelSessionThreadMsg *msg);
+static int session_thread_queue(CamelSession *session, CamelSessionThreadMsg *msg, int flags);
+static void session_thread_wait(CamelSession *session, int id);
+#endif
 
 /* The vfolder provider is always avilable */
 static CamelProvider vee_provider = {
@@ -87,6 +93,10 @@ camel_session_init (CamelSession *session)
 	session->priv = g_malloc0(sizeof(*session->priv));
 #ifdef ENABLE_THREADS
 	session->priv->lock = g_mutex_new();
+	session->priv->thread_lock = g_mutex_new();
+	session->priv->thread_id = 1;
+	session->priv->thread_active = g_hash_table_new(NULL, NULL);
+	session->priv->thread_queue = NULL;
 #endif	
 }
 
@@ -105,6 +115,12 @@ camel_session_finalise (CamelObject *o)
 {
 	CamelSession *session = (CamelSession *)o;
 
+#ifdef ENABLE_THREADS
+	g_hash_table_destroy(session->priv->thread_active);
+	if (session->priv->thread_queue)
+		e_thread_destroy(session->priv->thread_queue);
+#endif
+
 	g_free(session->storage_path);
 	g_hash_table_foreach_remove (session->providers,
 				     camel_session_destroy_provider, NULL);
@@ -112,8 +128,8 @@ camel_session_finalise (CamelObject *o)
 
 #ifdef ENABLE_THREADS
 	g_mutex_free(session->priv->lock);
-#endif	
-
+	g_mutex_free(session->priv->thread_lock);
+#endif
 	g_free(session->priv);
 }
 
@@ -127,6 +143,13 @@ camel_session_class_init (CamelSessionClass *camel_session_class)
 	camel_session_class->get_service = get_service;
 	camel_session_class->get_storage_path = get_storage_path;
 
+#ifdef ENABLE_THREADS
+	camel_session_class->thread_msg_new = session_thread_msg_new;
+	camel_session_class->thread_msg_free = session_thread_msg_free;
+	camel_session_class->thread_queue = session_thread_queue;
+	camel_session_class->thread_wait = session_thread_wait;
+#endif
+
 	if (vee_provider.service_cache == NULL) {
 		vee_provider.object_types[CAMEL_PROVIDER_STORE] = camel_vee_store_get_type ();
 		vee_provider.service_cache = g_hash_table_new (camel_url_hash, camel_url_equal);
@@ -686,3 +709,162 @@ camel_session_get_filter_driver (CamelSession *session,
 {
 	return CS_CLASS (session)->get_filter_driver (session, type, ex);
 }
+
+#ifdef ENABLE_THREADS
+
+static void *session_thread_msg_new(CamelSession *session, CamelSessionThreadOps *ops, unsigned int size)
+{
+	CamelSessionThreadMsg *m;
+
+	g_assert(size >= sizeof(*m));
+
+	m = g_malloc0(size);
+	m->ops = ops;
+
+	CAMEL_SESSION_LOCK(session, thread_lock);
+	m->id = session->priv->thread_id++;
+	g_hash_table_insert(session->priv->thread_active, (void *)m->id, m);
+	CAMEL_SESSION_UNLOCK(session, thread_lock);
+
+	return m;
+}
+
+static void session_thread_msg_free(CamelSession *session, CamelSessionThreadMsg *msg)
+{
+	g_assert(msg->ops != NULL);
+
+	printf("free message %p session %p\n", msg, session);
+
+	CAMEL_SESSION_LOCK(session, thread_lock);
+	g_hash_table_remove(session->priv->thread_active, (void *)msg->id);
+	CAMEL_SESSION_UNLOCK(session, thread_lock);
+
+	printf("free msg, ops->free = %p\n", msg->ops->free);
+
+	if (msg->ops->free)
+		msg->ops->free(session, msg);
+	g_free(msg);
+}
+
+static void session_thread_destroy(EThread *thread, CamelSessionThreadMsg *msg, CamelSession *session)
+{
+	printf("destroy message %p session %p\n", msg, session);
+	session_thread_msg_free(session, msg);
+}
+
+static void session_thread_received(EThread *thread, CamelSessionThreadMsg *msg, CamelSession *session)
+{
+	printf("receive message %p session %p\n", msg, session);
+	if (msg->ops->receive)
+		msg->ops->receive(session, msg);
+}
+
+static int session_thread_queue(CamelSession *session, CamelSessionThreadMsg *msg, int flags)
+{
+	int id;
+
+	CAMEL_SESSION_LOCK(session, thread_lock);
+	if (session->priv->thread_queue == NULL) {
+		session->priv->thread_queue = e_thread_new(E_THREAD_QUEUE);
+		e_thread_set_msg_destroy(session->priv->thread_queue, (EThreadFunc)session_thread_destroy, session);
+		e_thread_set_msg_received(session->priv->thread_queue, (EThreadFunc)session_thread_received, session);
+	}
+	CAMEL_SESSION_UNLOCK(session, thread_lock);
+
+	id = msg->id;
+	e_thread_put(session->priv->thread_queue, &msg->msg);
+
+	return id;
+}
+
+static void session_thread_wait(CamelSession *session, int id)
+{
+	int wait;
+
+	/* we just busy wait, only other alternative is to setup a reply port? */
+	do {
+		CAMEL_SESSION_LOCK(session, thread_lock);
+		wait = g_hash_table_lookup(session->priv->thread_active, (void *)id) != NULL;
+		CAMEL_SESSION_UNLOCK(session, thread_lock);
+		if (wait) {
+			usleep(20000);
+		}
+	} while (wait);
+}
+
+/**
+ * camel_session_thread_msg_new:
+ * @session: 
+ * @ops: 
+ * @size: 
+ * 
+ * Create a new thread message, using ops as the receive/reply/free
+ * ops, of @size bytes.
+ *
+ * @ops points to the operations used to recieve/process and finally
+ * free the message.
+ **/
+void *camel_session_thread_msg_new(CamelSession *session, CamelSessionThreadOps *ops, unsigned int size)
+{
+	g_assert(CAMEL_IS_SESSION(session));
+	g_assert(ops != NULL);
+	g_assert(size >= sizeof(CamelSessionThreadMsg));
+		 
+	return CS_CLASS (session)->thread_msg_new(session, ops, size);
+}
+
+/**
+ * camel_session_thread_msg_free:
+ * @session: 
+ * @msg: 
+ * 
+ * Free a @msg.  Note that the message must have been allocated using
+ * msg_new, and must nto have been submitted to any queue function.
+ **/
+void camel_session_thread_msg_free(CamelSession *session, CamelSessionThreadMsg *msg)
+{
+	g_assert(CAMEL_IS_SESSION(session));
+	g_assert(msg != NULL);
+	g_assert(msg->ops != NULL);
+
+	return CS_CLASS (session)->thread_msg_free(session, msg);
+}
+
+/**
+ * camel_session_thread_queue:
+ * @session: 
+ * @msg: 
+ * @flags: queue type flags, currently 0.
+ * 
+ * Queue a thread message in another thread for processing.
+ * The operation should be (but needn't) run in a queued manner
+ * with other operations queued in this manner.
+ * 
+ * Return value: The id of the operation queued.
+ **/
+int camel_session_thread_queue(CamelSession *session, CamelSessionThreadMsg *msg, int flags)
+{
+	g_assert(CAMEL_IS_SESSION(session));
+	g_assert(msg != NULL);
+
+	return CS_CLASS (session)->thread_queue(session, msg, flags);
+}
+
+/**
+ * camel_session_thread_wait:
+ * @session: 
+ * @id: 
+ * 
+ * Wait on an operation to complete (by id).
+ **/
+void camel_session_thread_wait(CamelSession *session, int id)
+{
+	g_assert(CAMEL_IS_SESSION(session));
+	
+	if (id == -1)
+		return;
+
+	return CS_CLASS (session)->thread_wait(session, id);
+}
+
+#endif
diff --git a/camel/camel-session.h b/camel/camel-session.h
index 54eea0b1e6..0ae292f452 100644
--- a/camel/camel-session.h
+++ b/camel/camel-session.h
@@ -37,6 +37,8 @@ extern "C" {
 #include <camel/camel-object.h>
 #include <camel/camel-provider.h>
 
+#include <e-util/e-msgport.h>
+
 #define CAMEL_SESSION_TYPE     (camel_session_get_type ())
 #define CAMEL_SESSION(obj)     (CAMEL_CHECK_CAST((obj), CAMEL_SESSION_TYPE, CamelSession))
 #define CAMEL_SESSION_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_SESSION_TYPE, CamelSessionClass))
@@ -60,6 +62,11 @@ struct _CamelSession
 	gboolean online;
 };
 
+#ifdef ENABLE_THREADS
+typedef struct _CamelSessionThreadOps CamelSessionThreadOps;
+typedef struct _CamelSessionThreadMsg CamelSessionThreadMsg;
+#endif
+
 typedef struct {
 	CamelObjectClass parent_class;
 
@@ -104,6 +111,14 @@ typedef struct {
 	CamelFilterDriver * (*get_filter_driver) (CamelSession *session,
 						  const char *type,
 						  CamelException *ex);
+#ifdef ENABLE_THREADS
+	/* mechanism for creating and maintaining multiple threads of control */
+	void *(*thread_msg_new)(CamelSession *session, CamelSessionThreadOps *ops, unsigned int size);
+	void (*thread_msg_free)(CamelSession *session, CamelSessionThreadMsg *msg);
+	int (*thread_queue)(CamelSession *session, CamelSessionThreadMsg *msg, int flags);
+	void (*thread_wait)(CamelSession *session, int id);
+#endif
+	
 } CamelSessionClass;
 
 
@@ -175,6 +190,26 @@ CamelFilterDriver *camel_session_get_filter_driver  (CamelSession *session,
 						     const char *type,
 						     CamelException *ex);
 
+#ifdef ENABLE_THREADS
+struct _CamelSessionThreadOps {
+	void (*receive)(CamelSession *session, struct _CamelSessionThreadMsg *m);
+	void (*free)(CamelSession *session, struct _CamelSessionThreadMsg *m);
+};
+
+struct _CamelSessionThreadMsg {
+	EMsg msg;
+
+	CamelSessionThreadOps *ops;
+	int id;
+	/* user fields follow */
+};
+
+void *camel_session_thread_msg_new(CamelSession *session, CamelSessionThreadOps *ops, unsigned int size);
+void camel_session_thread_msg_free(CamelSession *session, CamelSessionThreadMsg *msg);
+int camel_session_thread_queue(CamelSession *session, CamelSessionThreadMsg *msg, int flags);
+void camel_session_thread_wait(CamelSession *session, int id);
+#endif
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/camel/camel-store.c b/camel/camel-store.c
index 9722163cec..489d269991 100644
--- a/camel/camel-store.c
+++ b/camel/camel-store.c
@@ -67,12 +67,17 @@ static gboolean folder_subscribed (CamelStore *store, const char *folder_name);
 static void subscribe_folder (CamelStore *store, const char *folder_name, CamelException *ex);
 static void unsubscribe_folder (CamelStore *store, const char *folder_name, CamelException *ex);
 
+static void construct (CamelService *service, CamelSession *session,
+		       CamelProvider *provider, CamelURL *url,
+		       CamelException *ex);
+
 static void
 camel_store_class_init (CamelStoreClass *camel_store_class)
 {
 	CamelObjectClass *camel_object_class =
 		CAMEL_OBJECT_CLASS (camel_store_class);
-	
+	CamelServiceClass *camel_service_class = CAMEL_SERVICE_CLASS(camel_store_class);
+
 	parent_class = CAMEL_SERVICE_CLASS (camel_type_get_global_classfuncs (camel_service_get_type ()));
 	
 	/* virtual method definition */
@@ -93,6 +98,8 @@ camel_store_class_init (CamelStoreClass *camel_store_class)
 	camel_store_class->unsubscribe_folder = unsubscribe_folder;
 	
 	/* virtual method overload */
+	camel_service_class->construct = construct;
+
 	camel_object_class_declare_event (camel_object_class,
 					  "folder_created", NULL);
 	camel_object_class_declare_event (camel_object_class,
@@ -184,6 +191,21 @@ folder_finalize (CamelObject *folder, gpointer event_data, gpointer user_data)
 	}
 }
 
+static void
+construct (CamelService *service, CamelSession *session,
+	   CamelProvider *provider, CamelURL *url,
+	   CamelException *ex)
+{
+	CamelStore *store = CAMEL_STORE(service);
+
+	parent_class->construct(service, session, provider, url, ex);
+	if (camel_exception_is_set (ex))
+		return;
+
+	if (camel_url_get_param(url, "filter"))
+		store->flags |= CAMEL_STORE_FILTER_INBOX;
+}
+
 static CamelFolder *
 get_folder (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex)
 {
diff --git a/camel/camel-store.h b/camel/camel-store.h
index 6983524091..e86c884a1a 100644
--- a/camel/camel-store.h
+++ b/camel/camel-store.h
@@ -56,6 +56,7 @@ typedef struct _CamelFolderInfo {
 /* Flags for store flags */
 #define CAMEL_STORE_SUBSCRIPTIONS	(1 << 0)
 #define CAMEL_STORE_VTRASH		(1 << 1)
+#define CAMEL_STORE_FILTER_INBOX	(1 << 2)
 
 struct _CamelStore
 {
diff --git a/camel/camel-vee-folder.c b/camel/camel-vee-folder.c
index e2e224da92..b001536bd8 100644
--- a/camel/camel-vee-folder.c
+++ b/camel/camel-vee-folder.c
@@ -193,10 +193,6 @@ vee_folder_construct (CamelVeeFolder *vf, CamelStore *parent_store, const char *
 	char *tmp;
 	
 	vf->flags = flags;
-
-	/* We dont support ? syntax anymore */
-	g_assert(strchr(name, '?') == NULL);
-
 	vf->vname = g_strdup(name);
 	tmp = strrchr(vf->vname, '/');
 	if (tmp)
diff --git a/camel/providers/imap/camel-imap-folder.c b/camel/providers/imap/camel-imap-folder.c
index fc873f9e85..5d2a8ba146 100644
--- a/camel/providers/imap/camel-imap-folder.c
+++ b/camel/providers/imap/camel-imap-folder.c
@@ -50,7 +50,6 @@
 #include "camel-data-wrapper.h"
 #include "camel-disco-diary.h"
 #include "camel-exception.h"
-#include "camel-filter-driver.h"
 #include "camel-mime-filter-crlf.h"
 #include "camel-mime-filter-from.h"
 #include "camel-mime-message.h"
@@ -220,7 +219,7 @@ camel_imap_folder_new (CamelStore *parent, const char *folder_name,
 
 	if ((imap_store->parameters & IMAP_PARAM_FILTER_INBOX) &&
 	    !g_strcasecmp (folder_name, "INBOX"))
-		imap_folder->do_filtering = TRUE;
+		folder->filter_recent = TRUE;
 
 	return folder;
 }
@@ -1586,7 +1585,6 @@ add_message_from_data (CamelFolder *folder, GPtrArray *messages,
 static void
 imap_update_summary (CamelFolder *folder, int exists,
 		     CamelFolderChangeInfo *changes,
-		     GPtrArray *recents,
 		     CamelException *ex)
 {
 	CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store);
@@ -1775,8 +1773,8 @@ imap_update_summary (CamelFolder *folder, int exists,
 		camel_folder_summary_add (folder->summary, mi);
 		camel_folder_change_info_add_uid (changes, camel_message_info_uid (mi));
 
-		if (recents && (mi->flags & CAMEL_IMAP_MESSAGE_RECENT))
-			g_ptr_array_add (recents, (char *)camel_message_info_uid (mi));
+		if ((mi->flags & CAMEL_IMAP_MESSAGE_RECENT))
+			camel_folder_change_info_recent_uid(changes, camel_message_info_uid (mi));
 	}
 	g_ptr_array_free (messages, TRUE);
 	return;
@@ -1798,44 +1796,6 @@ imap_update_summary (CamelFolder *folder, int exists,
 	}
 }
 
-struct _filter_msg {
-	CamelImapMsg msg;
-
-	GPtrArray *recents;
-	CamelFolder *folder;
-	CamelFilterDriver *driver;
-};
-
-static void
-filter_proc(CamelImapStore *store, CamelImapMsg *mm)
-{
-	struct _filter_msg *msg = (struct _filter_msg *)mm;
-
-	printf("executing filtering %d messages folder %p\n", msg->recents->len, msg->folder);
-
-	/* what about exceptions? */
-	camel_filter_driver_filter_folder(msg->driver, msg->folder, NULL, msg->recents, FALSE, NULL);
-}
-
-static void
-filter_free(CamelImapStore *store, CamelImapMsg *mm)
-{
-	struct _filter_msg *msg = (struct _filter_msg *)mm;
-	int i;
-
-	printf("freeing filtering %d messages folder %p\n", msg->recents->len, msg->folder);
-
-	camel_object_unref((CamelObject *)msg->driver);
-
-	camel_folder_thaw(msg->folder);
-	camel_object_unref((CamelObject *)msg->folder);
-
-	for (i=0;i<msg->recents->len;i++)
-		g_free(msg->recents->pdata[i]);
-
-	g_ptr_array_free(msg->recents, TRUE);
-}
-
 /* Called with the store's command_lock locked */
 void
 camel_imap_folder_changed (CamelFolder *folder, int exists,
@@ -1872,50 +1832,11 @@ camel_imap_folder_changed (CamelFolder *folder, int exists,
 	}
 	
 	len = camel_folder_summary_count (folder->summary);
-	if (exists > len) {
-		if (imap_folder->do_filtering)
-			recents = g_ptr_array_new ();
-		imap_update_summary (folder, exists, changes, recents, ex);
-	}
+	if (exists > len)
+		imap_update_summary (folder, exists, changes, ex);
 	
-	/* if we have updates to make for filtering (probably), then we freeze the
-	   folder so we dont show them till they're complete, this may cause unacceptable
-	   delays for users, but the alternative isn't very nice either (show them and let
-	   them change as processed) */
-	if (recents && !camel_exception_is_set (ex) && recents->len) {
-		CamelFilterDriver *driver;
-		
-		camel_folder_freeze (folder);
-		
-		if (camel_folder_change_info_changed (changes))
-			camel_object_trigger_event (CAMEL_OBJECT (folder), "folder_changed", changes);
-		
-		driver = camel_session_get_filter_driver (CAMEL_SERVICE (folder->parent_store)->session, "incoming", ex);
-		if (driver) {
-#ifdef ENABLE_THREADS
-			int i;
-			struct _filter_msg *msg = (struct _filter_msg *)camel_imap_msg_new(filter_proc, filter_free, sizeof(*msg));
-
-			msg->recents = g_ptr_array_new();
-			for (i=0;i<recents->len;i++)
-				g_ptr_array_add(msg->recents, g_strdup(recents->pdata[i]));
-
-			camel_object_ref((CamelObject *)folder);
-			msg->folder = folder;
-			msg->driver = driver;
-			printf("queueing filtering %d messages folder %p\n", msg->recents->len, folder);
-			camel_imap_msg_queue((CamelImapStore *)folder->parent_store, (CamelImapMsg *)msg);
-#else
-			camel_filter_driver_filter_folder (driver, folder, NULL, recents, FALSE, ex);
-			camel_folder_thaw (folder);
-			camel_object_unref (CAMEL_OBJECT (driver));
-#endif
-		} else
-			camel_folder_thaw (folder);
-	} else {
-		if (camel_folder_change_info_changed (changes))
-			camel_object_trigger_event (CAMEL_OBJECT (folder), "folder_changed", changes);
-	}
+	if (camel_folder_change_info_changed (changes))
+		camel_object_trigger_event (CAMEL_OBJECT (folder), "folder_changed", changes);
 	
 	camel_folder_change_info_free (changes);
 	
diff --git a/camel/providers/imap/camel-imap-folder.h b/camel/providers/imap/camel-imap-folder.h
index db507d52d5..295cfd041e 100644
--- a/camel/providers/imap/camel-imap-folder.h
+++ b/camel/providers/imap/camel-imap-folder.h
@@ -48,7 +48,7 @@ struct _CamelImapFolder {
 
 	struct _CamelImapFolderPrivate *priv;
 
-	gboolean need_rescan, need_refresh, do_filtering;
+	gboolean need_rescan, need_refresh;
 	CamelFolderSearch *search;
 	CamelImapMessageCache *cache;
 };
diff --git a/camel/providers/imap/camel-imap-store.c b/camel/providers/imap/camel-imap-store.c
index d4cf4fb16c..b58b97fa83 100644
--- a/camel/providers/imap/camel-imap-store.c
+++ b/camel/providers/imap/camel-imap-store.c
@@ -285,8 +285,10 @@ construct (CamelService *service, CamelSession *session,
 	}
 	if (camel_url_get_param (url, "check_all"))
 		imap_store->parameters |= IMAP_PARAM_CHECK_ALL;
-	if (camel_url_get_param (url, "filter"))
+	if (camel_url_get_param (url, "filter")) {
 		imap_store->parameters |= IMAP_PARAM_FILTER_INBOX;
+		store->flags |= CAMEL_STORE_FILTER_INBOX;
+	}
 }
 
 static void
diff --git a/camel/providers/local/camel-local-folder.c b/camel/providers/local/camel-local-folder.c
index 811a71ecbe..927ca105ae 100644
--- a/camel/providers/local/camel-local-folder.c
+++ b/camel/providers/local/camel-local-folder.c
@@ -213,10 +213,14 @@ camel_local_folder_construct(CamelLocalFolder *lf, CamelStore *parent_store, con
 
 	folder->summary = (CamelFolderSummary *)CLOCALF_CLASS(lf)->create_summary(lf->summary_path, lf->folder_path, lf->index);
 	if (camel_local_summary_load((CamelLocalSummary *)folder->summary, forceindex, ex) == -1) {
+		camel_exception_clear(ex);
+	}
+	
+	if (camel_local_summary_check((CamelLocalSummary *)folder->summary, lf->changes, ex) == -1) {
 		camel_object_unref (CAMEL_OBJECT (folder));
 		return NULL;
 	}
-	
+
 	fi = g_new0 (CamelFolderInfo, 1);
 	fi->full_name = g_strdup (full_name);
 	fi->name = g_strdup (name);
diff --git a/camel/providers/local/camel-local-provider.c b/camel/providers/local/camel-local-provider.c
index 8a4047699f..606416fc37 100644
--- a/camel/providers/local/camel-local-provider.c
+++ b/camel/providers/local/camel-local-provider.c
@@ -55,6 +55,12 @@ static CamelProvider mbox_provider = {
 	/* ... */
 };
 
+static CamelProviderConfEntry local_conf_entries[] = {
+	{ CAMEL_PROVIDER_CONF_CHECKBOX, "filter", NULL,
+	  N_("Apply filters to new messages in INBOX"), "0" },
+	{ CAMEL_PROVIDER_CONF_END }
+};
+
 static CamelProvider maildir_provider = {
 	"maildir",
 	N_("Qmail maildir-format mail files"),
@@ -62,6 +68,7 @@ static CamelProvider maildir_provider = {
 	"mail",
 	CAMEL_PROVIDER_IS_SOURCE | CAMEL_PROVIDER_IS_STORAGE,
 	CAMEL_URL_NEED_PATH | CAMEL_URL_PATH_IS_ABSOLUTE,
+	local_conf_entries,
 	/* ... */
 };
 
@@ -72,6 +79,7 @@ static CamelProvider spool_provider = {
 	"mail",
 	CAMEL_PROVIDER_IS_SOURCE | CAMEL_PROVIDER_IS_STORAGE,
 	CAMEL_URL_NEED_PATH | CAMEL_URL_PATH_IS_ABSOLUTE,
+	local_conf_entries,
 	/* ... */
 };
 
diff --git a/camel/providers/local/camel-local-store.c b/camel/providers/local/camel-local-store.c
index fe8f09a911..43437b551a 100644
--- a/camel/providers/local/camel-local-store.c
+++ b/camel/providers/local/camel-local-store.c
@@ -190,6 +190,9 @@ get_folder_info (CamelStore *store, const char *top,
 	/* FIXME: This is broken, but it corresponds to what was
 	 * there before.
 	 */
+
+	printf("-- LOCAL STRE -- get folder info: %s\n", top);
+
 	return NULL;
 }
 
diff --git a/camel/providers/local/camel-local-summary.c b/camel/providers/local/camel-local-summary.c
index c925e6e36a..3202076520 100644
--- a/camel/providers/local/camel-local-summary.c
+++ b/camel/providers/local/camel-local-summary.c
@@ -148,18 +148,12 @@ camel_local_summary_load(CamelLocalSummary *cls, int forceindex, CamelException
 	if (forceindex
 	    || stat(s->summary_path, &st) == -1
 	    || ((CamelLocalSummaryClass *)(CAMEL_OBJECT_GET_CLASS(cls)))->load(cls, forceindex, ex) == -1) {
+		g_warning("Could not load summary: flags may be reset");
 		camel_folder_summary_clear((CamelFolderSummary *)cls);
+		return -1;
 	}
 
-	if (camel_local_summary_check(cls, NULL, ex) == 0) {
-		if (camel_folder_summary_save(s) == -1)
-			g_warning("Could not save summary for %s: %s", cls->folder_path, strerror(errno));
-		if (cls->index && ibex_save(cls->index) == -1)
-			g_warning("Could not sync index for %s: %s", cls->folder_path, strerror(errno));
-
-		return 0;
-	}
-	return -1;
+	return 0;
 }
 
 char *
@@ -261,6 +255,13 @@ camel_local_summary_check(CamelLocalSummary *cls, CamelFolderChangeInfo *changei
 
 	ret = ((CamelLocalSummaryClass *)(CAMEL_OBJECT_GET_CLASS(cls)))->check(cls, changeinfo, ex);
 
+	if (ret != -1) {
+		if (camel_folder_summary_save((CamelFolderSummary *)cls) == -1)
+			g_warning("Could not save summary for %s: %s", cls->folder_path, strerror(errno));
+		if (cls->index && ibex_save(cls->index) == -1)
+			g_warning("Could not sync index for %s: %s", cls->folder_path, strerror(errno));
+	}
+
 #ifdef DOSTATS
 	if (ret != -1) {
 		int i;
diff --git a/camel/providers/local/camel-maildir-folder.c b/camel/providers/local/camel-maildir-folder.c
index 159aa84620..1bd6417e1a 100644
--- a/camel/providers/local/camel-maildir-folder.c
+++ b/camel/providers/local/camel-maildir-folder.c
@@ -110,6 +110,11 @@ camel_maildir_folder_new(CamelStore *parent_store, const char *full_name, guint3
 	d(printf("Creating maildir folder: %s\n", full_name));
 
 	folder = (CamelFolder *)camel_object_new(CAMEL_MAILDIR_FOLDER_TYPE);
+
+	if (parent_store->flags & CAMEL_STORE_FILTER_INBOX
+	    && strcmp(full_name, "") == 0)
+		folder->filter_recent = TRUE;
+
 	folder = (CamelFolder *)camel_local_folder_construct((CamelLocalFolder *)folder,
 							     parent_store, full_name, flags, ex);
 
diff --git a/camel/providers/local/camel-maildir-store.c b/camel/providers/local/camel-maildir-store.c
index c200058c95..927c194089 100644
--- a/camel/providers/local/camel-maildir-store.c
+++ b/camel/providers/local/camel-maildir-store.c
@@ -313,8 +313,8 @@ static int scan_dir(GHashTable *visited, char *root, const char *path, guint32 f
 						closedir(dir);
 						return -1;
 					}
+					g_free(new);
 				}
-				g_free(new);
 			}
 			g_free(tmp);
 		}
diff --git a/camel/providers/local/camel-maildir-summary.c b/camel/providers/local/camel-maildir-summary.c
index 315e45ffd6..39726566bc 100644
--- a/camel/providers/local/camel-maildir-summary.c
+++ b/camel/providers/local/camel-maildir-summary.c
@@ -635,8 +635,10 @@ maildir_summary_check(CamelLocalSummary *cls, CamelFolderChangeInfo *changes, Ca
 
 			if (rename(src, dest) == 0) {
 				camel_maildir_summary_add(cls, destfilename, forceindex);
-				if (changes)
+				if (changes) {
 					camel_folder_change_info_add_uid(changes, destname);
+					camel_folder_change_info_recent_uid(changes, destname);
+				}
 			} else {
 				/* else?  we should probably care about failures, but wont */
 				g_warning("Failed to move new maildir message %s to cur %s", src, dest);
diff --git a/camel/providers/local/camel-spool-folder.c b/camel/providers/local/camel-spool-folder.c
index be4ca31cf2..c5e9165917 100644
--- a/camel/providers/local/camel-spool-folder.c
+++ b/camel/providers/local/camel-spool-folder.c
@@ -200,7 +200,7 @@ camel_spool_folder_construct(CamelSpoolFolder *lf, CamelStore *parent_store, con
 		return NULL;
 	}
 
-	camel_spool_summary_check((CamelSpoolSummary *)folder->summary, NULL, ex);
+	camel_spool_summary_check((CamelSpoolSummary *)folder->summary, lf->changes, ex);
 	camel_spool_folder_unlock(lf);
 
 	fi = g_malloc0(sizeof(*fi));
@@ -209,9 +209,8 @@ camel_spool_folder_construct(CamelSpoolFolder *lf, CamelStore *parent_store, con
 	fi->url = g_strdup(lf->folder_path);
 	fi->unread_message_count = camel_folder_get_unread_message_count(folder);
 	camel_object_trigger_event(CAMEL_OBJECT(parent_store), "folder_created", fi);
-	
 	camel_folder_info_free (fi);
-	
+
 	return lf;
 }
 
@@ -223,6 +222,10 @@ camel_spool_folder_new(CamelStore *parent_store, const char *full_name, guint32
 	d(printf("Creating spool folder: %s in %s\n", full_name, camel_local_store_get_toplevel_dir((CamelLocalStore *)parent_store)));
 
 	folder = (CamelFolder *)camel_object_new(CAMEL_SPOOL_FOLDER_TYPE);
+
+	if (parent_store->flags & CAMEL_STORE_FILTER_INBOX
+	    && strcmp(full_name, "INBOX") == 0)
+		folder->filter_recent = TRUE;
 	folder = (CamelFolder *)camel_spool_folder_construct((CamelSpoolFolder *)folder,
 							     parent_store, full_name, flags, ex);
 
diff --git a/camel/providers/local/camel-spool-store.c b/camel/providers/local/camel-spool-store.c
index aa9d583d17..600ee8b2bc 100644
--- a/camel/providers/local/camel-spool-store.c
+++ b/camel/providers/local/camel-spool-store.c
@@ -148,8 +148,7 @@ static CamelFolder *
 get_folder(CamelStore * store, const char *folder_name, guint32 flags, CamelException * ex)
 {
 	char *path = ((CamelService *)store)->url->path;
-	char *name;
-	int len;
+	CamelFolder *folder;
 
 	printf("opening folder %s on path %s\n", folder_name, path);
 
@@ -161,12 +160,9 @@ get_folder(CamelStore * store, const char *folder_name, guint32 flags, CamelExce
 		return NULL;
 	}
 
-	len = strlen(path);
-	name = alloca(len+1);
-	strcpy(name, path);
-	name[len-1] = 0;
+	folder = camel_spool_folder_new(store, folder_name, flags, ex);
 
-	return camel_spool_folder_new(store, name, flags, ex);
+	return folder;
 }
 
 static CamelFolder *
diff --git a/camel/providers/local/camel-spool-summary.c b/camel/providers/local/camel-spool-summary.c
index 2aa0dcb8e4..651ce7b0e9 100644
--- a/camel/providers/local/camel-spool-summary.c
+++ b/camel/providers/local/camel-spool-summary.c
@@ -751,6 +751,11 @@ spool_summary_sync_full(CamelSpoolSummary *cls, gboolean expunge, CamelFolderCha
 						     strerror(errno));
 				goto error;
 			}
+
+			/* mark this message as recent */
+			if (info->info.flags & CAMEL_MESSAGE_FOLDER_NOXEV)
+				camel_folder_change_info_recent_uid(changeinfo, camel_message_info_uid(info));
+
 			info->info.flags &= 0xffff;
 			g_free(xevnew);
 			xevnew = NULL;