Added folder_created event here.

2001-03-27  Not Zed  <NotZed@Ximian.com>

        * camel-vee-store.c (vee_get_folder): Added folder_created event
        here.

        * camel-vee-folder.c (unmatched_finalise): Removed, moved into
        main finalise code.
        (message_changed): Just create a new change entry and promote it
        to a folder_changed thing.
        (vee_sync): Always rebuild folder on sync, even when not expunge.
        (folder_changed): If not autoupdating, make sure we remove any
        removed entries.
        (vee_folder_build_folder):
        (vee_folder_remove_folder): NOP if we're called on
        folder_unmatched.
        (vee_search_by_expression): Only search each folder once.  Should
        we also order the result in summary order?

2001-03-20  Not Zed  <NotZed@Ximian.com>

        * camel-store.c (init_trash): Fix calling for vee_folder_new().

        * camel-folder-summary.c (camel_folder_summary_remove_index):
        Optimise slightly, use ptr_array_remove_index rather than have to
        search for the index by using summary_remove.

        * camel-vee-folder.h: Removed local member from VeeFolder, since
        it was never used.

        * camel-vee-store.c (camel_vee_store_finalise): Setup finalise
        function.

        * camel-vee-folder.c (camel_vee_folder_set_expression): New
        function to set the query of an existing vfolder.
        (camel_vee_folder_construct): New function for
        convenience/subclasses.
        (camel_vee_folder_new): Removed exception parameter, no longer
        needed (since we dont search yet).
        (camel_vee_folder_new): Changed to use folder_construct, and no
        longer raise the folder created signal.
        (vee_folder_build_folder): Make it return error on exception, so
        we can work without exceptions.
        (vee_folder_remove_folder): Use remove index rather than
        remove_uid, this is ok since we have the summary locked for our
        own access.
        (camel_vee_folder_add_folder): Only add the folder to the
        unmatched private if it is not a private folder.
        (camel_vee_folder_remove_folder): Only remove the folder from
        unmatched if it is not private.
        (vee_expunge): Just call sync with expunge set.
        (vee_sync): If expunging, also refresh the search.
        (vee_folder_build_folder): We do our own locking now, removed from
        callers, also trigger changed events here too (within locks),
        fixed callers appropriately.
        (vee_folder_remove_folder): Do our own locking, and trigger
        changed events.
        (vee_folder_add_info): Renamed of vee_folder_add, we now take a
        hash of the folder name, rather than use the folders address.
        (hash_folder): Convert a folder name into an 8 character hash.
        (vee_get_message, vee_search_by_expression, vee_set_message_flags,
        vee_set_message_user_flag, vee_move_message_to): Changed the uid
        to be an 8 byte hash + original uid, with no ':' anymore.

svn path=/trunk/; revision=8957

7 files changed, 668 insertions, 610 deletions

diff --git a/camel/ChangeLog b/camel/ChangeLog
index d4f4d6d06d..9422e5e746 100644
--- a/camel/ChangeLog
+++ b/camel/ChangeLog
@@ -1,3 +1,66 @@
+2001-03-27  Not Zed  <NotZed@Ximian.com>
+
+	* camel-vee-store.c (vee_get_folder): Added folder_created event
+	here.
+	
+	* camel-vee-folder.c (unmatched_finalise): Removed, moved into
+	main finalise code.
+	(message_changed): Just create a new change entry and promote it
+	to a folder_changed thing.
+	(vee_sync): Always rebuild folder on sync, even when not expunge.
+	(folder_changed): If not autoupdating, make sure we remove any
+	removed entries.
+	(vee_folder_build_folder): 
+	(vee_folder_remove_folder): NOP if we're called on
+	folder_unmatched.
+	(vee_search_by_expression): Only search each folder once.  Should
+	we also order the result in summary order?
+
+2001-03-20  Not Zed  <NotZed@Ximian.com>
+
+	* camel-store.c (init_trash): Fix calling for vee_folder_new().
+
+	* camel-folder-summary.c (camel_folder_summary_remove_index):
+	Optimise slightly, use ptr_array_remove_index rather than have to
+	search for the index by using summary_remove.
+
+	* camel-vee-folder.h: Removed local member from VeeFolder, since
+	it was never used.
+
+	* camel-vee-store.c (camel_vee_store_finalise): Setup finalise
+	function.
+
+	* camel-vee-folder.c (camel_vee_folder_set_expression): New
+	function to set the query of an existing vfolder.
+	(camel_vee_folder_construct): New function for
+	convenience/subclasses.
+	(camel_vee_folder_new): Removed exception parameter, no longer
+	needed (since we dont search yet).
+	(camel_vee_folder_new): Changed to use folder_construct, and no
+	longer raise the folder created signal.
+	(vee_folder_build_folder): Make it return error on exception, so
+	we can work without exceptions.
+	(vee_folder_remove_folder): Use remove index rather than
+	remove_uid, this is ok since we have the summary locked for our
+	own access.
+	(camel_vee_folder_add_folder): Only add the folder to the
+	unmatched private if it is not a private folder.
+	(camel_vee_folder_remove_folder): Only remove the folder from
+	unmatched if it is not private.
+	(vee_expunge): Just call sync with expunge set.
+	(vee_sync): If expunging, also refresh the search.
+	(vee_folder_build_folder): We do our own locking now, removed from
+	callers, also trigger changed events here too (within locks),
+	fixed callers appropriately.
+	(vee_folder_remove_folder): Do our own locking, and trigger
+	changed events.
+	(vee_folder_add_info): Renamed of vee_folder_add, we now take a
+	hash of the folder name, rather than use the folders address.
+	(hash_folder): Convert a folder name into an 8 character hash.
+	(vee_get_message, vee_search_by_expression, vee_set_message_flags,
+	vee_set_message_user_flag, vee_move_message_to): Changed the uid
+	to be an 8 byte hash + original uid, with no ':' anymore.
+
 2001-03-26  Jeffrey Stedfast  <fejj@ximian.com>
 
 	* camel-mime-utils.c (header_decode_text): When writing the last
diff --git a/camel/camel-folder-summary.c b/camel/camel-folder-summary.c
index 9aaa61e50c..8a21b8f93f 100644
--- a/camel/camel-folder-summary.c
+++ b/camel/camel-folder-summary.c
@@ -1045,19 +1045,18 @@ void camel_folder_summary_remove_uid(CamelFolderSummary *s, const char *uid)
  **/
 void camel_folder_summary_remove_index(CamelFolderSummary *s, int index)
 {
-	CAMEL_SUMMARY_LOCK(s, ref_lock);
 	CAMEL_SUMMARY_LOCK(s, summary_lock);
 	if (index < s->messages->len) {
 		CamelMessageInfo *info = s->messages->pdata[index];
-		/* make sure it doesn't vanish while we're not looking */
-		info->refcount++;
+
+		g_hash_table_remove(s->messages_uid, camel_message_info_uid(info));
+		g_ptr_array_remove_index(s->messages, index);
+		s->flags |= CAMEL_SUMMARY_DIRTY;
+
 		CAMEL_SUMMARY_UNLOCK(s, summary_lock);
-		CAMEL_SUMMARY_UNLOCK(s, ref_lock);
-		camel_folder_summary_remove(s, info);
 		camel_folder_summary_info_free(s, info);
 	} else {
 		CAMEL_SUMMARY_UNLOCK(s, summary_lock);
-		CAMEL_SUMMARY_UNLOCK(s, ref_lock);
 	}
 }
 
diff --git a/camel/camel-store.c b/camel/camel-store.c
index 97f269fd40..0d39c6ee29 100644
--- a/camel/camel-store.c
+++ b/camel/camel-store.c
@@ -381,8 +381,7 @@ init_trash (CamelStore *store)
 	
 	name = g_strdup_printf ("%s?(match-all (system-flag \"Deleted\"))", _("Trash"));
 	
-	store->vtrash = camel_vee_folder_new (store, name, CAMEL_STORE_FOLDER_CREATE |
-					      CAMEL_STORE_VEE_FOLDER_AUTO, NULL);
+	store->vtrash = camel_vee_folder_new (store, name, CAMEL_STORE_FOLDER_CREATE|CAMEL_STORE_VEE_FOLDER_AUTO|CAMEL_STORE_FOLDER_PRIVATE);
 	
 	g_free (name);
 	
diff --git a/camel/camel-store.h b/camel/camel-store.h
index 6ea20b4d2c..493720b24f 100644
--- a/camel/camel-store.h
+++ b/camel/camel-store.h
@@ -70,6 +70,7 @@ struct _CamelStore
 /* open mode for folder */
 #define CAMEL_STORE_FOLDER_CREATE (1<<0)
 #define CAMEL_STORE_FOLDER_BODY_INDEX (1<<1)
