+2001-09-14 <NotZed@Ximian.com>
+
+ * camel-vee-folder.c (camel_vee_folder_set_folders): New function,
+ set the complete list of folders on a vfolder, all at once.
+ (camel_vee_folder_set_expression): If we set the query to be the
+ same thing, dont do anything.
+
+ * camel-vee-store.c (camel_vee_store_init): Turn off vtrash for
+ this store.
+
+ * camel-store.c (camel_store_init): Enable vtrash by default via
+ flags.
+ (camel_store_get_trash): REturn NULL if the store doesn't support
+ vtrash.
+ (init_trash): Dont init if store doesn't support vtrash.
+
+ * camel-store.h: Add a new flags CAMEL_STORE_VTRASH -> store
+ supports vtrash.
+
+2001-09-13 <NotZed@Ximian.com>
+
+ * camel-vee-store.c (vee_get_folder_info): Implement.
+ (build_info): Used to build a folder record from the folders
+ hashtable.
+ (vee_delete_folder): Implemented, remove folder from hashtable.
+ (vee_rename_folder): Implemented, remove old folder from
+ hashtable, add new one and rename its guts too.
+
+ * camel-store.c (camel_store_rename_folder): Do nothing if we're
+ not asked to actually change names. Also dont do the renamed
+ cache check till after we've called the subclass.
+ (camel_store_delete_folder): Call the subclass delete firs,t then
+ make sure the cache is right.
+
+ * camel-vee-folder.c (vee_folder_construct): Remove support for
+ name?query syntax to setup vfolder. Abort if such syntax is used.
+ (camel_vee_folder_new): Removed code that handles ? syntax, etc.
+ (vee_folder_build_folder): Handle unset expression, treat it as an
+ empty search.
+ (camel_vee_folder_set_expression): Oops, actually set the
+ expression.
+
+ * camel-vtrash-folder.c (camel_vtrash_folder_new): Dont use
+ name?query syntax to setup vfolder, but set the expression
+ directly. Also fixes a small memleak.
+
+2001-09-12 <NotZed@Ximian.com>
+
+ * camel-store.c (camel_store_delete_folder): Fixed warnings with a cast.
+ (camel_store_rename_folder): "
+
2001-09-14 Jeffrey Stedfast <fejj@ximian.com>
* camel-url.c (camel_url_set_param): Use g_datalist_set_data_full
} else
store->folders = NULL;
- store->flags = 0;
+ /* set vtrash on by default */
+ store->flags = CAMEL_STORE_VTRASH;
store->priv = g_malloc0 (sizeof (*store->priv));
#ifdef ENABLE_THREADS
if (store->folders) {
CAMEL_STORE_LOCK(store, cache_lock);
+ printf("adding folder '%s' to folders hashtable\n", folder_name);
g_hash_table_insert (store->folders, g_strdup (folder_name), folder);
+ printf("store folders size = %d\n", g_hash_table_size(store->folders));
+
camel_object_hook_event (CAMEL_OBJECT (folder), "finalize", folder_finalize, store);
CAMEL_STORE_UNLOCK(store, cache_lock);
- }
+ } else
+ printf("not adding folder '%s' to folders hashtable\n", folder_name);
}
}
CAMEL_STORE_LOCK(store, folder_lock);
+ CS_CLASS (store)->delete_folder (store, folder_name, ex);
+
/* if we deleted a folder, force it out of the cache, and also out of the vtrash if setup */
if (store->folders) {
CamelFolder *folder;
char *key;
CAMEL_STORE_LOCK(store, cache_lock);
- if (g_hash_table_lookup_extended(store->folders, folder_name, &key, (void **)&folder)) {
+ if (g_hash_table_lookup_extended(store->folders, folder_name, (void **)&key, (void **)&folder)) {
g_hash_table_remove(store->folders, key);
g_free(key);
CAMEL_STORE_UNLOCK(store, cache_lock);
}
}
- CS_CLASS (store)->delete_folder (store, folder_name, ex);
CAMEL_STORE_UNLOCK(store, folder_lock);
}
char *key;
CamelFolder *folder;
+ if (strcmp(old_name, new_name) == 0)
+ return;
+
CAMEL_STORE_LOCK(store, folder_lock);
+ CS_CLASS (store)->rename_folder (store, old_name, new_name, ex);
/* remove the old name from the cache if it is there */
CAMEL_STORE_LOCK(store, cache_lock);
- if (g_hash_table_lookup_extended(store->folders, old_name, &key, (void **)&folder)) {
+ if (g_hash_table_lookup_extended(store->folders, old_name, (void **)&key, (void **)&folder)) {
g_hash_table_remove(store->folders, key);
g_free(key);
}
CAMEL_STORE_UNLOCK(store, cache_lock);
- CS_CLASS (store)->rename_folder (store, old_name, new_name, ex);
CAMEL_STORE_UNLOCK(store, folder_lock);
}
static void
init_trash (CamelStore *store)
{
+ if ((store->flags & CAMEL_STORE_VTRASH) == 0)
+ return;
+
store->vtrash = camel_vtrash_folder_new (store, CAMEL_VTRASH_NAME);
if (store->vtrash) {
camel_store_get_trash (CamelStore *store, CamelException *ex)
{
CamelFolder *folder;
+
+ if ((store->flags & CAMEL_STORE_VTRASH) == 0)
+ return NULL;
CAMEL_STORE_LOCK(store, folder_lock);
folder = CS_CLASS (store)->get_trash (store, ex);
/* Flags for store flags */
-#define CAMEL_STORE_SUBSCRIPTIONS (1 << 0)
+#define CAMEL_STORE_SUBSCRIPTIONS (1 << 0)
+#define CAMEL_STORE_VTRASH (1 << 1)
struct _CamelStore
{
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);
- }
+ /* We dont support ? syntax anymore */
+ g_assert(strchr(name, '?') == NULL);
+ vf->vname = g_strdup(name);
tmp = strrchr(vf->vname, '/');
if (tmp)
tmp++;
camel_vee_folder_new(CamelStore *parent_store, const char *name, guint32 flags)
{
CamelVeeFolder *vf;
- char *path, *query;
UNMATCHED_LOCK();
UNMATCHED_UNLOCK();
- path = alloca(strlen(name)+1);
- strcpy(path, name);
- query = strchr(path, '?');
- if (query)
- *query++ = 0;
-
- if (strcmp(path, "UNMATCHED") == 0) {
+ if (strcmp(name, "UNMATCHED") == 0) {
camel_object_ref((CamelObject *)folder_unmatched);
printf("returning unmatched %p, count = %d\n", folder_unmatched, camel_folder_get_message_count((CamelFolder *)folder_unmatched));
return (CamelFolder *)folder_unmatched;
CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);
+ /* no change, do nothing */
+ if ((vf->expression && query && strcmp(vf->expression, query) == 0)
+ || (vf->expression == NULL && query == NULL)) {
+ CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
+ return;
+ }
+
+ g_free(vf->expression);
+ if (query)
+ vf->expression = g_strdup(query);
+
node = p->folders;
while (node) {
CamelFolder *f = node->data;
camel_object_unref((CamelObject *)sub);
}
+static void
+remove_folders(CamelFolder *folder, CamelFolder *foldercopy, CamelVeeFolder *vf)
+{
+ camel_vee_folder_remove_folder(vf, folder);
+ camel_object_unref((CamelObject *)folder);
+}
+
+/**
+ * camel_vee_folder_set_folders:
+ * @vf:
+ * @folders:
+ *
+ * Set the whole list of folder sources on a vee folder.
+ **/
+void
+camel_vee_folder_set_folders(CamelVeeFolder *vf, GList *folders)
+{
+ GHashTable *remove = g_hash_table_new(NULL, NULL);
+ GList *l;
+ CamelFolder *folder;
+
+ /* setup a table of all folders we have currently */
+ CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);
+ l = vf->priv->folders;
+ while (l) {
+ g_hash_table_insert(remove, l->data, l->data);
+ camel_object_ref((CamelObject *)l->data);
+ l = l->next;
+ }
+ CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);
+
+ /* if we already have the folder, ignore it, otherwise add it */
+ l = folders;
+ while (l) {
+ if ((folder = g_hash_table_lookup(remove, l->data))) {
+ g_hash_table_remove(remove, folder);
+ camel_object_unref((CamelObject *)folder);
+ } else {
+ camel_vee_folder_add_folder(vf, l->data);
+ }
+ l = l->next;
+ }
+
+ /* then remove any we still have */
+ g_hash_table_foreach(remove, (GHFunc)remove_folders, vf);
+ g_hash_table_destroy(remove);
+}
+
/**
* camel_vee_folder_hash_folder:
* @folder:
if (vf == folder_unmatched)
return 0;
- match = camel_folder_search_by_expression(f, vf->expression, ex);
- if (match == NULL)
- return -1;
+ /* if we have no expression, or its been cleared, then act as if no matches */
+ if (vf->expression == NULL) {
+ match = g_ptr_array_new();
+ } else {
+ match = camel_folder_search_by_expression(f, vf->expression, ex);
+ if (match == NULL)
+ return -1;
+ }
u.source = source;
u.vf = vf;
g_hash_table_destroy(matchhash);
g_hash_table_destroy(allhash);
- camel_folder_search_free(f, match);
+ /* if expression not set, we only had a null list */
+ if (vf->expression == NULL)
+ g_ptr_array_free(match, TRUE);
+ else
+ camel_folder_search_free(f, match);
camel_folder_free_uids(f, all);
if (unmatched_changes) {
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_folders (CamelVeeFolder *vf, GList *folders);
void camel_vee_folder_set_expression (CamelVeeFolder *vf, const char *expr);
void camel_vee_folder_hash_folder (CamelFolder *folder, char buffer[8]);
* USA
*/
+#include "camel-exception.h"
#include "camel-vee-store.h"
#include "camel-vee-folder.h"
+#include "camel-private.h"
+
#include <string.h>
static CamelFolder *vee_get_folder (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex);
+static void vee_delete_folder(CamelStore *store, const char *folder_name, CamelException *ex);
+static void vee_rename_folder(CamelStore *store, const char *old, const char *new, CamelException *ex);
static void vee_init_trash (CamelStore *store);
static CamelFolder *vee_get_trash (CamelStore *store, CamelException *ex);
+static CamelFolderInfo *vee_get_folder_info(CamelStore *store, const char *top, guint32 flags, CamelException *ex);
+
struct _CamelVeeStorePrivate {
CamelFolderInfo *folder_info;
};
/* virtual method overload */
store_class->get_folder = vee_get_folder;
+ store_class->rename_folder = vee_rename_folder;
+ store_class->delete_folder = vee_delete_folder;
+ store_class->get_folder_info = vee_get_folder_info;
+ store_class->free_folder_info = camel_store_free_folder_info_full;
+
store_class->init_trash = vee_init_trash;
store_class->get_trash = vee_get_trash;
}
camel_vee_store_init (CamelVeeStore *obj)
{
struct _CamelVeeStorePrivate *p;
+ CamelStore *store = (CamelStore *)obj;
+
+ /* we dont want a vtrash on this one */
+ store->flags &= ~(CAMEL_STORE_VTRASH);
p = _PRIVATE(obj) = g_malloc0(sizeof(*p));
}
{
return NULL;
}
+
+struct _build_info {
+ const char *top;
+ guint32 flags;
+ GPtrArray *infos;
+};
+
+static void
+build_info(char *name, CamelVeeFolder *folder, struct _build_info *data)
+{
+ CamelFolderInfo *info;
+
+ /* check we have to include this one */
+ if (data->top) {
+ if (data->flags & CAMEL_STORE_FOLDER_INFO_RECURSIVE) {
+ if (strncmp(name, data->top, strlen(data->top) != 0))
+ return;
+ } else {
+ if (strcmp(name, data->top))
+ return;
+ }
+ } else {
+ if ((data->flags & CAMEL_STORE_FOLDER_INFO_RECURSIVE) == 0) {
+ if (strchr(name, '/'))
+ return;
+ }
+ }
+
+ info = g_malloc0(sizeof(*info));
+ info->url = g_strdup_printf("vfolder:%s#%s", ((CamelService *)((CamelFolder *)folder)->parent_store)->url->path,
+ ((CamelFolder *)folder)->full_name);
+ info->full_name = g_strdup(((CamelFolder *)folder)->full_name);
+ info->name = g_strdup(((CamelFolder *)folder)->name);
+ info->unread_message_count = camel_folder_get_unread_message_count((CamelFolder *)folder);
+ g_ptr_array_add(data->infos, info);
+}
+
+static CamelFolderInfo *
+vee_get_folder_info(CamelStore *store, const char *top, guint32 flags, CamelException *ex)
+{
+ struct _build_info data;
+ CamelFolderInfo *info;
+
+ /* first, build the info list */
+ data.top = top;
+ data.flags = flags;
+ data.infos = g_ptr_array_new();
+ CAMEL_STORE_LOCK(store, cache_lock);
+ g_hash_table_foreach(store->folders, (GHFunc)build_info, &data);
+ CAMEL_STORE_UNLOCK(store, cache_lock);
+
+ /* and always add UNMATCHED, if scanning from top/etc */
+ if (top == NULL || top[0] == 0 || strncmp(top, "UNMATCHED", strlen("UNMATCHED")) == 0) {
+ info = g_malloc0(sizeof(*info));
+ info->url = g_strdup_printf("vfolder:%s#UNMATCHED", ((CamelService *)store)->url->path);
+ info->full_name = g_strdup("UNMATCHED");
+ info->name = g_strdup("UNMATCHED");
+ info->unread_message_count = -1;
+ g_ptr_array_add(data.infos, info);
+ }
+
+ /* convert it into a tree */
+ info = camel_folder_info_build(data.infos, (top&&top[0])?top:"", '/', TRUE);
+ g_ptr_array_free(data.infos, TRUE);
+
+ return info;
+}
+
+static void
+vee_delete_folder(CamelStore *store, const char *folder_name, CamelException *ex)
+{
+ CamelFolder *folder;
+ char *key;
+
+ if (strcmp(folder_name, "UNMATCHED") == 0) {
+ camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
+ _("Cannot delete folder: %s: Invalid operation"), folder_name);
+ return;
+ }
+
+ CAMEL_STORE_LOCK(store, cache_lock);
+ if (g_hash_table_lookup_extended(store->folders, folder_name, (void **)&key, (void **)&folder)) {
+ int update;
+
+ update = (((CamelVeeFolder *)folder)->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0;
+ g_hash_table_remove(store->folders, key);
+ CAMEL_STORE_UNLOCK(store, cache_lock);
+ if (store->vtrash)
+ camel_vee_folder_remove_folder((CamelVeeFolder *)store->vtrash, folder);
+
+ /* FIXME: deleted event shoudl just pass out the folder name, not all this shit?? */
+ if (update) {
+ CamelFolderInfo *fi = g_malloc0(sizeof(*fi));
+
+ fi->full_name = g_strdup(key);
+ fi->name = strrchr(key, '/');
+ if (fi->name == NULL)
+ fi->name = g_strdup(key);
+ else
+ fi->name = g_strdup(fi->name);
+ fi->url = g_strdup_printf("vfolder:%s#%s", ((CamelService *)store)->url->path, key);
+ fi->unread_message_count = -1;
+
+ camel_object_trigger_event(CAMEL_OBJECT(store), "folder_deleted", fi);
+ camel_folder_info_free(fi);
+ }
+ g_free(key);
+ } else {
+ CAMEL_STORE_UNLOCK(store, cache_lock);
+
+ camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
+ _("Cannot delete folder: %s: No such folder"), folder_name);
+ }
+}
+
+static void
+vee_rename_folder(CamelStore *store, const char *old, const char *new, CamelException *ex)
+{
+ CamelFolder *folder;
+ char *key, *oldname, *full_oldname;
+
+ if (strcmp(old, "UNMATCHED") == 0) {
+ camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
+ _("Cannot rename folder: %s: Invalid operation"), old);
+ return;
+ }
+
+ CAMEL_STORE_LOCK(store, cache_lock);
+ if (g_hash_table_lookup_extended(store->folders, old, (void **)&key, (void **)&folder)) {
+ g_hash_table_remove(store->folders, key);
+ g_free(key);
+
+ /* this should really be atomic */
+ oldname = folder->name;
+ full_oldname = folder->full_name;
+ key = folder->name;
+ folder->full_name = g_strdup(new);
+ key = strrchr(new, '/');
+ key = key?key+1:(char *)new;
+ folder->name = g_strdup(key);
+ g_hash_table_insert(store->folders, g_strdup(new), folder);
+
+ g_free(oldname);
+ g_free(full_oldname);
+ CAMEL_STORE_UNLOCK(store, cache_lock);
+
+
+ } else {
+ CAMEL_STORE_UNLOCK(store, cache_lock);
+
+ camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
+ _("Cannot rename folder: %s: No such folder"), new);
+ }
+}
+
camel_vtrash_folder_new (CamelStore *parent_store, const char *name)
{
CamelFolder *vtrash;
- char *vtrash_name;
- guint32 flags;
vtrash = (CamelFolder *)camel_object_new (camel_vtrash_folder_get_type ());
- vtrash_name = g_strdup_printf ("%s?(match-all (system-flag \"Deleted\"))", name);
- flags = CAMEL_STORE_FOLDER_PRIVATE | CAMEL_STORE_FOLDER_CREATE | CAMEL_STORE_VEE_FOLDER_AUTO;
-
- camel_vee_folder_construct (CAMEL_VEE_FOLDER (vtrash), parent_store, vtrash_name, flags);
-
+ camel_vee_folder_construct (CAMEL_VEE_FOLDER (vtrash), parent_store, name,
+ CAMEL_STORE_FOLDER_PRIVATE | CAMEL_STORE_FOLDER_CREATE | CAMEL_STORE_VEE_FOLDER_AUTO);
+ camel_vee_folder_set_expression((CamelVeeFolder *)vtrash, "(match-all (system-flag \"Deleted\"))");
+
return vtrash;
}
projects / platform / upstream / evolution-data-server.git / commitdiff