/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /* subscribe-dialog.c: Subscribe dialog */ /* * Authors: Chris Toshok * Peter Williams * * Copyright 2000 Ximian, Inc. (www.ximian.com) * * This program is free software; you can redistribute it and/or * modify it under the terms of version 2 of the GNU General Public * License as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this program; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #include #include #include #include #include "evolution-shell-component-utils.h" #include "mail.h" #include "mail-tools.h" #include "mail-ops.h" #include "mail-mt.h" #include "mail-folder-cache.h" #include "camel/camel-exception.h" #include "camel/camel-store.h" #include "camel/camel-session.h" #include "subscribe-dialog.h" #include "art/empty.xpm" #include "art/mark.xpm" #define d(x) /* Things to test. * - Feature * + How to check that it works. * * - Proper stores displayed * + Skip stores that don't support subscriptions * + Skip disabled stores * - Changing subscription status * + Select single folder, double-click row -> toggled * + Select multiple folders, press subscribe -> all selected folders end up subscribed * - (un)Subscribing from/to already (un)subscribed folder * + Check that no IMAP command is sent * - Switching views between stores * + Proper tree shown * - No crashes when buttons are pressed with "No store" screen * + obvious * - Restoring filter settings when view switched * + Enter search, change view, change back -> filter checked and search entry set * + Clear search, change view, change back -> "all" checked * - Cancelling in middle of get_store * + Enter invalid hostname, open dialog, click Close * - Cancelling in middle if listing * + Open large directory, click Close * - Cancelling in middle of subscription op * + How to test? * - Test with both IMAP and NNTP * + obvious * - Verify that refresh view works * + obvious * - No unnecessary tree rebuilds * + Show All folders, change filter with empty search -> no tree rebuild * + Converse * - No out of date tree * + Show All Folders, change to filter with a search -> tree rebuild * - Tree construction logic (mostly IMAP-specific terminology) * + Tree is created progressively * + No wasted LIST responses * + No extraneous LIST commands * + Specifying "folder names begin with" works * + Always show folders below IMAP namespace (no escaping the namespace) * + Don't allow subscription to NoSelect folders * + IMAP accounts always show INBOX * - Shell interactions * + Folders are properly created / delete from folder tree when subscribed / unsubscribed * + Folders with spaces in names / 8bit chars * + Toplevel as well as subfolders * + Mail Folder Cache doesn't complain * - No ETable wackiness * + Verify columns cannot be DnD'd * + Alphabetical order always * - UI cleanliness * + Keybindings work * + Some widget has focus by default * + Escape / enter work * + Close button works */ /* FIXME: we should disable/enable the subscribe/unsubscribe buttons as * appropriate when only a single message is selected. We need a * mechanism to learn when the selected folder's subscription status * changes, so when the user double-clicks it (eg) the buttons can * (de)sensitize appropriately. See Ximian bug #7673. */ /*#define NEED_TOGGLE_SELECTION*/ typedef struct _FolderETree FolderETree; typedef struct _FolderETreeClass FolderETreeClass; struct _FolderETree { ETreeMemory parent; ETreePath root; GHashTable *scan_ops; GHashTable *subscribe_ops; CamelStore *store; EvolutionStorage *e_storage; char *service_name; char *search; }; struct _FolderETreeClass { ETreeMemoryClass parent; }; static GtkObjectClass *folder_etree_parent_class = NULL; typedef struct _FolderETreeExtras FolderETreeExtras; typedef struct _FolderETreeExtrasClass FolderETreeExtrasClass; enum { FOLDER_COL_SUBSCRIBED, FOLDER_COL_NAME, FOLDER_COL_LAST }; struct _FolderETreeExtras { ETableExtras parent; GdkPixbuf *toggles[2]; }; struct _FolderETreeExtrasClass { ETableExtrasClass parent; }; static GtkObjectClass *ftree_extras_parent_class = NULL; /* util */ static void recursive_add_folder (EvolutionStorage *storage, const char *path, const char *name, const char *url) { char *parent, *pname, *p; p = strrchr (path, '/'); if (p && p != path) { parent = g_strndup (path, p - path); if (!evolution_storage_folder_exists (storage, parent)) { p = strrchr (parent, '/'); if (p) pname = g_strdup (p + 1); else pname = g_strdup (""); recursive_add_folder (storage, parent, pname, ""); g_free (pname); } g_free (parent); } evolution_storage_new_folder (storage, path, name, "mail", url, name, NULL, FALSE, TRUE, 0); } /* ** Get one level of folderinfo ****************************************** */ typedef void (*SubscribeShortFolderinfoFunc) (CamelStore *store, char *prefix, CamelFolderInfo *info, gpointer data); int subscribe_get_short_folderinfo (FolderETree *ftree, const char *prefix, SubscribeShortFolderinfoFunc func, gpointer user_data); struct _get_short_folderinfo_msg { struct _mail_msg msg; char *prefix; FolderETree *ftree; CamelFolderInfo *info; SubscribeShortFolderinfoFunc func; gpointer user_data; }; static char * get_short_folderinfo_desc (struct _mail_msg *mm, int done) { struct _get_short_folderinfo_msg *m = (struct _get_short_folderinfo_msg *) mm; char *ret, *name; name = camel_service_get_name (CAMEL_SERVICE (m->ftree->store), TRUE); if (m->prefix) ret = g_strdup_printf (_("Scanning folders under %s on \"%s\""), m->prefix, name); else ret = g_strdup_printf (_("Scanning root-level folders on \"%s\""), name); g_free (name); return ret; } static void get_short_folderinfo_get (struct _mail_msg *mm) { struct _get_short_folderinfo_msg *m = (struct _get_short_folderinfo_msg *) mm; m->info = camel_store_get_folder_info (m->ftree->store, m->prefix, CAMEL_STORE_FOLDER_INFO_FAST, &mm->ex); } static void get_short_folderinfo_got (struct _mail_msg *mm) { struct _get_short_folderinfo_msg *m = (struct _get_short_folderinfo_msg *) mm; if (camel_exception_is_set (&mm->ex)) g_warning ("Error getting folder info from store at %s: %s", camel_service_get_url (CAMEL_SERVICE (m->ftree->store)), camel_exception_get_description (&mm->ex)); /* 'done' is probably guaranteed to fail, but... */ if (m->func) m->func (m->ftree->store, m->prefix, m->info, m->user_data); } static void get_short_folderinfo_free (struct _mail_msg *mm) { struct _get_short_folderinfo_msg *m = (struct _get_short_folderinfo_msg *) mm; camel_store_free_folder_info (m->ftree->store, m->info); gtk_object_unref (GTK_OBJECT (m->ftree)); g_free (m->prefix); /* may be NULL but that's ok */ } static struct _mail_msg_op get_short_folderinfo_op = { get_short_folderinfo_desc, get_short_folderinfo_get, get_short_folderinfo_got, get_short_folderinfo_free, }; int subscribe_get_short_folderinfo (FolderETree *ftree, const char *prefix, SubscribeShortFolderinfoFunc func, gpointer user_data) { struct _get_short_folderinfo_msg *m; int id; m = mail_msg_new (&get_short_folderinfo_op, NULL, sizeof(*m)); m->ftree = ftree; gtk_object_ref (GTK_OBJECT (ftree)); if (prefix) m->prefix = g_strdup (prefix); else m->prefix = NULL; m->func = func; m->user_data = user_data; id = m->msg.seq; e_thread_put (mail_thread_queued, (EMsg *)m); return id; } /* ** Subscribe folder operation **************************************** */ typedef void (*SubscribeFolderCallback) (const char *, const char *, gboolean, gboolean, gpointer); struct _subscribe_msg { struct _mail_msg msg; CamelStore *store; gboolean subscribe; char *full_name; char *name; SubscribeFolderCallback cb; gpointer cb_data; }; static char * subscribe_folder_desc (struct _mail_msg *mm, int done) { struct _subscribe_msg *m = (struct _subscribe_msg *) mm; if (m->subscribe) return g_strdup_printf (_("Subscribing to folder \"%s\""), m->name); else return g_strdup_printf (_("Unsubscribing to folder \"%s\""), m->name); } static void subscribe_folder_subscribe (struct _mail_msg *mm) { struct _subscribe_msg *m = (struct _subscribe_msg *) mm; if (m->subscribe) camel_store_subscribe_folder (m->store, m->full_name, &mm->ex); else camel_store_unsubscribe_folder (m->store, m->full_name, &mm->ex); } static void subscribe_folder_subscribed (struct _mail_msg *mm) { struct _subscribe_msg *m = (struct _subscribe_msg *) mm; if (m->cb) (m->cb) (m->full_name, m->name, m->subscribe, !camel_exception_is_set (&mm->ex), m->cb_data); } static void subscribe_folder_free (struct _mail_msg *mm) { struct _subscribe_msg *m = (struct _subscribe_msg *) mm; g_free (m->name); g_free (m->full_name); camel_object_unref (CAMEL_OBJECT (m->store)); } static struct _mail_msg_op subscribe_folder_op = { subscribe_folder_desc, subscribe_folder_subscribe, subscribe_folder_subscribed, subscribe_folder_free, }; static int subscribe_do_subscribe_folder (CamelStore *store, const char *full_name, const char *name, gboolean subscribe, SubscribeFolderCallback cb, gpointer cb_data) { struct _subscribe_msg *m; int id; g_return_val_if_fail (CAMEL_IS_STORE (store), 0); g_return_val_if_fail (full_name, 0); m = mail_msg_new (&subscribe_folder_op, NULL, sizeof(*m)); m->store = store; m->subscribe = subscribe; m->name = g_strdup (name); m->full_name = g_strdup (full_name); m->cb = cb; m->cb_data = cb_data; camel_object_ref (CAMEL_OBJECT (store)); id = m->msg.seq; e_thread_put (mail_thread_queued, (EMsg *)m); return id; } /* ** FolderETree Extras *************************************************** */ static void fete_destroy (GtkObject *object) { FolderETreeExtras *extras = (FolderETreeExtras *) object; gdk_pixbuf_unref (extras->toggles[0]); gdk_pixbuf_unref (extras->toggles[1]); ftree_extras_parent_class->destroy (object); } static void fete_class_init (GtkObjectClass *object_class) { object_class->destroy = fete_destroy; ftree_extras_parent_class = gtk_type_class (E_TABLE_EXTRAS_TYPE); } static void fete_init (GtkObject *object) { FolderETreeExtras *extras = (FolderETreeExtras *) object; ECell *cell; ECell *text_cell; /* text column */ cell = e_cell_text_new (NULL, GTK_JUSTIFY_LEFT); text_cell = cell; gtk_object_set (GTK_OBJECT (cell), "bold_column", FOLDER_COL_SUBSCRIBED, NULL); e_table_extras_add_cell (E_TABLE_EXTRAS (extras), "cell_text", cell); /* toggle column */ extras->toggles[0] = gdk_pixbuf_new_from_xpm_data ((const char **)empty_xpm); extras->toggles[1] = gdk_pixbuf_new_from_xpm_data ((const char **)mark_xpm); cell = e_cell_toggle_new (0, 2, extras->toggles); e_table_extras_add_cell (E_TABLE_EXTRAS (extras), "cell_toggle", cell); /* tree cell */ cell = e_cell_tree_new (NULL, NULL, TRUE, text_cell); e_table_extras_add_cell (E_TABLE_EXTRAS (extras), "cell_tree", cell); /* misc */ e_table_extras_add_pixbuf (E_TABLE_EXTRAS (extras), "subscribed-image", extras->toggles[1]); } /* naughty! */ static E_MAKE_TYPE (fete, "FolderETreeExtras", FolderETreeExtras, fete_class_init, fete_init, E_TABLE_EXTRAS_TYPE); /* ** Global Extras ******************************************************** */ static FolderETreeExtras *global_extras = NULL; static void global_extras_destroyed (GtkObject *obj, gpointer user_data) { global_extras = NULL; } static ETableExtras * subscribe_get_global_extras (void) { if (global_extras == NULL) { global_extras = gtk_type_new (fete_get_type()); gtk_object_ref (GTK_OBJECT (global_extras)); gtk_object_sink (GTK_OBJECT (global_extras)); gtk_signal_connect (GTK_OBJECT (global_extras), "destroy", global_extras_destroyed, NULL); } gtk_object_ref (GTK_OBJECT (global_extras)); return E_TABLE_EXTRAS (global_extras); } /* ** Folder Tree Node ***************************************************** */ typedef struct _ftree_node ftree_node; struct _ftree_node { guint8 flags; char *cache; int uri_offset; int full_name_offset; /* format: {name}{\0}{uri}{\0}{full_name}{\0} * (No braces). */ char data[1]; }; #define FTREE_NODE_GOT_CHILDREN (1 << 0) #define FTREE_NODE_SUBSCRIBABLE (1 << 1) #define FTREE_NODE_SUBSCRIBED (1 << 2) #define FTREE_NODE_ROOT (1 << 3) static ftree_node * ftree_node_new_root (const char *prefix) { ftree_node *node; size_t size; if (prefix == NULL) prefix = ""; size = sizeof (ftree_node) + strlen (prefix) + 1; node = g_malloc (size); node->flags = FTREE_NODE_ROOT; node->uri_offset = 0; node->full_name_offset = 1; node->data[0] = '\0'; strcpy (node->data + 1, prefix); return node; } static ftree_node * ftree_node_new (CamelStore *store, CamelFolderInfo *fi) { ftree_node *node; int uri_offset, full_name_offset; size_t size; CamelURL *url; uri_offset = strlen (fi->name) + 1; full_name_offset = uri_offset + strlen (fi->url) + 1; size = full_name_offset + strlen (fi->full_name); /* - 1 for sizeof(node.data) but +1 for terminating \0 */ node = g_malloc (sizeof (*node) + size); node->cache = NULL; /* Noselect? */ url = camel_url_new (fi->url, NULL); if (camel_url_get_param (url, "noselect")) node->flags = 0; else node->flags = FTREE_NODE_SUBSCRIBABLE; camel_url_free (url); /* subscribed? */ if (camel_store_folder_subscribed (store, fi->full_name)) node->flags |= FTREE_NODE_SUBSCRIBED; /* Copy strings */ node->uri_offset = uri_offset; node->full_name_offset = full_name_offset; strcpy (node->data, fi->name); strcpy (node->data + uri_offset, fi->url); strcpy (node->data + full_name_offset, fi->full_name); /* Done */ return node; } #define ftree_node_subscribable(node) ( ((ftree_node *) (node))->flags & FTREE_NODE_SUBSCRIBABLE ) #define ftree_node_subscribed(node) ( ((ftree_node *) (node))->flags & FTREE_NODE_SUBSCRIBED ) #define ftree_node_get_name(node) ( ((ftree_node *) (node))->data ) #define ftree_node_get_full_name(node) ( ((ftree_node *) (node))->data + ((ftree_node *) (node))->full_name_offset ) #define ftree_node_get_uri(node) ( ((ftree_node *) (node))->data + ((ftree_node *) (node))->uri_offset ) /* ** Folder Tree Model **************************************************** */ /* A subscribe or scan operation */ typedef struct _ftree_op_data ftree_op_data; struct _ftree_op_data { FolderETree *ftree; ETreePath path; ftree_node *data; int handle; }; /* ETreeModel functions */ static int fe_column_count (ETreeModel *etm) { return FOLDER_COL_LAST; } static void * fe_duplicate_value (ETreeModel *etm, int col, const void *val) { return g_strdup (val); } static void fe_free_value (ETreeModel *etm, int col, void *val) { g_free (val); } static void* fe_init_value (ETreeModel *etm, int col) { return g_strdup (""); } static gboolean fe_value_is_empty (ETreeModel *etm, int col, const void *val) { return !(val && *(char *)val); } static char * fe_value_to_string (ETreeModel *etm, int col, const void *val) { return g_strdup (val); } static GdkPixbuf * fe_icon_at (ETreeModel *etree, ETreePath path) { return NULL; /* XXX no icons for now */ } static gpointer fe_root_value_at (FolderETree *ftree, int col) { switch (col) { case FOLDER_COL_NAME: return ftree->service_name; case FOLDER_COL_SUBSCRIBED: return GINT_TO_POINTER (0); default: printf ("Oh no, unimplemented column %d in subscribe dialog\n", col); } return NULL; } static gpointer fe_real_value_at (FolderETree *ftree, int col, gpointer data) { switch (col) { case FOLDER_COL_NAME: return ftree_node_get_name (data); case FOLDER_COL_SUBSCRIBED: if (ftree_node_subscribed (data)) return GINT_TO_POINTER (1); return GINT_TO_POINTER (0); default: printf ("Oh no, unimplemented column %d in subscribe dialog\n", col); } return NULL; } static void * fe_value_at (ETreeModel *etree, ETreePath path, int col) { FolderETree *ftree = (FolderETree *) etree; gpointer node_data; if (path == ftree->root) return fe_root_value_at (ftree, col); node_data = e_tree_memory_node_get_data (E_TREE_MEMORY (etree), path); return fe_real_value_at (ftree, col, node_data); } static void fe_set_value_at (ETreeModel *etree, ETreePath path, int col, const void *val) { /* nothing */ } static gboolean fe_return_false (void) { return FALSE; } static gint fe_sort_folder (ETreeMemory *etmm, ETreePath left, ETreePath right, gpointer user_data) { ftree_node *n_left, *n_right; n_left = e_tree_memory_node_get_data (etmm, left); n_right = e_tree_memory_node_get_data (etmm, right); return g_strcasecmp (ftree_node_get_name (n_left), ftree_node_get_name (n_right)); } /* scanning */ static void fe_got_children (CamelStore *store, char *prefix, CamelFolderInfo *info, gpointer data) { ftree_op_data *closure = (ftree_op_data *) data; if (!info) /* cancelled */ return; if (!prefix) prefix = ""; for ( ; info; info = info->sibling) { ETreePath child_path; ftree_node *node; if (strcmp (info->full_name, prefix) == 0) continue; node = ftree_node_new (store, info); child_path = e_tree_memory_node_insert (E_TREE_MEMORY (closure->ftree), closure->path, 0, node); e_tree_memory_sort_node (E_TREE_MEMORY (closure->ftree), closure->path, fe_sort_folder, NULL); } if (closure->data) closure->data->flags |= FTREE_NODE_GOT_CHILDREN; g_hash_table_remove (closure->ftree->scan_ops, closure->path); g_free (closure); } static void fe_check_for_children (FolderETree *ftree, ETreePath path) { ftree_op_data *closure; ftree_node *node; char *prefix; node = e_tree_memory_node_get_data (E_TREE_MEMORY (ftree), path); /* have we already gotten these children? */ if (node->flags & FTREE_NODE_GOT_CHILDREN) return; /* or we're loading them right now? */ if (g_hash_table_lookup (ftree->scan_ops, path)) return; /* figure out our search prefix */ if (path == ftree->root) prefix = ftree->search; else prefix = ftree_node_get_full_name (node); closure = g_new (ftree_op_data, 1); closure->ftree = ftree; closure->path = path; closure->data = node; closure->handle = -1; g_hash_table_insert (ftree->scan_ops, path, closure); /* FIXME. Tiny race possiblity I guess. */ closure->handle = subscribe_get_short_folderinfo (ftree, prefix, fe_got_children, closure); } static void fe_create_root_node (FolderETree *ftree) { ftree_node *node; node = ftree_node_new_root (ftree->search); ftree->root = e_tree_memory_node_insert (E_TREE_MEMORY(ftree), NULL, 0, node); fe_check_for_children (ftree, ftree->root); } static ETreePath fe_get_first_child (ETreeModel *model, ETreePath path) { ETreePath child_path; child_path = E_TREE_MODEL_CLASS (folder_etree_parent_class)->get_first_child (model, path); if (child_path) fe_check_for_children ((FolderETree *) model, child_path); else fe_check_for_children ((FolderETree *) model, path); return child_path; } /* subscribing */ static char * fe_node_to_shell_path (ftree_node *node) { char *path = NULL; int name_len, full_name_len; name_len = strlen (ftree_node_get_name (node)); full_name_len = strlen (ftree_node_get_full_name (node)); if (name_len != full_name_len) { char *full_name; char *iter; char sep; /* so, we don't know the heirarchy separator. But * full_name = blahXblahXname, where X = separator * and name = .... name. So we can determine it. * (imap_store->dir_sep isn't really private, I guess, * so we could use that if we had the store. But also * we don't "know" that it is an IMAP store anyway.) */ full_name = ftree_node_get_full_name (node); sep = full_name[full_name_len - (name_len + 1)]; if (sep != '/') { path = g_malloc (full_name_len + 2); path[0] = '/'; strcpy (path + 1, full_name); while ((iter = strchr (path, sep)) != NULL) *iter = '/'; } } if (!path) path = g_strdup_printf ("/%s", ftree_node_get_full_name (node)); return path; } static void fe_done_subscribing (const char *full_name, const char *name, gboolean subscribe, gboolean success, gpointer user_data) { ftree_op_data *closure = (ftree_op_data *) user_data; if (success && closure->handle != -1) { char *path; path = fe_node_to_shell_path (closure->data); if (subscribe) { closure->data->flags |= FTREE_NODE_SUBSCRIBED; recursive_add_folder (closure->ftree->e_storage, path, name, ftree_node_get_uri (closure->data)); } else { closure->data->flags &= ~FTREE_NODE_SUBSCRIBED; /* FIXME: recursively remove folder as well? Possible? */ evolution_storage_removed_folder (closure->ftree->e_storage, path); } g_free (path); e_tree_model_node_data_changed (E_TREE_MODEL (closure->ftree), closure->path); } if (closure->handle != -1) g_hash_table_remove (closure->ftree->subscribe_ops, closure->path); g_free (closure); } /* cleanup */ static gboolean fe_cancel_op_foreach (gpointer key, gpointer value, gpointer user_data) { /*FolderETree *ftree = (FolderETree *) user_data;*/ ftree_op_data *closure = (ftree_op_data *) value; if (closure->handle != -1) mail_msg_cancel (closure->handle); closure->handle = -1; return TRUE; } static void fe_kill_current_tree (FolderETree *ftree) { g_hash_table_foreach_remove (ftree->scan_ops, fe_cancel_op_foreach, ftree); g_assert (g_hash_table_size (ftree->scan_ops) == 0); } static void fe_destroy (GtkObject *obj) { FolderETree *ftree = (FolderETree *) (obj); fe_kill_current_tree (ftree); g_hash_table_foreach_remove (ftree->subscribe_ops, fe_cancel_op_foreach, ftree); g_hash_table_destroy (ftree->scan_ops); g_hash_table_destroy (ftree->subscribe_ops); camel_object_unref (CAMEL_OBJECT (ftree->store)); bonobo_object_unref (BONOBO_OBJECT (ftree->e_storage)); g_free (ftree->search); g_free (ftree->service_name); } typedef gboolean (*bool_func_1) (ETreeModel *, ETreePath, int); typedef gboolean (*bool_func_2) (ETreeModel *); static void folder_etree_class_init (GtkObjectClass *klass) { ETreeModelClass *etree_model_class = E_TREE_MODEL_CLASS (klass); folder_etree_parent_class = gtk_type_class (E_TREE_MEMORY_TYPE); klass->destroy = fe_destroy; etree_model_class->value_at = fe_value_at; etree_model_class->set_value_at = fe_set_value_at; etree_model_class->column_count = fe_column_count; etree_model_class->duplicate_value = fe_duplicate_value; etree_model_class->free_value = fe_free_value; etree_model_class->initialize_value = fe_init_value; etree_model_class->value_is_empty = fe_value_is_empty; etree_model_class->value_to_string = fe_value_to_string; etree_model_class->icon_at = fe_icon_at; etree_model_class->is_editable = (bool_func_1) fe_return_false; etree_model_class->has_save_id = (bool_func_2) fe_return_false; etree_model_class->has_get_node_by_id = (bool_func_2) fe_return_false; etree_model_class->get_first_child = fe_get_first_child; } static void folder_etree_init (GtkObject *object) { FolderETree *ftree = (FolderETree *) object; e_tree_memory_set_node_destroy_func (E_TREE_MEMORY (ftree), (GFunc) g_free, ftree); ftree->scan_ops = g_hash_table_new (g_direct_hash, g_direct_equal); ftree->subscribe_ops = g_hash_table_new (g_direct_hash, g_direct_equal); ftree->search = g_strdup (""); } static FolderETree * folder_etree_construct (FolderETree *ftree, CamelStore *store) { e_tree_memory_construct (E_TREE_MEMORY (ftree)); ftree->store = store; camel_object_ref (CAMEL_OBJECT (store)); ftree->service_name = camel_service_get_name (CAMEL_SERVICE (store), FALSE); ftree->e_storage = mail_lookup_storage (store); /* this gives us a ref */ fe_create_root_node (ftree); return ftree; } static E_MAKE_TYPE (folder_etree, "FolderETree", FolderETree, folder_etree_class_init, folder_etree_init, E_TREE_MEMORY_TYPE); /* public */ static FolderETree * folder_etree_new (CamelStore *store) { FolderETree *ftree; ftree = gtk_type_new (folder_etree_get_type()); ftree = folder_etree_construct (ftree, store); return ftree; } static void folder_etree_clear_tree (FolderETree *ftree) { e_tree_memory_freeze (E_TREE_MEMORY (ftree)); e_tree_memory_node_remove (E_TREE_MEMORY (ftree), ftree->root); fe_create_root_node (ftree); e_tree_memory_thaw (E_TREE_MEMORY (ftree)); } static void folder_etree_set_search (FolderETree *ftree, const char *search) { if (!strcmp (search, ftree->search)) return; g_free (ftree->search); ftree->search = g_strdup (search); folder_etree_clear_tree (ftree); } static int folder_etree_path_set_subscription (FolderETree *ftree, ETreePath path, gboolean subscribe) { ftree_op_data *closure; ftree_node *node; /* already in progress? */ if (g_hash_table_lookup (ftree->subscribe_ops, path)) return 0; /* noselect? */ node = e_tree_memory_node_get_data (E_TREE_MEMORY (ftree), path); if (!ftree_node_subscribable (node)) return -1; /* noop? */ /* uh, this should be a not XOR or something */ if ((ftree_node_subscribed (node) && subscribe) || (!ftree_node_subscribed (node) && !subscribe)) return 0; closure = g_new (ftree_op_data, 1); closure->ftree = ftree; closure->path = path; closure->data = node; closure->handle = -1; g_hash_table_insert (ftree->subscribe_ops, path, closure); closure->handle = subscribe_do_subscribe_folder (ftree->store, ftree_node_get_full_name (node), ftree_node_get_name (node), subscribe, fe_done_subscribing, closure); return 0; } static int folder_etree_path_toggle_subscription (FolderETree *ftree, ETreePath path) { ftree_node *node = e_tree_memory_node_get_data (E_TREE_MEMORY (ftree), path); if (ftree_node_subscribed (node)) return folder_etree_path_set_subscription (ftree, path, FALSE); else return folder_etree_path_set_subscription (ftree, path, TRUE); } /* ** StoreData ************************************************************ */ typedef struct _StoreData StoreData; typedef void (*StoreDataStoreFunc) (StoreData *, CamelStore *, gpointer); struct _StoreData { int refcount; char *uri; FolderETree *ftree; CamelStore *store; int request_id; GtkWidget *widget; StoreDataStoreFunc store_func; gpointer store_data; }; static StoreData * store_data_new (const char *uri) { StoreData *sd; sd = g_new0 (StoreData, 1); sd->refcount = 1; sd->uri = g_strdup (uri); return sd; } static void store_data_free (StoreData *sd) { if (sd->request_id) mail_msg_cancel (sd->request_id); if (sd->widget) gtk_object_unref (GTK_OBJECT (sd->widget)); if (sd->ftree) gtk_object_unref (GTK_OBJECT (sd->ftree)); if (sd->store) camel_object_unref (CAMEL_OBJECT (sd->store)); g_free (sd->uri); g_free (sd); } static void store_data_ref (StoreData *sd) { sd->refcount++; } static void store_data_unref (StoreData *sd) { if (sd->refcount <= 1) { store_data_free (sd); } else { sd->refcount--; } } static void sd_got_store (char *uri, CamelStore *store, gpointer user_data) { StoreData *sd = (StoreData *) user_data; sd->store = store; if (store) /* we can have exceptions getting the store... server is down, eg */ camel_object_ref (CAMEL_OBJECT (sd->store)); /* uh, so we might have a problem if this operation is cancelled. Unsure. */ sd->request_id = 0; if (sd->store_func) (sd->store_func) (sd, sd->store, sd->store_data); store_data_unref (sd); } static void store_data_async_get_store (StoreData *sd, StoreDataStoreFunc func, gpointer user_data) { if (sd->request_id) { d(printf ("Already loading store, nooping\n")); return; } if (sd->store) { /* um, is this the best behavior? */ func (sd, sd->store, user_data); return; } sd->store_func = func; sd->store_data = user_data; store_data_ref (sd); sd->request_id = mail_get_store (sd->uri, sd_got_store, sd); } static void store_data_cancel_get_store (StoreData *sd) { g_return_if_fail (sd->request_id); mail_msg_cancel (sd->request_id); sd->request_id = 0; } static void sd_toggle_cb (ETree *tree, int row, ETreePath path, int col, GdkEvent *event, gpointer user_data) { StoreData *sd = (StoreData *) user_data; folder_etree_path_toggle_subscription (sd->ftree, path); } static GtkWidget * store_data_get_widget (StoreData *sd) { GtkWidget *tree; if (!sd->store) { d(printf ("store data can't get widget before getting store.\n")); return NULL; } if (sd->widget) return sd->widget; sd->ftree = folder_etree_new (sd->store); /* You annoy me, etree! */ tree = gtk_widget_new (E_TREE_SCROLLED_TYPE, "hadjustment", NULL, "vadjustment", NULL, NULL); tree = (GtkWidget *) e_tree_scrolled_construct_from_spec_file (E_TREE_SCROLLED (tree), E_TREE_MODEL (sd->ftree), subscribe_get_global_extras (), EVOLUTION_ETSPECDIR "/subscribe-dialog.etspec", NULL); e_tree_root_node_set_visible (e_tree_scrolled_get_tree(E_TREE_SCROLLED(tree)), TRUE); gtk_signal_connect (GTK_OBJECT (e_tree_scrolled_get_tree(E_TREE_SCROLLED (tree))), "double_click", GTK_SIGNAL_FUNC (sd_toggle_cb), sd); gtk_object_unref (GTK_OBJECT (global_extras)); sd->widget = tree; gtk_object_ref (GTK_OBJECT (sd->widget)); return sd->widget; } typedef struct _selection_closure { StoreData *sd; enum { SET, CLEAR, TOGGLE } mode; } selection_closure; static void sd_subscribe_folder_foreach (int model_row, gpointer closure) { selection_closure *sc = (selection_closure *) closure; StoreData *sd = sc->sd; ETree *tree = e_tree_scrolled_get_tree(E_TREE_SCROLLED(sd->widget)); ETreePath path = e_tree_node_at_row (tree, model_row); /* ignore results */ switch (sc->mode) { case SET: folder_etree_path_set_subscription (sd->ftree, path, TRUE); break; case CLEAR: folder_etree_path_set_subscription (sd->ftree, path, FALSE); break; case TOGGLE: folder_etree_path_toggle_subscription (sd->ftree, path); break; } } static void store_data_selection_set_subscription (StoreData *sd, gboolean subscribe) { selection_closure sc; ETree *tree; sc.sd = sd; if (subscribe) sc.mode = SET; else sc.mode = CLEAR; tree = e_tree_scrolled_get_tree (E_TREE_SCROLLED (sd->widget)); e_tree_selected_row_foreach (tree, sd_subscribe_folder_foreach, &sc); } #ifdef NEED_TOGGLE_SELECTION static void store_data_selection_toggle_subscription (StoreData *sd) { selection_closure sc; ETree *tree; sc.sd = sd; sc.mode = TOGGLE; tree = e_tree_scrolled_get_tree (E_TREE_SCROLLED (sd->widget)); e_tree_selected_row_foreach (tree, sd_subscribe_folder_foreach, &sc); } #endif static gboolean store_data_mid_request (StoreData *sd) { return (gboolean) sd->request_id; } /* ** yaay, SubscribeDialog ******************************************************* */ #define PARENT_TYPE (gtk_object_get_type ()) #ifdef JUST_FOR_TRANSLATORS static char *str = N_("Folder"); #endif #define STORE_DATA_KEY "store-data" struct _SubscribeDialogPrivate { GladeXML *xml; GList *store_list; StoreData *current_store; GtkWidget *current_widget; GtkWidget *default_widget; GtkWidget *none_item; GtkWidget *search_entry; GtkWidget *hbox; GtkWidget *filter_radio, *all_radio; GtkWidget *sub_button, *unsub_button, *refresh_button; }; static GtkObjectClass *subscribe_dialog_parent_class; static void sc_refresh_pressed (GtkWidget *widget, gpointer user_data) { SubscribeDialog *sc = SUBSCRIBE_DIALOG (user_data); if (sc->priv->current_store) folder_etree_clear_tree (sc->priv->current_store->ftree); } static void sc_search_activated (GtkWidget *widget, gpointer user_data) { SubscribeDialog *sc = SUBSCRIBE_DIALOG (user_data); StoreData *store = sc->priv->current_store; char *search; if (!store) return; search = e_utf8_gtk_entry_get_text (GTK_ENTRY (widget)); folder_etree_set_search (store->ftree, search); } static void sc_subscribe_pressed (GtkWidget *widget, gpointer user_data) { SubscribeDialog *sc = SUBSCRIBE_DIALOG (user_data); StoreData *store = sc->priv->current_store; if (!store) return; store_data_selection_set_subscription (store, TRUE); } static void sc_unsubscribe_pressed (GtkWidget *widget, gpointer user_data) { SubscribeDialog *sc = SUBSCRIBE_DIALOG (user_data); StoreData *store = sc->priv->current_store; if (!store) return; store_data_selection_set_subscription (store, FALSE); } static void sc_all_toggled (GtkWidget *widget, gpointer user_data) { SubscribeDialog *sc = SUBSCRIBE_DIALOG (user_data); StoreData *store = sc->priv->current_store; if (!store) return; if (GTK_TOGGLE_BUTTON (widget)->active) { gtk_widget_set_sensitive (sc->priv->search_entry, FALSE); folder_etree_set_search (store->ftree, ""); } } static void sc_filter_toggled (GtkWidget *widget, gpointer user_data) { SubscribeDialog *sc = SUBSCRIBE_DIALOG (user_data); StoreData *store = sc->priv->current_store; if (!store) return; if (GTK_TOGGLE_BUTTON (widget)->active) { gtk_widget_set_sensitive (sc->priv->search_entry, TRUE); sc_search_activated (sc->priv->search_entry, sc); } } static void populate_store_foreach (MailConfigService *service, SubscribeDialog *sc) { StoreData *sd; if (service->url == NULL || service->enabled == FALSE) return; sd = store_data_new (service->url); sc->priv->store_list = g_list_prepend (sc->priv->store_list, sd); } static void kill_default_view (SubscribeDialog *sc) { gtk_widget_hide (sc->priv->none_item); /* the entry will be set sensitive when one of the * radio buttons is activated, if necessary. */ gtk_widget_set_sensitive (sc->priv->all_radio, TRUE); gtk_widget_set_sensitive (sc->priv->filter_radio, TRUE); gtk_widget_set_sensitive (sc->priv->sub_button, TRUE); gtk_widget_set_sensitive (sc->priv->unsub_button, TRUE); gtk_widget_set_sensitive (sc->priv->refresh_button, TRUE); } static void sc_selection_changed (GtkObject *obj, gpointer user_data) { SubscribeDialog *sc = SUBSCRIBE_DIALOG (user_data); gboolean sensitive; if (e_selection_model_selected_count (E_SELECTION_MODEL (obj))) sensitive = TRUE; else sensitive = FALSE; gtk_widget_set_sensitive (sc->priv->sub_button, sensitive); gtk_widget_set_sensitive (sc->priv->unsub_button, sensitive); } static void menu_item_selected (GtkMenuItem *item, gpointer user_data) { SubscribeDialog *sc = SUBSCRIBE_DIALOG (user_data); StoreData *sd = gtk_object_get_data (GTK_OBJECT (item), STORE_DATA_KEY); g_return_if_fail (sd); if (sd->widget == NULL) { GtkWidget *widget; ESelectionModel *esm; ETree *tree; widget = store_data_get_widget (sd); gtk_box_pack_start (GTK_BOX (sc->priv->hbox), widget, TRUE, TRUE, 0); tree = e_tree_scrolled_get_tree (E_TREE_SCROLLED (widget)); esm = e_tree_get_selection_model (tree); gtk_signal_connect (GTK_OBJECT (esm), "selection_changed", sc_selection_changed, sc); sc_selection_changed ((GtkObject *)esm, sc); } if (sc->priv->current_widget == sc->priv->default_widget) kill_default_view (sc); gtk_widget_hide (sc->priv->current_widget); gtk_widget_show (sd->widget); sc->priv->current_widget = sd->widget; sc->priv->current_store = sd; if (*sd->ftree->search) { e_utf8_gtk_entry_set_text (GTK_ENTRY (sc->priv->search_entry), sd->ftree->search); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sc->priv->filter_radio), TRUE); } else { e_utf8_gtk_entry_set_text (GTK_ENTRY (sc->priv->search_entry), ""); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sc->priv->all_radio), TRUE); } } static void dummy_item_selected (GtkMenuItem *item, gpointer user_data) { SubscribeDialog *sc = SUBSCRIBE_DIALOG (user_data); gtk_widget_hide (sc->priv->current_widget); gtk_widget_show (sc->priv->default_widget); sc->priv->current_widget = sc->priv->default_widget; sc->priv->current_store = NULL; e_utf8_gtk_entry_set_text (GTK_ENTRY (sc->priv->search_entry), ""); } /* wonderful */ static void got_sd_store (StoreData *sd, CamelStore *store, gpointer data) { if (store && camel_store_supports_subscriptions (store)) gtk_widget_show (GTK_WIDGET (data)); } /* FIXME: if there aren't any stores that are subscribable, the option * menu will only have the "No server selected" item and the user will * be confused. */ static void populate_store_list (SubscribeDialog *sc) { GSList *sources; GList *iter; GtkWidget *menu; GtkWidget *omenu; sources = mail_config_get_sources (); g_slist_foreach (sources, (GFunc) populate_store_foreach, sc); g_slist_free (sources); menu = gtk_menu_new (); for (iter = sc->priv->store_list; iter; iter = iter->next) { GtkWidget *item; CamelURL *url; char *string; url = camel_url_new (((StoreData *) iter->data)->uri, NULL); string = camel_url_to_string (url, CAMEL_URL_HIDE_ALL); camel_url_free (url); item = gtk_menu_item_new_with_label (string); store_data_async_get_store (iter->data, got_sd_store, item); gtk_object_set_data (GTK_OBJECT (item), STORE_DATA_KEY, iter->data); gtk_signal_connect (GTK_OBJECT (item), "activate", menu_item_selected, sc); g_free (string); gtk_menu_prepend (GTK_MENU (menu), item); } sc->priv->none_item = gtk_menu_item_new_with_label (_("No server has been selected")); gtk_signal_connect (GTK_OBJECT (sc->priv->none_item), "activate", dummy_item_selected, sc); gtk_widget_show (sc->priv->none_item); gtk_menu_prepend (GTK_MENU (menu), sc->priv->none_item); gtk_widget_show (menu); omenu = glade_xml_get_widget (sc->priv->xml, "store_menu"); gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu); } static void subscribe_dialog_destroy (GtkObject *object) { SubscribeDialog *sc; GList *iter; sc = SUBSCRIBE_DIALOG (object); for (iter = sc->priv->store_list; iter; iter = iter->next) { StoreData *data = iter->data; if (store_data_mid_request (data)) store_data_cancel_get_store (data); data->store_func = NULL; store_data_unref (data); } g_list_free (sc->priv->store_list); gtk_object_unref (GTK_OBJECT (sc->priv->xml)); g_free (sc->priv); subscribe_dialog_parent_class->destroy (object); } static void subscribe_dialog_class_init (GtkObjectClass *object_class) { object_class->destroy = subscribe_dialog_destroy; subscribe_dialog_parent_class = gtk_type_class (PARENT_TYPE); } static void subscribe_dialog_init (GtkObject *object) { SubscribeDialog *sc = SUBSCRIBE_DIALOG (object); sc->priv = g_new0 (SubscribeDialogPrivate, 1); } static GtkWidget * sc_create_default_widget (void) { GtkWidget *label; GtkWidget *viewport; label = gtk_label_new (_("Please select a server.")); gtk_widget_show (label); viewport = gtk_viewport_new (NULL, NULL); gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (viewport), label); return viewport; } static void subscribe_dialog_construct (GtkObject *object) { SubscribeDialog *sc = SUBSCRIBE_DIALOG (object); /* Load the XML */ sc->priv->xml = glade_xml_new (EVOLUTION_GLADEDIR "/subscribe-dialog.glade", NULL); sc->app = glade_xml_get_widget (sc->priv->xml, "Manage Subscriptions"); sc->priv->hbox = glade_xml_get_widget (sc->priv->xml, "tree_box"); sc->priv->search_entry = glade_xml_get_widget (sc->priv->xml, "search_entry"); sc->priv->filter_radio = glade_xml_get_widget (sc->priv->xml, "filter_radio"); sc->priv->all_radio = glade_xml_get_widget (sc->priv->xml, "all_radio"); sc->priv->sub_button = glade_xml_get_widget (sc->priv->xml, "subscribe_button"); sc->priv->unsub_button = glade_xml_get_widget (sc->priv->xml, "unsubscribe_button"); sc->priv->refresh_button = glade_xml_get_widget (sc->priv->xml, "refresh_button"); /* create default view */ sc->priv->default_widget = sc_create_default_widget(); sc->priv->current_widget = sc->priv->default_widget; gtk_box_pack_start (GTK_BOX (sc->priv->hbox), sc->priv->default_widget, TRUE, TRUE, 0); gtk_widget_show (sc->priv->default_widget); gtk_widget_set_sensitive (sc->priv->all_radio, FALSE); gtk_widget_set_sensitive (sc->priv->filter_radio, FALSE); gtk_widget_set_sensitive (sc->priv->search_entry, FALSE); gtk_widget_set_sensitive (sc->priv->sub_button, FALSE); gtk_widget_set_sensitive (sc->priv->unsub_button, FALSE); gtk_widget_set_sensitive (sc->priv->refresh_button, FALSE); /* hook up some signals */ gtk_signal_connect (GTK_OBJECT (sc->priv->search_entry), "activate", sc_search_activated, sc); gtk_signal_connect (GTK_OBJECT (sc->priv->sub_button), "clicked", sc_subscribe_pressed, sc); gtk_signal_connect (GTK_OBJECT (sc->priv->unsub_button), "clicked", sc_unsubscribe_pressed, sc); gtk_signal_connect (GTK_OBJECT (sc->priv->refresh_button), "clicked", sc_refresh_pressed, sc); gtk_signal_connect (GTK_OBJECT (sc->priv->all_radio), "toggled", sc_all_toggled, sc); gtk_signal_connect (GTK_OBJECT (sc->priv->filter_radio), "toggled", sc_filter_toggled, sc); /* Get the list of stores */ populate_store_list (sc); } GtkObject * subscribe_dialog_new (void) { SubscribeDialog *subscribe_dialog; subscribe_dialog = gtk_type_new (SUBSCRIBE_DIALOG_TYPE); subscribe_dialog_construct (GTK_OBJECT (subscribe_dialog)); return GTK_OBJECT (subscribe_dialog); } E_MAKE_TYPE (subscribe_dialog, "SubscribeDialog", SubscribeDialog, subscribe_dialog_class_init, subscribe_dialog_init, PARENT_TYPE);