+#define CAMEL_STORE_FOLDER_PRIVATE (1<<2) /* a private folder, that shouldn't show up in unmatched/folder info's, etc */
 
 typedef struct {
 	CamelServiceClass parent_class;
diff --git a/camel/camel-vee-folder.c b/camel/camel-vee-folder.c
index 55a355ae2f..cfcf3175c7 100644
--- a/camel/camel-vee-folder.c
+++ b/camel/camel-vee-folder.c
@@ -32,6 +32,8 @@
 #include "camel-vee-store.h"	/* for open flags */
 #include "camel-private.h"
 
+#include "e-util/md5-utils.h"
+
 #ifdef DOESTRV
 #include "e-util/e-memory.h"
 #endif
@@ -48,6 +50,8 @@ typedef struct _CamelVeeMessageInfo {
 
 #define _PRIVATE(o) (((CamelVeeFolder *)(o))->priv)
 
+static void hash_folder(CamelFolder *folder, char buffer[8]);
+
 static void vee_sync (CamelFolder *folder, gboolean expunge, CamelException *ex);
 static void vee_expunge (CamelFolder *folder, CamelException *ex);
 
@@ -63,22 +67,22 @@ static void camel_vee_folder_class_init (CamelVeeFolderClass *klass);
 static void camel_vee_folder_init       (CamelVeeFolder *obj);
 static void camel_vee_folder_finalise   (CamelObject *obj);
 
-static void unmatched_finalise(CamelFolder *sub, gpointer type, CamelVeeFolder *vf);
+static int vee_folder_build_folder(CamelVeeFolder *vf, CamelFolder *source, CamelException *ex);
+static void vee_folder_remove_folder(CamelVeeFolder *vf, CamelFolder *source);
 
-static void folder_changed(CamelFolder *sub, gpointer type, CamelVeeFolder *vf);
 static void message_changed(CamelFolder *f, const char *uid, CamelVeeFolder *vf);
-
-static void vee_folder_build_folder(CamelVeeFolder *vf, CamelFolder *source, CamelException *ex);
-static void vee_folder_remove_folder(CamelVeeFolder *vf, CamelFolder *source);
+static void folder_changed(CamelFolder *sub, CamelFolderChangeInfo *changes, CamelVeeFolder *vf);
 
 static CamelFolderClass *camel_vee_folder_parent;
 
 /* a vfolder for unmatched messages */
+/* use folder_unmatched->summary_lock for access to unmatched_uids or appropriate internals, for consistency */
 static CamelVeeFolder *folder_unmatched;
-static GHashTable *unmatched_uids;
+static GHashTable *unmatched_uids; /* a refcount of uid's that are matched by any rules */
 #ifdef ENABLE_THREADS
 #include <pthread.h>
 static pthread_mutex_t unmatched_lock = PTHREAD_MUTEX_INITIALIZER;
+/* only used to initialise folder_unmatched */
 #define UNMATCHED_LOCK() pthread_mutex_lock(&unmatched_lock)
 #define UNMATCHED_UNLOCK() pthread_mutex_unlock(&unmatched_lock)
 #else
@@ -158,13 +162,17 @@ camel_vee_folder_finalise (CamelObject *obj)
 	struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);
 	GList *node;
 
-	/* FIXME: some leaks here, summary etc */
-
+	/* FIXME: check leaks */
 	node = p->folders;
 	while (node) {
 		CamelFolder *f = node->data;
-		camel_object_unhook_event ((CamelObject *)f, "folder_changed", (CamelObjectEventHookFunc) folder_changed, vf);
-		camel_object_unhook_event ((CamelObject *)f, "message_changed", (CamelObjectEventHookFunc) message_changed, vf);
+		if (vf != folder_unmatched) {
+			camel_object_unhook_event((CamelObject *)f, "folder_changed", (CamelObjectEventHookFunc) folder_changed, vf);
+			camel_object_unhook_event((CamelObject *)f, "message_changed", (CamelObjectEventHookFunc) message_changed, vf);
+			/* this updates the vfolder */
+			if ((vf->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0)
+				camel_vee_folder_remove_folder(vf, f);
+		}
 		camel_object_unref((CamelObject *)f);
 		node = g_list_next(node);
 	}
@@ -174,6 +182,7 @@ camel_vee_folder_finalise (CamelObject *obj)
 
 	camel_folder_change_info_free(vf->changes);
 	camel_object_unref((CamelObject *)vf->search);
+	camel_object_unref((CamelObject *)((CamelFolder *)vf)->summary);
 
 #ifdef ENABLE_THREADS
 	g_mutex_free(p->summary_lock);
@@ -182,6 +191,34 @@ camel_vee_folder_finalise (CamelObject *obj)
 	g_free(p);
 }
 
+void
+camel_vee_folder_construct(CamelVeeFolder *vf, CamelStore *parent_store, const char *name, guint32 flags)
+{
+	CamelFolder *folder = (CamelFolder *)vf;
+	char *tmp;
+
+	vf->flags = flags;
+
+	tmp = strchr(name, '?');
+	if (tmp) {
+		vf->vname = g_strndup(name, tmp-name);
+		vf->expression = g_strdup(tmp+1);
+	} else {
+		vf->vname = g_strdup(name);
+	}
+
+	tmp = strrchr(vf->vname, '/');
+	if (tmp)
+		tmp++;
+	else
+		tmp = vf->vname;
+	camel_folder_construct(folder, parent_store, vf->vname, tmp);
+
+	/* should CamelVeeMessageInfo be subclassable ..? */
+	folder->summary = camel_folder_summary_new();
+	folder->summary->message_info_size = sizeof(CamelVeeMessageInfo);
+}
+
 /**
  * camel_vee_folder_new:
  * @parent_store: the parent CamelVeeStore
@@ -193,189 +230,312 @@ camel_vee_folder_finalise (CamelObject *obj)
  * Return value: A new CamelVeeFolder widget.
  **/
 CamelFolder *
-camel_vee_folder_new(CamelStore *parent_store, const char *name, guint32 flags, CamelException *ex)
+camel_vee_folder_new(CamelStore *parent_store, const char *name, guint32 flags)
 {
-	CamelFolderInfo *fi;
-	CamelFolder *folder;
 	CamelVeeFolder *vf;
-	char *namepart, *searchpart;
-
-	namepart = g_strdup(name);
-	searchpart = strchr(namepart, '?');
-	if (searchpart == NULL) {
-		/* no search, no result! */
-		searchpart = "(body-contains \"=some-invalid_string-sequence=xx\")";
-	} else {
-		*searchpart++ = 0;
-	}
+	char *path, *query;
 
 	UNMATCHED_LOCK();
 
+	/* setup unmatched folder if we haven't yet */
 	if (folder_unmatched == NULL) {
-		printf("setting up unmatched folder\n");
 		unmatched_uids = g_hash_table_new(g_str_hash, g_str_equal);
-
-		folder = (CamelFolder *)camel_object_new(camel_vee_folder_get_type());
-		folder_unmatched = vf = (CamelVeeFolder *)folder;
-		camel_folder_construct(folder, parent_store, "UNMATCHED", "UNMATCHED");
-		folder->summary = camel_folder_summary_new();
-		folder->summary->message_info_size = sizeof(CamelVeeMessageInfo);
-
-		vf->expression = g_strdup("(header-contains \"subject\" \"--= in =-=-=+ valid , ., .l\")");
-		vf->vname = g_strdup("UNMATCHED");
+		folder_unmatched = vf = (CamelVeeFolder *)camel_object_new(camel_vee_folder_get_type());
+		printf("created foldeer unmatched %p\n", folder_unmatched);
+		camel_vee_folder_construct(vf, parent_store, "UNMATCHED", CAMEL_STORE_FOLDER_PRIVATE);
 	}
 
 	UNMATCHED_UNLOCK();
 
-	printf("opening vee folder %s\n", name);
-	if (strcmp(namepart, "UNMATCHED") == 0) {
+	path = alloca(strlen(name)+1);
+	strcpy(path, name);
+	query = strchr(path, '?');
+	if (query)
+		*query++ = 0;
+
+	if (strcmp(path, "UNMATCHED") == 0) {
 		camel_object_ref((CamelObject *)folder_unmatched);
-		g_free(namepart);
-		printf("opened UNMATCHED folder %p %s with %d messages\n", folder_unmatched, name, camel_folder_get_message_count((CamelFolder *)folder_unmatched));
+		printf("returning unmatched %p, count = %d\n", folder_unmatched, camel_folder_get_message_count((CamelFolder *)folder_unmatched));
 		return (CamelFolder *)folder_unmatched;
 	}
 
+	vf = (CamelVeeFolder *)camel_object_new(camel_vee_folder_get_type());
+	camel_vee_folder_construct(vf, parent_store, name, flags);
 
-	folder =  CAMEL_FOLDER (camel_object_new (camel_vee_folder_get_type()));
-	vf = (CamelVeeFolder *)folder;
-	vf->flags = flags;
+	printf("returning folder %s %p, count = %d\n", name, vf, camel_folder_get_message_count((CamelFolder *)vf));
 
-	/* remove folders as they vanish */
-	camel_object_hook_event((CamelObject *)vf, "finalize", (CamelObjectEventHookFunc)unmatched_finalise, folder_unmatched);
+	return (CamelFolder *)vf;
+}
 
-	camel_folder_construct (folder, parent_store, namepart, namepart);
+void
+camel_vee_folder_set_expression(CamelVeeFolder *vf, const char *query)
+{
+	struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);
+	GList *node;
 
-	folder->summary = camel_folder_summary_new();
-	folder->summary->message_info_size = sizeof(CamelVeeMessageInfo);
+	CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);
 
-	vf->expression = g_strdup(searchpart);
-	vf->vname = namepart;
+	node = p->folders;
+	while (node) {
+		CamelFolder *f = node->data;
 
-	printf("opened normal folder folder %p %s with %d messages\n", folder, name, camel_folder_get_message_count(folder));
+		if (vee_folder_build_folder(vf, f, NULL) == -1)
+			break;
 
-	/* FIXME: should be moved to store */
-	fi = g_new0(CamelFolderInfo, 1);
-	fi->full_name = g_strdup(name);
-	fi->name = g_strdup(name);
-	fi->url = g_strdup_printf("vfolder:%s?%s", vf->vname, vf->expression);
-	fi->unread_message_count = -1;
-	
-	camel_object_trigger_event(CAMEL_OBJECT(parent_store), "folder_created", fi);
-	camel_folder_info_free (fi);
+		node = node->next;
+	}
 
-	return folder;
+	CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
 }
 
