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

1 files changed, 184 insertions, 2 deletions

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