-static CamelVeeMessageInfo * vee_folder_add_uid(CamelVeeFolder *vf, CamelFolder *f, const char *inuid);
+/**
+ * camel_vee_folder_add_folder:
+ * @vf: Virtual Folder object
+ * @sub: source CamelFolder to add to @vf
+ *
+ * Adds @sub as a source folder to @vf.
+ **/
+void
+camel_vee_folder_add_folder(CamelVeeFolder *vf, CamelFolder *sub)
+{
+	struct _CamelVeeFolderPrivate *p = _PRIVATE(vf), *up = _PRIVATE(folder_unmatched);
+
+	CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);
+
+	/* for normal vfolders we want only unique ones, for unmatched we want them all recorded */
+	if (g_list_find(p->folders, sub) == NULL) {
+		camel_object_ref((CamelObject *)sub);
+		p->folders = g_list_append(p->folders, sub);
+	}
+	if ((vf->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0) {
+		camel_object_ref((CamelObject *)sub);
+		up->folders = g_list_append(up->folders, sub);
+	}
+
+	CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
+
+	d(printf("camel_vee_folder_add_folde(%p, %p)\n", vf, sub));
+
+	camel_object_hook_event((CamelObject *)sub, "folder_changed", (CamelObjectEventHookFunc)folder_changed, vf);
+	camel_object_hook_event((CamelObject *)sub, "message_changed", (CamelObjectEventHookFunc)message_changed, vf);
+
+	vee_folder_build_folder(vf, sub, NULL);
+}
+
+/**
+ * camel_vee_folder_remove_folder:
+ * @vf: Virtual Folder object
+ * @sub: source CamelFolder to remove from @vf
+ *
+ * Removed the source folder, @sub, from the virtual folder, @vf.
+ **/
+void
+camel_vee_folder_remove_folder(CamelVeeFolder *vf, CamelFolder *sub)
+{
+	struct _CamelVeeFolderPrivate *p = _PRIVATE(vf), *up = _PRIVATE(folder_unmatched);
+
+	CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);
+	if (g_list_find(p->folders, sub) == NULL) {
+		CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
+		return;
+	}
+
+	p->folders = g_list_remove(p->folders, sub);
+	if ((vf->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0 && g_list_find(p->folders, sub) != NULL) {
+		up->folders = g_list_remove(up->folders, sub);
+		camel_object_unref((CamelObject *)sub);
+	}
+
+	CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
+
+	vee_folder_remove_folder(vf, sub);
+
+	camel_object_unref((CamelObject *)sub);
+}
 
-/* must be called with summary_lock held */
 static void
-unmatched_uid_remove(const char *uidin, CamelFolder *source)
+vee_sync(CamelFolder *folder, gboolean expunge, CamelException *ex)
 {
-	char *oldkey, *uid;
-	int n;
+	CamelVeeFolder *vf = (CamelVeeFolder *)folder;
+	struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);
+	GList *node;
 
-	uid = g_strdup_printf("%p:%s", source, uidin);
-	
-	/*printf("checking unmatched uid (remove from source) %s\n", uid);*/
+	CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);
 
-	UNMATCHED_LOCK();
+	node = p->folders;
+	while (node) {
+		CamelFolder *f = node->data;
 
-	if (g_hash_table_lookup_extended(unmatched_uids, uid, (void **)&oldkey, (void **)&n)) {
-		if (n == 1) {
-			/*printf("lost all matches, adding uid to unmatched\n");*/
-			if (vee_folder_add_uid(folder_unmatched, source, oldkey))
-				camel_folder_change_info_add_uid(folder_unmatched->changes, uid);
-			g_hash_table_remove(unmatched_uids, oldkey);
-			g_free(oldkey);
-		} else
-			g_hash_table_insert(unmatched_uids, oldkey, (void *)n-1);
-	} else {
-		/*printf("unknown uid, adding to unmatched\n");*/
-		/* FIXME: lookup to see if we already have it first, to save doing it later */
-		if (vee_folder_add_uid(folder_unmatched, source, uidin))
-			camel_folder_change_info_add_uid(folder_unmatched->changes, uid);
-	}
+		camel_folder_sync(f, expunge, ex);
+		if (camel_exception_is_set(ex))
+			break;
 
-	UNMATCHED_UNLOCK();
+		if (vee_folder_build_folder(vf, f, ex) == -1)
+			break;
 
-	g_free(uid);
+		node = node->next;
+	}
+
+	CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
 }
 
-/* add a uid to the unmatched folder if it is unmatched everywhere else */
 static void
-unmatched_uid_check(const char *uidin, CamelFolder *source)
+vee_expunge (CamelFolder *folder, CamelException *ex)
 {
-	char *oldkey, *uid;
-	int n;
+	((CamelFolderClass *)camel_vee_folder_parent)->sync(folder, TRUE, ex);
+}
 
-	uid = g_strdup_printf("%p:%s", source, uidin);
-	
-	/*printf("checking unmatched uid (remove from source) %s\n", uid);*/
+static CamelMimeMessage *
+vee_get_message(CamelFolder *folder, const char *uid, CamelException *ex)
+{
+	CamelVeeMessageInfo *mi;
+	CamelMimeMessage *msg = NULL;
 
-	UNMATCHED_LOCK();
+	mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);
+	if (mi) {
+		msg =  camel_folder_get_message(mi->folder, camel_message_info_uid(mi)+8, ex);
+		camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
+	} else {
+		camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID,
+				     "No such message %s in %s", uid,
+				     folder->name);
+	}
 
-	if (!g_hash_table_lookup_extended(unmatched_uids, uid, (void **)&oldkey, (void **)&n)) {
-		/*printf("unknown uid, adding to unmatched\n");*/
-		/* FIXME: lookup to see if we already have it first, to save doing it later */
-		if (vee_folder_add_uid(folder_unmatched, source, uidin))
-			camel_folder_change_info_add_uid(folder_unmatched->changes, uid);
+	return msg;
+}
+
+static GPtrArray *
+vee_search_by_expression(CamelFolder *folder, const char *expression, CamelException *ex)
+{
+	GList *node;
+	GPtrArray *matches, *result = g_ptr_array_new ();
+	char *expr;
+	CamelVeeFolder *vf = (CamelVeeFolder *)folder;
+	struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);
+	GHashTable *searched = g_hash_table_new(NULL, NULL);
+
+	CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);
+
+	expr = g_strdup_printf("(and %s %s)", vf->expression, expression);
+	node = p->folders;
+	while (node) {
+		CamelFolder *f = node->data;
+		int i;
+		char hash[8];
+		
+		/* make sure we only search each folder once - for unmatched folder to work right */
+		if (g_hash_table_lookup(searched, f) == NULL) {
+			hash_folder(f, hash);
+			matches = camel_folder_search_by_expression(f, expression, ex);
+			for (i = 0; i < matches->len; i++) {
+				char *uid = matches->pdata[i];
+				g_ptr_array_add(result, g_strdup_printf("%.8s%s", hash, uid));
+			}
+			camel_folder_search_free(f, matches);
+			g_hash_table_insert(searched, f, f);
+		}
+		node = g_list_next(node);
 	}
 
-	UNMATCHED_UNLOCK();
+	CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
+
+	g_hash_table_destroy(searched);
 
-	g_free(uid);
+	return result;
 }
 
-/* must be called with summary_lock held */
 static void
-unmatched_uid_add(const char *uidin, CamelFolder *source)
+vee_set_message_flags(CamelFolder *folder, const char *uid, guint32 flags, guint32 set)
 {
-	char *oldkey, *uid;
-	int n;
-	CamelMessageInfo *info;
+	CamelVeeMessageInfo *mi;
+
+	mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);
+	if (mi) {
+		((CamelFolderClass *)camel_vee_folder_parent)->set_message_flags(folder, uid, flags, set);
+		camel_folder_set_message_flags(mi->folder, camel_message_info_uid(mi) + 8, flags, set);
+		camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
+	}
+}
 
-	uid = g_strdup_printf("%p:%s", source, uidin);
+static void
+vee_set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value)
+{
+	CamelVeeMessageInfo *mi;
 
-	/*printf("checking unmatched uid (added to source) %s\n", uid);*/
+	mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);
+	if (mi) {
+		((CamelFolderClass *)camel_vee_folder_parent)->set_message_user_flag(folder, uid, name, value);
+		camel_folder_set_message_user_flag(mi->folder, camel_message_info_uid(mi) + 8, name, value);
+		camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
+	}
+}
 
-	UNMATCHED_LOCK();
+static void
+vee_move_message_to(CamelFolder *folder, const char *uid, CamelFolder *dest, CamelException *ex)
+{
+	CamelVeeMessageInfo *mi;
 
-	info = camel_folder_summary_uid(((CamelFolder *)folder_unmatched)->summary, uid);
-	if (info) {
-		/*printf("we have it, lets remove it\n");*/
-		camel_folder_summary_remove_uid(((CamelFolder *)folder_unmatched)->summary, uid);
-		camel_folder_change_info_remove_uid(folder_unmatched->changes, uid);
-		camel_folder_summary_info_free(((CamelFolder *)folder_unmatched)->summary, info);
+	mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);
+	if (mi) {
+		/* noop if it we're moving from the same vfolder (uh, which should't happen but who knows) */
+		if (folder != mi->folder) {
+			camel_folder_move_message_to(mi->folder, camel_message_info_uid(mi) + 8, dest, ex);
+		}
+		camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
+	} else {
+		camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID, _("No such message: %s"), uid);
 	}
+}
 
-	if (g_hash_table_lookup_extended(unmatched_uids, uid, (void **)&oldkey, (void **)&n)) {
-		g_hash_table_insert(unmatched_uids, oldkey, (void **)n+1);
-		g_free(uid);
-	} else
-		g_hash_table_insert(unmatched_uids, uid, (void **)1);
+/* ********************************************************************** *
+   utility functions */
 
-	UNMATCHED_UNLOCK();
+/* convert a folder name (full path) into a 8 character identifier that should be static */
+static void
+hash_folder(CamelFolder *folder, char buffer[8])
+{
+	MD5Context ctx;
+	unsigned char digest[16];
+	unsigned int state = 0, save = 0;
+	char *tmp;
+	int i;
+
+	md5_init(&ctx);
+	tmp = camel_service_get_url((CamelService *)folder->parent_store);
+	md5_update(&ctx, tmp, strlen(tmp));
+	g_free(tmp);
+	md5_update(&ctx, folder->full_name, strlen(folder->full_name));
+	md5_final(&ctx, digest);
+	base64_encode_close(digest, 6, FALSE, buffer, &state, &save);
+
+	for (i=0;i<8;i++) {
+		if (buffer[i] == '+')
+			buffer[i] = '.';
+		if (buffer[i] == '/')
+			buffer[i] = '_';
+	}
 }
 
 /* must be called with summary_lock held */
 static CamelVeeMessageInfo *
-vee_folder_add(CamelVeeFolder *vf, CamelFolder *f, CamelMessageInfo *info)
+vee_folder_add_info(CamelVeeFolder *vf, CamelFolder *f, CamelMessageInfo *info, const char hash[8])
 {
 	CamelVeeMessageInfo *mi;
 	char *uid;
 	CamelFolder *folder = (CamelFolder *)vf;
 	CamelMessageInfo *dinfo;
 
-	uid = g_strdup_printf("%p:%s", f, camel_message_info_uid(info));
-	/* FIXME: Has races */
+	uid = g_strdup_printf("%.8s%s", hash, camel_message_info_uid(info));
 	dinfo = camel_folder_summary_uid(folder->summary, uid);
 	if (dinfo) {
+		(printf("w:clash, we already have '%s' in summary\n", uid));
 		g_free(uid);
 		camel_folder_summary_info_free(folder->summary, dinfo);
 		return NULL;
 	}
 
+	d(printf("adding uid %s to %s\n", uid, vf->vname));
+
 	mi = (CamelVeeMessageInfo *)camel_folder_summary_info_new(folder->summary);
 	camel_message_info_dup_to(info, (CamelMessageInfo *)mi);
 #ifdef DOESTRV
@@ -384,7 +544,7 @@ vee_folder_add(CamelVeeFolder *vf, CamelFolder *f, CamelMessageInfo *info)
 #else	
 	g_free(mi->info.uid);
 	mi->info.uid = uid;
-#endif		
+#endif
 	mi->folder = f;
 	camel_folder_summary_add(folder->summary, (CamelMessageInfo *)mi);
 
@@ -393,163 +553,362 @@ vee_folder_add(CamelVeeFolder *vf, CamelFolder *f, CamelMessageInfo *info)
 
 /* must be called with summary_lock held */
 static CamelVeeMessageInfo *
-vee_folder_add_uid(CamelVeeFolder *vf, CamelFolder *f, const char *inuid)
+vee_folder_add_uid(CamelVeeFolder *vf, CamelFolder *f, const char *inuid, const char hash[8])
 {
 	CamelMessageInfo *info;
 	CamelVeeMessageInfo *mi = NULL;
 
 	info = camel_folder_get_message_info(f, inuid);
 	if (info) {
-		if ((mi = vee_folder_add(vf, f, info)))
-			if (vf != folder_unmatched)
-				unmatched_uid_add(inuid, f);
-
+		mi = vee_folder_add_info(vf, f, info, hash);
 		camel_folder_free_message_info(f, info);
 	}
 	return mi;
 }
 
-/* must be called with summary_lock held */
 static void
-vfolder_remove_match(CamelVeeFolder *vf, CamelVeeMessageInfo *vinfo)
+vee_folder_remove_folder(CamelVeeFolder *vf, CamelFolder *source)
 {
-	const char *uid = camel_message_info_uid(vinfo);
+	int i, count, n, still;
+	char *oldkey;
+	CamelFolder *folder = (CamelFolder *)vf;
+	char hash[8];
+	struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);
+
+	if (vf == folder_unmatched)
+		return;
 
-	printf("removing match %s\n", uid);
+	/* check if this folder is still to be part of unmatched */
+	if ((vf->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0) {
+		CAMEL_VEE_FOLDER_LOCK(folder_unmatched, subfolder_lock);
+		still = g_list_find(p->folders, source) != NULL;
+		CAMEL_VEE_FOLDER_UNLOCK(folder_unmatched, subfolder_lock);
+		hash_folder(source, hash);
+	} else {
+		still = FALSE;
+	}
+
+	CAMEL_VEE_FOLDER_LOCK(vf, summary_lock);
+	CAMEL_VEE_FOLDER_LOCK(folder_unmatched, summary_lock);
+
+	count = camel_folder_summary_count(folder->summary);
+	for (i=0;i<count;i++) {
+		CamelVeeMessageInfo *mi = (CamelVeeMessageInfo *)camel_folder_summary_index(folder->summary, i);
+		if (mi) {
+			if (mi->folder == source) {
+				const char *uid = camel_message_info_uid(mi);
 
-	unmatched_uid_remove(strchr(uid, ':'), vinfo->folder);
+				camel_folder_change_info_remove_uid(vf->changes, uid);
+				camel_folder_summary_remove_index(folder->summary, i);
+				i--;
+				if ((vf->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0) {
+					if (still) {
+						if (g_hash_table_lookup_extended(unmatched_uids, uid, (void **)&oldkey, (void **)&n)) {
+							if (n == 1) {
+								g_hash_table_remove(unmatched_uids, oldkey);
+								if (vee_folder_add_uid(folder_unmatched, source, oldkey+8, hash))
+									camel_folder_change_info_add_uid(folder_unmatched->changes, oldkey);
+								g_free(oldkey);
+							} else {
+								g_hash_table_insert(unmatched_uids, oldkey, (void *)(n-1));
+							}
+						}
+					} else {
+						if (g_hash_table_lookup_extended(unmatched_uids, camel_message_info_uid(mi), (void **)&oldkey, (void **)&n)) {
+							g_hash_table_remove(unmatched_uids, oldkey);
+							g_free(oldkey);
+						}
+						camel_folder_summary_remove_uid(((CamelFolder *)folder_unmatched)->summary, uid);
+					}
+				}
+			}
+			camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
+		}
+	}
+
+	if (camel_folder_change_info_changed(vf->changes)) {
+		camel_object_trigger_event((CamelObject *)vf, "folder_changed", vf->changes);
+		camel_folder_change_info_clear(vf->changes);
+	}
+
+	if (camel_folder_change_info_changed(folder_unmatched->changes)) {
+		camel_object_trigger_event((CamelObject *)vf, "folder_changed", folder_unmatched->changes);
+		camel_folder_change_info_clear(folder_unmatched->changes);
+	}
+
+	CAMEL_VEE_FOLDER_UNLOCK(folder_unmatched, summary_lock);
+	CAMEL_VEE_FOLDER_UNLOCK(vf, summary_lock);
 
-	camel_folder_change_info_remove_uid(vf->changes, uid);
-	camel_folder_summary_remove(((CamelFolder *)vf)->summary, (CamelMessageInfo *)vinfo);
 }
 
-/* must be called with summary_lock held */
-static CamelVeeMessageInfo *
-vee_folder_add_change(CamelVeeFolder *vf, CamelFolder *f, CamelMessageInfo *info)
-{
-	CamelVeeMessageInfo *mi = NULL;
+struct _update_data {
+	CamelFolder *source;
+	CamelVeeFolder *vf;
+	char hash[8];
+};
 
-	mi = vee_folder_add(vf, f, info);
-	if (mi) {
-		unmatched_uid_add(camel_message_info_uid(info), f);
+static void
+unmatched_check_uid(char *uidin, void *value, struct _update_data *u)
+{
+	char *uid;
+	int n;
 
-		camel_folder_change_info_add_uid(vf->changes, camel_message_info_uid(mi));
+	uid = alloca(strlen(uidin)+9);
+	sprintf(uid, "%.8s%s", u->hash, uidin);
+	n = (int)g_hash_table_lookup(unmatched_uids, uid);
+	if (n == 0) {
+		if (vee_folder_add_uid(folder_unmatched, u->source, uidin, u->hash))
+			camel_folder_change_info_add_uid(folder_unmatched->changes, uid);
+	} else {
+		CamelVeeMessageInfo *mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(((CamelFolder *)folder_unmatched)->summary, uid);
+		if (mi) {
+			camel_folder_summary_remove(((CamelFolder *)folder_unmatched)->summary, (CamelMessageInfo *)mi);
+			camel_folder_change_info_remove_uid(folder_unmatched->changes, uid);
+			camel_folder_summary_info_free(((CamelFolder *)folder_unmatched)->summary, (CamelMessageInfo *)mi);
+		}
 	}
-	
-	return mi;
 }
 
-/* must be called with summary_lock held */
 static void
-vfolder_change_match(CamelVeeFolder *vf, CamelVeeMessageInfo *vinfo, const CamelMessageInfo *info)
+folder_added_uid(char *uidin, void *value, struct _update_data *u)
 {
-	CamelFlag *flag;
-	CamelTag *tag;
+	CamelVeeMessageInfo *mi;
+	char *oldkey;
+	int n;
 
-	d(printf("changing match %s\n", camel_message_info_uid(vinfo)));
+	if ( (mi = vee_folder_add_uid(u->vf, u->source, uidin, u->hash)) ) {
+		camel_folder_change_info_add_uid(u->vf->changes, camel_message_info_uid(mi));
 
-	vinfo->info.flags = info->flags;
-	camel_flag_list_free(&vinfo->info.user_flags);
-	flag = info->user_flags;
-	while (flag) {
-		camel_flag_set(&vinfo->info.user_flags, flag->name, TRUE);
-		flag = flag->next;
-	}
-	camel_tag_list_free(&vinfo->info.user_tags);
-	tag = info->user_tags;
-	while (tag) {
-		camel_tag_set(&vinfo->info.user_tags, tag->name, tag->value);
-		tag = tag->next;
+		if (g_hash_table_lookup_extended(unmatched_uids, camel_message_info_uid(mi), (void **)&oldkey, (void **)&n)) {
+			g_hash_table_insert(unmatched_uids, oldkey, (void *)(n+1));
+		} else {
+			g_hash_table_insert(unmatched_uids, g_strdup(camel_message_info_uid(mi)), (void *)1);
+		}
 	}
-	camel_folder_change_info_change_uid(vf->changes, camel_message_info_uid(vinfo));
 }
 
-/* track changes to the unmatched folders */
-static void
-unmatched_finalise(CamelFolder *sub, gpointer type, CamelVeeFolder *vf)
+/* build query contents for a single folder */
+static int
+vee_folder_build_folder(CamelVeeFolder *vf, CamelFolder *source, CamelException *ex)
 {
-	int count, i;
+	GPtrArray *match, *all;
+	GHashTable *allhash, *matchhash;
+	CamelFolder *f = source;
+	CamelFolder *folder = (CamelFolder *)vf;
+	int i, n, count;
+	struct _update_data u;
+
+	if (vf == folder_unmatched)
+		return 0;
+
+	match = camel_folder_search_by_expression(f, vf->expression, ex);
+	if (match == NULL)
+		return -1;
+
+	u.source = source;
+	u.vf = vf;
+	hash_folder(source, u.hash);
 
 	CAMEL_VEE_FOLDER_LOCK(vf, summary_lock);
-	UNMATCHED_LOCK();
 
+	/* we build 2 hash tables, one for all uid's not matched, the other for all matched uid's,
+	   we just ref the real memory */
+	matchhash = g_hash_table_new(g_str_hash, g_str_equal);
+	for (i=0;i<match->len;i++)
+		g_hash_table_insert(matchhash, match->pdata[i], (void *)1);
+
+	allhash = g_hash_table_new(g_str_hash, g_str_equal);
+	all = camel_folder_get_uids(f);
+	for (i=0;i<all->len;i++)
+		if (g_hash_table_lookup(matchhash, all->pdata[i]) == NULL)
+			g_hash_table_insert(allhash, all->pdata[i], (void *)1);
+
+	CAMEL_VEE_FOLDER_LOCK(folder_unmatched, summary_lock);
+
+	/* scan, looking for "old" uid's to be removed */
+	count = camel_folder_summary_count(folder->summary);
+	for (i=0;i<count;i++) {
+		CamelVeeMessageInfo *mi = (CamelVeeMessageInfo *)camel_folder_summary_index(folder->summary, i);
+
+		if (mi) {
+			if (mi->folder == source) {
+				char *uid = (char *)camel_message_info_uid(mi), *oldkey;
+
+				if (g_hash_table_lookup(matchhash, uid+8) == NULL) {
+					camel_folder_summary_remove_index(folder->summary, i);
+					camel_folder_change_info_remove_uid(vf->changes, camel_message_info_uid(mi));
+					i--;
+					if (g_hash_table_lookup_extended(unmatched_uids, uid, (void **)&oldkey, (void **)&n)) {
+						if (n == 1) {
+							g_hash_table_remove(unmatched_uids, oldkey);
+							g_free(oldkey);
+						} else {
+							g_hash_table_insert(unmatched_uids, oldkey, (void *)(n-1));
+						}
+					}
+				} else {
+					g_hash_table_remove(matchhash, uid+8);
+				}
+			}
+			camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
+		}
+	}
+
+	/* now matchhash contains any new uid's, add them, etc */
+	g_hash_table_foreach(matchhash, (GHFunc)folder_added_uid, &u);
+
+	/* scan unmatched, remove any that have vanished, etc */
 	count = camel_folder_summary_count(((CamelFolder *)folder_unmatched)->summary);
 	for (i=0;i<count;i++) {
 		CamelVeeMessageInfo *mi = (CamelVeeMessageInfo *)camel_folder_summary_index(((CamelFolder *)folder_unmatched)->summary, i);
-		const char *uid;
-		char *oldkey;
-		int n;
 
 		if (mi) {
-			uid = camel_message_info_uid(mi);
-			if (mi->folder == sub) {
-				if (g_hash_table_lookup_extended(unmatched_uids, uid, (void **)&oldkey, (void **)&n)) {
-					if (n == 1)
-						g_hash_table_remove(unmatched_uids, oldkey);
-					else
-						camel_folder_change_info_remove_uid(folder_unmatched->changes, uid);
+			if (mi->folder == source) {
+				char *uid = (char *)camel_message_info_uid(mi);
+
+				if (g_hash_table_lookup(allhash, uid+8) == NULL) {
+					/* no longer exists at all, just remove it entirely */
+					camel_folder_summary_remove_index(((CamelFolder *)folder_unmatched)->summary, i);
+					camel_folder_change_info_remove_uid(folder_unmatched->changes, camel_message_info_uid(mi));
+					i--;
+				} else {
+					g_hash_table_remove(allhash, uid+8);
 				}
-				camel_folder_summary_remove(((CamelFolder *)folder_unmatched)->summary, (CamelMessageInfo *)mi);
-				i--;
 			}
 			camel_folder_summary_info_free(((CamelFolder *)folder_unmatched)->summary, (CamelMessageInfo *)mi);
 		}
 	}
-	
+
+	/* now allhash contains all potentially new uid's for the unmatched folder, process */
+	g_hash_table_foreach(allhash, (GHFunc)unmatched_check_uid, &u);
+
+	CAMEL_VEE_FOLDER_UNLOCK(folder_unmatched, summary_lock);
+
+	g_hash_table_destroy(matchhash);
+	g_hash_table_destroy(allhash);
+	camel_folder_search_free(f, match);
+	camel_folder_free_uids(f, all);
+
 	if (camel_folder_change_info_changed(folder_unmatched->changes)) {
 		camel_object_trigger_event((CamelObject *)folder_unmatched, "folder_changed", folder_unmatched->changes);
 		camel_folder_change_info_clear(folder_unmatched->changes);
 	}
 
-	UNMATCHED_UNLOCK();
+
+	if (camel_folder_change_info_changed(vf->changes)) {
+		camel_object_trigger_event((CamelObject *)vf, "folder_changed", vf->changes);
+		camel_folder_change_info_clear(vf->changes);
+	}
+
 	CAMEL_VEE_FOLDER_UNLOCK(vf, summary_lock);
+
+	return 0;
 }
 
-/* FIXME: This code is a big race, as it is never called locked ... */
+/*
+
+  (match-folder "folder1" "folder2")
+
+ */
+
 
+/* must be called with summary_lock held */
 static void
-folder_changed(CamelFolder *sub, gpointer type, CamelVeeFolder *vf)
+vee_folder_change_match(CamelVeeFolder *vf, CamelVeeMessageInfo *vinfo, const CamelMessageInfo *info)
+{
+	CamelFlag *flag;
+	CamelTag *tag;
+
+	d(printf("changing match %s\n", camel_message_info_uid(vinfo)));
+
+	vinfo->info.flags = info->flags;
+	camel_flag_list_free(&vinfo->info.user_flags);
+	flag = info->user_flags;
+	while (flag) {
+		camel_flag_set(&vinfo->info.user_flags, flag->name, TRUE);
+		flag = flag->next;
+	}
+	camel_tag_list_free(&vinfo->info.user_tags);
+	tag = info->user_tags;
+	while (tag) {
+		camel_tag_set(&vinfo->info.user_tags, tag->name, tag->value);
+		tag = tag->next;
+	}
+	camel_folder_change_info_change_uid(vf->changes, camel_message_info_uid(vinfo));
+}
+
+static void
+folder_changed(CamelFolder *sub, CamelFolderChangeInfo *changes, CamelVeeFolder *vf)
 {
-	CamelFolderChangeInfo *changes = type;
 	CamelFolder *folder = (CamelFolder *)vf;
-	char *vuid;
+	char *vuid, hash[8];
 	CamelVeeMessageInfo *vinfo;
 	int i;
 	CamelMessageInfo *info;
+	char *oldkey;
+	int n;
 
-	printf("folder_changed(%p, %p) (for %s)\n", sub, vf, vf->expression);
+	hash_folder(sub, hash);
 
-	/* if not auto-updating, only propagate changed events, not added/removed items */
+	/* if not auto-updating, only propagate changed/removed events, not added items */
 	if ((vf->flags & CAMEL_STORE_VEE_FOLDER_AUTO) == 0) {
 		CAMEL_VEE_FOLDER_LOCK(vf, summary_lock);
+		CAMEL_VEE_FOLDER_LOCK(folder_unmatched, summary_lock);
 
 		for (i=0;i<changes->uid_changed->len;i++) {
 			info = camel_folder_get_message_info(sub, changes->uid_changed->pdata[i]);
-			vuid = g_strdup_printf("%p:%s", sub, (char *)changes->uid_changed->pdata[i]);
+			vuid = g_strdup_printf("%.8s%s", hash, (char *)changes->uid_changed->pdata[i]);
 			vinfo = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, vuid);
 			if (vinfo && info)
-				vfolder_change_match(vf, vinfo, info);
-			
+				vee_folder_change_match(vf, vinfo, info);
 			g_free(vuid);
-			
 			if (info)
 				camel_folder_free_message_info(sub, info);
 			if (vinfo)
 				camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)vinfo);
 		}
 
+		for (i=0;i<changes->uid_removed->len;i++) {
+			vuid = g_strdup_printf("%.8s%s", hash, (char *)changes->uid_changed->pdata[i]);
+			vinfo = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, vuid);
+			if (vinfo) {
+				camel_folder_change_info_remove_uid(vf->changes, vuid);
+				camel_folder_summary_remove(folder->summary, (CamelMessageInfo *)vinfo);
+				camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)vinfo);
+
+				if ((vf->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0) {
+					if (g_hash_table_lookup_extended(unmatched_uids, vuid, (void **)&oldkey, (void **)&n)) {
+						g_hash_table_remove(unmatched_uids, oldkey);
+						g_free(oldkey);
+					}
+					camel_folder_summary_remove_uid(((CamelFolder *)folder_unmatched)->summary, vuid);
+				}
+
+			}
+			g_free(vuid);
+		}
+
 		if (camel_folder_change_info_changed(vf->changes)) {
 			camel_object_trigger_event((CamelObject *)vf, "folder_changed", vf->changes);
 			camel_folder_change_info_clear(vf->changes);
 		}
 
+		if (camel_folder_change_info_changed(folder_unmatched->changes)) {
+			camel_object_trigger_event((CamelObject *)folder_unmatched, "folder_changed", folder_unmatched->changes);
+			camel_folder_change_info_clear(folder_unmatched->changes);
+		}
+
+		CAMEL_VEE_FOLDER_UNLOCK(folder_unmatched, summary_lock);
 		CAMEL_VEE_FOLDER_UNLOCK(vf, summary_lock);
 
 		return;
 	}
 
 	/* if we are autoupdating, then do the magic */
+	/* FIXME: This should be optimised to be incremental, but its just too much work right now to validate it */
+	vee_folder_build_folder(vf, sub, NULL);
 
+#if 0
 	/* assume its faster to search a long list in whole, than by part */
 	if (changes && (changes->uid_added->len + changes->uid_changed->len) < 500) {
 		gboolean match;
@@ -564,10 +923,8 @@ folder_changed(CamelFolder *sub, gpointer type, CamelVeeFolder *vf)
 
 		/* see if added ones now match us */
 		for (i=0;i<changes->uid_added->len;i++) {
-			printf("checking new uid: %s\n", (char *)changes->uid_added->pdata[i]);
 			info = camel_folder_get_message_info(sub, changes->uid_added->pdata[i]);
 			if (info) {
-				printf("uid ok, subject: %s\n", camel_message_info_subject(info));
 				camel_folder_search_set_folder(vf->search, sub);
 				match = camel_folder_search_match_expression(vf->search, vf->expression, info, NULL);
 				if (match)
@@ -614,182 +971,19 @@ folder_changed(CamelFolder *sub, gpointer type, CamelVeeFolder *vf)
 	} else {
 		vee_folder_build_folder(vf, sub, NULL);
 	}
-
-	/* cascade up, if we need to */
-	if (camel_folder_change_info_changed(vf->changes)) {
-		printf("got folder changes\n");
-		camel_object_trigger_event( CAMEL_OBJECT(vf), "folder_changed", vf->changes);
-		camel_folder_change_info_clear(vf->changes);
-	} else
-		printf("no, we didn't really get any changes\n");
-
-	CAMEL_VEE_FOLDER_UNLOCK(vf, summary_lock);
-
-	UNMATCHED_LOCK();
-
-	if (camel_folder_change_info_changed(folder_unmatched->changes)) {
-		camel_object_trigger_event((CamelObject *)folder_unmatched, "folder_changed", folder_unmatched->changes);
-		camel_folder_change_info_clear(folder_unmatched->changes);
-	}
-
-	UNMATCHED_UNLOCK();
+#endif
 }
 
-/* FIXME: This code is a race, as it is never called locked */
-
-/* track flag changes in the summary */
+/* track flag changes in the summary, we just promote it to a folder_changed event */
 static void
 message_changed(CamelFolder *f, const char *uid, CamelVeeFolder *vf)
 {
-	CamelMessageInfo *info;
-	CamelVeeMessageInfo *vinfo;
-	char *vuid;
-	CamelFolder *folder = (CamelFolder *)vf;
-	gboolean match;
-
-	CAMEL_VEE_FOLDER_LOCK(vf, summary_lock);
-
-	info = camel_folder_get_message_info(f, uid);
-	vuid = g_strdup_printf("%p:%s", f, uid);
-	vinfo = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, vuid);
-
-	/* see if this message now matches/doesn't match anymore */
+	CamelFolderChangeInfo *changes;
 
-	/* Hmm, this might not work if the folder uses some weird search thing,
-	   and/or can be slow since it wont use any index index, hmmm. */
-
-	if (vf->flags & CAMEL_STORE_VEE_FOLDER_AUTO) {
-		camel_folder_search_set_folder(vf->search, f);
-		
-		match = camel_folder_search_match_expression(vf->search, vf->expression, info, NULL);
-
-		if (info) {
-			if (vinfo) {
-				if (!match)
-					vfolder_remove_match(vf, vinfo);
-				else
-					vfolder_change_match(vf, vinfo, info);
-			}
-			else if (match)
-				vee_folder_add_change(vf, f, info);
-		} else if (vinfo)
-			vfolder_remove_match(vf, vinfo);
-	} else {
-		if (info && vinfo)
-			vfolder_change_match(vf, vinfo, info);
-	}
-
-	if (info)
-		camel_folder_free_message_info(f, info);
-	if (vinfo)
-		camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)vinfo);
-
-	/* cascade up, if required.  This could probably be delayed,
-	   but doesn't matter really, that is what freeze is for. */
-	if (camel_folder_change_info_changed(vf->changes)) {
-		camel_object_trigger_event( CAMEL_OBJECT(vf), "folder_changed", vf->changes);
-		camel_folder_change_info_clear(vf->changes);
-	}
-
-	CAMEL_VEE_FOLDER_UNLOCK(vf, summary_lock);
-
-	UNMATCHED_LOCK();
-
-	if (camel_folder_change_info_changed(folder_unmatched->changes)) {
-		camel_object_trigger_event((CamelObject *)folder_unmatched, "folder_changed", folder_unmatched->changes);
-		camel_folder_change_info_clear(folder_unmatched->changes);
-	}
-
-	UNMATCHED_UNLOCK();
-
-	g_free(vuid);
-}
-
-
-/**
- * camel_vee_folder_remove_folder:
- * @vf: Virtual Folder object
- * @sub: source CamelFolder to remove from @vf
- *
- * Removed the source folder, @sub, from the virtual folder, @vf.
- **/
-void
-camel_vee_folder_remove_folder(CamelVeeFolder *vf, CamelFolder *sub)
-{
-	struct _CamelVeeFolderPrivate *p = _PRIVATE(vf), *up = _PRIVATE(folder_unmatched);
-
-	CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);
-	if (g_list_find(p->folders, sub) == NULL) {
-		CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
-		return;
-	}
-
-	p->folders = g_list_remove(p->folders, sub);
-	up->folders = g_list_remove(up->folders, sub);
-	CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
-
-	/* hrm, should this be run?? */
-	unmatched_finalise(sub, 0, folder_unmatched);
-
-	UNMATCHED_LOCK();
-	if (camel_folder_change_info_changed(folder_unmatched->changes)) {
-		camel_object_trigger_event((CamelObject *)folder_unmatched, "folder_changed", folder_unmatched->changes);
-		camel_folder_change_info_clear(folder_unmatched->changes);
-	}
-	UNMATCHED_UNLOCK();
-
-	CAMEL_VEE_FOLDER_LOCK(vf, summary_lock);
-	vee_folder_remove_folder(vf, sub);
-	if (camel_folder_change_info_changed(vf->changes)) {
-		camel_object_trigger_event((CamelObject *)vf, "folder_changed", vf->changes);
-		camel_folder_change_info_clear(vf->changes);
-	}
-	CAMEL_VEE_FOLDER_UNLOCK(vf, summary_lock);
-}
-
-
-/**
- * camel_vee_folder_add_folder:
- * @vf: Virtual Folder object
- * @sub: source CamelFolder to add to @vf
- *
- * Adds @sub as a source folder to @vf.
- **/
-void
-camel_vee_folder_add_folder(CamelVeeFolder *vf, CamelFolder *sub)
-{
-	struct _CamelVeeFolderPrivate *p = _PRIVATE(vf), *up = _PRIVATE(folder_unmatched);
-
-	camel_object_ref((CamelObject *)sub);
-
-	CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);
-
-	/* the reference is shared with both the real vfolder and the unmatched vfolder */
-	p->folders = g_list_append(p->folders, sub);
-	up->folders = g_list_append(up->folders, sub);
-
-	CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
-
-	d(printf("camel_vee_folder_add_folde(%p, %p)\n", vf, sub));
-
-	camel_object_hook_event((CamelObject *)sub, "folder_changed", (CamelObjectEventHookFunc)folder_changed, vf);
-	camel_object_hook_event((CamelObject *)sub, "message_changed", (CamelObjectEventHookFunc)message_changed, vf);
-
-	CAMEL_VEE_FOLDER_LOCK(vf, summary_lock);
-
-	vee_folder_build_folder(vf, sub, NULL);
-
-	if (camel_folder_change_info_changed(vf->changes)) {
-		camel_object_trigger_event((CamelObject *)vf, "folder_changed", vf->changes);
-		camel_folder_change_info_clear(vf->changes);
-	}
-#if 0
-	/* we'll assume the caller is going to update the whole list after they do this
-	   this may or may not be the right thing to do, but it should be close enough */
-	camel_folder_change_info_clear(vf->changes);
-#endif
-
-	CAMEL_VEE_FOLDER_UNLOCK(vf, summary_lock);
+	changes = camel_folder_change_info_new();
+	camel_folder_change_info_change_uid(changes, uid);
+	folder_changed(f, changes, vf);
+	camel_folder_change_info_free(changes);
 }
 
 
@@ -822,233 +1016,4 @@ camel_vee_folder_get_message_folder (CamelVeeFolder *vf, const gchar *uid)
 	return folder;
 }
 
-static void
-vee_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
-{
-	CamelVeeFolder *vf = (CamelVeeFolder *)folder;
-	struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);
-	GList *node;
 
-	CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);
-
-	node = p->folders;
-	while (node) {
-		CamelFolder *f = node->data;
-
-		camel_folder_sync(f, expunge, ex);
-		if (camel_exception_is_set(ex))
-			break;
-
-		node = node->next;
-	}
-
-	CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
-}
-
-static void
-vee_expunge (CamelFolder *folder, CamelException *ex)
-{
-	CamelVeeFolder *vf = (CamelVeeFolder *)folder;
-	struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);
-	GList *node;
-
-	CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);
-
-	node = p->folders;
-	while (node) {
-		CamelFolder *f = node->data;
-
-		camel_folder_expunge(f, ex);
-		if (camel_exception_is_set(ex))
-			break;
-		vee_folder_build_folder(vf, f, ex);
-		if (camel_exception_is_set(ex))
-			break;
-
-		node = node->next;
-	}
-
-	CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
-}
-
-static CamelMimeMessage *vee_get_message(CamelFolder *folder, const gchar *uid, CamelException *ex)
-{
-	CamelVeeMessageInfo *mi;
-	CamelMimeMessage *msg = NULL;
-
-	mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);
-	if (mi) {
-		msg =  camel_folder_get_message(mi->folder, strchr(camel_message_info_uid(mi), ':') + 1, ex);
-		camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
-	} else {
-		camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID,
-				     "No such message %s in %s", uid,
-				     folder->name);
-	}
-
-	return msg;
-}
-
-static GPtrArray *
-vee_search_by_expression(CamelFolder *folder, const char *expression, CamelException *ex)
-{
-	GList *node;
-	GPtrArray *matches, *result = g_ptr_array_new ();
-	char *expr;
-	CamelVeeFolder *vf = (CamelVeeFolder *)folder;
-	struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);
-
-	CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);
-
-	expr = g_strdup_printf("(and %s %s)", vf->expression, expression);
-	node = p->folders;
-	while (node) {
-		CamelFolder *f = node->data;
-		int i;
-
-		matches = camel_folder_search_by_expression(f, expression, ex);
-		for (i = 0; i < matches->len; i++) {
-			char *uid = matches->pdata[i];
-			g_ptr_array_add(result, g_strdup_printf("%p:%s", f, uid));
-		}
-		camel_folder_search_free(f, matches);
-		node = g_list_next(node);
-	}
-
-	CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
-
-	return result;
-}
-
-static void
-vee_set_message_flags(CamelFolder *folder, const char *uid, guint32 flags, guint32 set)
-{
-	CamelVeeMessageInfo *mi;
-
-	mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);
-	if (mi) {
-		((CamelFolderClass *)camel_vee_folder_parent)->set_message_flags(folder, uid, flags, set);
-		camel_folder_set_message_flags(mi->folder, strchr(camel_message_info_uid(mi), ':') + 1, flags, set);
-		camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
-	}
-}
-
-static void
-vee_set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value)
-{
-	CamelVeeMessageInfo *mi;
-
-	mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);
-	if (mi) {
-		((CamelFolderClass *)camel_vee_folder_parent)->set_message_user_flag(folder, uid, name, value);
-		camel_folder_set_message_user_flag(mi->folder, strchr(camel_message_info_uid(mi), ':') + 1, name, value);
-		camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
-	}
-}
-
-static void
-vee_move_message_to(CamelFolder *folder, const char *uid, CamelFolder *dest, CamelException *ex)
-{
-	CamelVeeMessageInfo *mi;
-
-	mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);
-	if (mi) {
-		/* noop if it we're moving from the same vfolder (uh, which should't happen but who knows) */
-		if (folder != mi->folder) {
-			camel_folder_move_message_to(mi->folder, strchr(camel_message_info_uid(mi), ':')+1, dest, ex);
-		}
-		camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
-	} else {
-		camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID, _("No such message: %s"), uid);
-	}
-}
-
-static void
-removed_uid(void *key, void *value, void *data)
-{
-	unmatched_uid_check(key, data);
-}
-
-static void
-vee_folder_remove_folder(CamelVeeFolder *vf, CamelFolder *source)
-{
-	int i, count;
-	CamelFolder *folder = (CamelFolder *)vf;
-
-	count = camel_folder_summary_count(folder->summary);
-	for (i=0;i<count;i++) {
-		CamelVeeMessageInfo *mi = (CamelVeeMessageInfo *)camel_folder_summary_index(folder->summary, i);
-		if (mi) {
-			if (mi->folder == source) {
-				camel_folder_change_info_remove_uid(vf->changes, camel_message_info_uid(mi));
-				camel_folder_summary_remove(folder->summary, (CamelMessageInfo *)mi);
-				i--;
-			}
-			camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
-		}
-	}
-}
-
-/* build query contents for a single folder */
-/* must have summary_lock held when calling */
-static void
-vee_folder_build_folder(CamelVeeFolder *vf, CamelFolder *source, CamelException *ex)
-{
-	GPtrArray *matches, *all;
-	GHashTable *left;
-	CamelFolder *f = source;
-	CamelVeeMessageInfo *mi;
-	CamelFolder *folder = (CamelFolder *)vf;
-	int i;
-	int count;
-
-	left = g_hash_table_new(g_str_hash, g_str_equal);
-	all = camel_folder_get_uids(f);
-	for (i=0;i<all->len;i++)
-		g_hash_table_insert(left, all->pdata[i], (void *)1);
-
-	count = camel_folder_summary_count(folder->summary);
-	for (i=0;i<count;i++) {
-		CamelVeeMessageInfo *mi = (CamelVeeMessageInfo *)camel_folder_summary_index(folder->summary, i);
-		if (mi) {
-			if (mi->folder == source) {
-				camel_folder_change_info_add_source(vf->changes, camel_message_info_uid(mi));
-				camel_folder_summary_remove(folder->summary, (CamelMessageInfo *)mi);
-				unmatched_uid_remove(camel_message_info_uid(mi), source);
-				i--;
-			}
-			camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
-		}
-	}
-
-	printf("searching folder with expression %s\n", vf->expression);
-
-	matches = camel_folder_search_by_expression(f, vf->expression, ex);
-	for (i = 0; i < matches->len; i++) {
-		g_hash_table_remove(left, matches->pdata[i]);
-		mi = vee_folder_add_uid(vf, f, matches->pdata[i]);
-		printf("adding match %s\n", matches->pdata[i]);
-		if (mi)
-			camel_folder_change_info_add_update(vf->changes, camel_message_info_uid(mi));
-	}
-
-	/* check if we have a match for these in another vfolder, else add them to the UNMATCHED folder */
-	g_hash_table_foreach(left, removed_uid, source);
-	g_hash_table_destroy(left);
-	camel_folder_search_free(f, matches);
-	camel_folder_free_uids(f, all);
-
-	camel_folder_change_info_build_diff(vf->changes);
-	camel_folder_change_info_build_diff(folder_unmatched->changes);
-
-	if (camel_folder_change_info_changed(folder_unmatched->changes)) {
-		camel_object_trigger_event((CamelObject *)folder_unmatched, "folder_changed", folder_unmatched->changes);
-		camel_folder_change_info_clear(folder_unmatched->changes);
-	}
-}
-
-/*
-
-  (match-folder "folder1" "folder2")
-
- */
diff --git a/camel/camel-vee-folder.h b/camel/camel-vee-folder.h
index 0cb16c98dd..b410bc26dc 100644
--- a/camel/camel-vee-folder.h
+++ b/camel/camel-vee-folder.h
@@ -38,7 +38,6 @@ struct _CamelVeeFolder {
 
 	char *expression;	/* query expression */
 	char *vname;		/* local name */
-	CamelFolder *local;	/* local storage for folder */
 
 	guint32 flags;		/* folder open flags */
 
@@ -50,12 +49,14 @@ struct _CamelVeeFolderClass {
 	CamelFolderClass parent_class;
 };
 
-guint		camel_vee_folder_get_type	(void);
-CamelFolder    *camel_vee_folder_new		(CamelStore *parent_store, const char *name,
-						 guint32 flags, CamelException *ex);
+guint	      camel_vee_folder_get_type		(void);
+CamelFolder  *camel_vee_folder_new		(CamelStore *parent_store, const char *name, guint32 flags);
+void         camel_vee_folder_construct		(CamelVeeFolder *vf, CamelStore *parent_store, const char *name, guint32 flags);
 
 void         camel_vee_folder_add_folder         (CamelVeeFolder *vf, CamelFolder *sub);
 void         camel_vee_folder_remove_folder      (CamelVeeFolder *vf, CamelFolder *sub);
+void	     camel_vee_folder_set_expression	 (CamelVeeFolder *vf, const char *expr);
+
 CamelFolder *camel_vee_folder_get_message_folder (CamelVeeFolder *vf, const char *uid);
 
 #endif /* ! _CAMEL_VEE_FOLDER_H */
diff --git a/camel/camel-vee-store.c b/camel/camel-vee-store.c
index 38d535dbee..5a9d79d8b2 100644
--- a/camel/camel-vee-store.c
+++ b/camel/camel-vee-store.c
@@ -22,17 +22,21 @@
 #include "camel-vee-store.h"
 #include "camel-vee-folder.h"
 
+#include <string.h>
+
 static CamelFolder *vee_get_folder (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex);
 static void vee_init_trash (CamelStore *store);
 static CamelFolder *vee_get_trash  (CamelStore *store, CamelException *ex);
 
 struct _CamelVeeStorePrivate {
+	CamelFolderInfo *folder_info;
 };
 
 #define _PRIVATE(o) (((CamelVeeStore *)(o))->priv)
 
 static void camel_vee_store_class_init (CamelVeeStoreClass *klass);
 static void camel_vee_store_init       (CamelVeeStore *obj);
+static void camel_vee_store_finalise   (CamelObject *obj);
 
 static CamelStoreClass *camel_vee_store_parent;
 
@@ -48,14 +52,13 @@ camel_vee_store_get_type (void)
 					    (CamelObjectClassInitFunc) camel_vee_store_class_init,
 					    NULL,
 					    (CamelObjectInitFunc) camel_vee_store_init,
-					    NULL);
+					    (CamelObjectFinalizeFunc) camel_vee_store_finalise);
 	}
 	
 	return type;
 }
 
 static void
-
 camel_vee_store_class_init (CamelVeeStoreClass *klass)
 {
 	CamelStoreClass *store_class = (CamelStoreClass *) klass;
@@ -76,6 +79,14 @@ camel_vee_store_init (CamelVeeStore *obj)
 	p = _PRIVATE(obj) = g_malloc0(sizeof(*p));
 }
 
+static void
+camel_vee_store_finalise (CamelObject *obj)
+{
+	CamelVeeStore *vs = (CamelVeeStore *)obj;
+
+	g_free(vs->priv);
+}
+
 /**
  * camel_vee_store_new:
  *
@@ -86,14 +97,33 @@ camel_vee_store_init (CamelVeeStore *obj)
 CamelVeeStore *
 camel_vee_store_new (void)
 {
-	CamelVeeStore *new = CAMEL_VEE_STORE ( camel_object_new (camel_vee_store_get_type ()));
+	CamelVeeStore *new = CAMEL_VEE_STORE(camel_object_new(camel_vee_store_get_type ()));
 	return new;
 }
 
 static CamelFolder *
 vee_get_folder (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex)
 {
-	return camel_vee_folder_new(store, folder_name, flags, ex);
+	CamelFolderInfo *fi;
+	CamelVeeFolder *vf;
+	char *name;
+
+	vf = (CamelVeeFolder *)camel_vee_folder_new(store, folder_name, flags);
+	if ((vf->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0) {
+		fi = g_malloc0(sizeof(*fi));
+		fi->full_name = g_strdup(vf->vname);
+		name = strrchr(vf->vname, '/');
+		if (name == NULL)
+			name = vf->vname;
+		fi->name = g_strdup(name);
+		fi->url = g_strdup_printf("vfolder:%s", vf->vname);
+		fi->unread_message_count = -1;
+	
+		camel_object_trigger_event(CAMEL_OBJECT(store), "folder_created", fi);
+		camel_folder_info_free(fi);
+	}
+
+	return (CamelFolder *)vf;
 }
 
 static void