static gchar * vfolder_adduri_desc (struct _adduri_msg *m) { CamelStore *store; CamelService *service; EMailSession *session; const gchar *display_name; gchar *folder_name; gchar *description; gboolean success; session = e_mail_backend_get_session (m->backend); success = e_mail_folder_uri_parse ( CAMEL_SESSION (session), m->uri, &store, &folder_name, NULL); if (!success) return NULL; service = CAMEL_SERVICE (store); display_name = camel_service_get_display_name (service); description = g_strdup_printf ( _("Updating Search Folders for '%s' : %s"), display_name, folder_name); g_object_unref (store); g_free (folder_name); return description; }
static void mail_store_add (EMailBackend *backend, CamelStore *store, AddStoreCallback callback) { EMailSession *session; EMFolderTreeModel *default_model; MailFolderCache *folder_cache; StoreInfo *store_info; g_return_if_fail (store_table != NULL); g_return_if_fail (store != NULL); g_return_if_fail (CAMEL_IS_STORE (store)); session = e_mail_backend_get_session (backend); default_model = em_folder_tree_model_get_default (); folder_cache = e_mail_session_get_folder_cache (session); store_info = store_info_new (store); store_info->callback = callback; g_hash_table_insert (store_table, store, store_info); if (special_mail_store_is_enabled (store)) em_folder_tree_model_add_store (default_model, store); mail_folder_cache_note_store ( folder_cache, CAMEL_SESSION (session), store, NULL, mail_store_note_store_cb, store_info_ref (store_info)); }
static void pine_import_exec (struct _pine_import_msg *m, GCancellable *cancellable, GError **error) { EShell *shell; EShellBackend *shell_backend; EMailSession *session; /* XXX Dig up the EMailSession from the default EShell. * Since the EImport framework doesn't allow for user * data, I don't see how else to get to it. */ shell = e_shell_get_default (); shell_backend = e_shell_get_backend_by_name (shell, "mail"); session = e_mail_backend_get_session (E_MAIL_BACKEND (shell_backend)); if (GPOINTER_TO_INT (g_datalist_get_data (&m->target->data, "pine-do-addr"))) import_contacts (); if (GPOINTER_TO_INT (g_datalist_get_data (&m->target->data, "pine-do-mail"))) { gchar *path; path = g_build_filename (g_get_home_dir (), "mail", NULL); mail_importer_import_folders_sync ( session, path, pine_special_folders, 0, m->cancellable); g_free (path); } }
void e_mail_store_remove_by_account (EMailBackend *backend, EAccount *account) { EMailSession *session; CamelService *service; CamelProvider *provider; const gchar *uid; g_return_if_fail (E_IS_MAIL_BACKEND (backend)); g_return_if_fail (E_IS_ACCOUNT (account)); uid = account->uid; session = e_mail_backend_get_session (backend); service = camel_session_get_service (CAMEL_SESSION (session), uid); g_return_if_fail (CAMEL_IS_STORE (service)); provider = camel_service_get_provider (service); g_return_if_fail (provider != NULL); if (!(provider->flags & CAMEL_PROVIDER_IS_STORAGE)) return; e_mail_store_remove (backend, CAMEL_STORE (service)); }
void e_mail_store_foreach (EMailBackend *backend, GFunc func, gpointer user_data) { EMailSession *session; GList *list, *link; /* XXX This is a silly convenience function. * Could probably just get rid of it. */ g_return_if_fail (E_IS_MAIL_BACKEND (backend)); g_return_if_fail (func != NULL); session = e_mail_backend_get_session (backend); list = camel_session_list_services (CAMEL_SESSION (session)); for (link = list; link != NULL; link = g_list_next (link)) { CamelService *service = CAMEL_SERVICE (link->data); if (CAMEL_IS_STORE (service)) func (service, user_data); } g_list_free (list); }
static gint uri_is_ignore (EMailBackend *backend, const gchar *uri) { EMailSession *session; CamelSession *camel_session; EAccountList *accounts; EAccount *account; EIterator *iter; const gchar *local_drafts_uri; const gchar *local_outbox_uri; const gchar *local_sent_uri; gint found = FALSE; local_drafts_uri = e_mail_local_get_folder_uri (E_MAIL_LOCAL_FOLDER_DRAFTS); local_outbox_uri = e_mail_local_get_folder_uri (E_MAIL_LOCAL_FOLDER_OUTBOX); local_sent_uri = e_mail_local_get_folder_uri (E_MAIL_LOCAL_FOLDER_SENT); session = e_mail_backend_get_session (backend); camel_session = CAMEL_SESSION (session); if (e_mail_folder_uri_equal (camel_session, local_outbox_uri, uri)) return TRUE; if (e_mail_folder_uri_equal (camel_session, local_sent_uri, uri)) return TRUE; if (e_mail_folder_uri_equal (camel_session, local_drafts_uri, uri)) return TRUE; accounts = e_get_account_list (); iter = e_list_get_iterator (E_LIST (accounts)); while (!found && e_iterator_is_valid (iter)) { /* XXX EIterator misuses const. */ account = (EAccount *) e_iterator_get (iter); if (!found && account->sent_folder_uri != NULL) found = e_mail_folder_uri_equal ( camel_session, uri, account->sent_folder_uri); if (!found && account->drafts_folder_uri != NULL) found = e_mail_folder_uri_equal ( camel_session, uri, account->drafts_folder_uri); e_iterator_next (iter); } g_object_unref (iter); return found; }
static SendReceiveData * send_receive_data_new (EMailShellView *mail_shell_view, GtkWidget *menu) { SendReceiveData *data; EShellView *shell_view; EShellBackend *shell_backend; EMailAccountStore *account_store; EMailBackend *backend; EMailSession *session; shell_view = E_SHELL_VIEW (mail_shell_view); shell_backend = e_shell_view_get_shell_backend (shell_view); backend = E_MAIL_BACKEND (shell_backend); session = e_mail_backend_get_session (backend); account_store = e_mail_ui_session_get_account_store ( E_MAIL_UI_SESSION (session)); data = g_slice_new0 (SendReceiveData); data->menu = GTK_MENU_SHELL (menu); /* do not reference */ data->session = g_object_ref (session); data->account_store = g_object_ref (account_store); data->menu_items = g_hash_table_new_full ( (GHashFunc) g_direct_hash, (GEqualFunc) g_direct_equal, (GDestroyNotify) NULL, (GDestroyNotify) g_object_unref); data->service_added_id = g_signal_connect ( account_store, "service-added", G_CALLBACK (send_receive_menu_service_added_cb), data); data->service_removed_id = g_signal_connect ( account_store, "service-removed", G_CALLBACK (send_receive_menu_service_removed_cb), data); data->service_enabled_id = g_signal_connect ( account_store, "service-enabled", G_CALLBACK (send_receive_menu_service_added_cb), data); data->service_disabled_id = g_signal_connect ( account_store, "service-disabled", G_CALLBACK (send_receive_menu_service_removed_cb), data); g_object_weak_ref ( G_OBJECT (menu), (GWeakNotify) send_receive_data_free, data); return data; }
static void vfolder_adduri_exec (struct _adduri_msg *m, GCancellable *cancellable, GError **error) { GList *l; EMailSession *session; CamelFolder *folder = NULL; MailFolderCache *folder_cache; if (vfolder_shutdown) return; session = e_mail_backend_get_session (m->backend); folder_cache = e_mail_session_get_folder_cache (session); /* we dont try lookup the cache if we are removing it, its no longer there */ if (!m->remove && !mail_folder_cache_get_folder_from_uri (folder_cache, m->uri, &folder)) { g_warning ( "Folder '%s' disappeared while I was " "adding/removing it to/from my vfolder", m->uri); return; } if (folder == NULL) folder = e_mail_session_uri_to_folder_sync ( session, m->uri, 0, cancellable, error); if (folder != NULL) { l = m->folders; while (l && !vfolder_shutdown) { if (m->remove) camel_vee_folder_remove_folder ( CAMEL_VEE_FOLDER (l->data), folder); else camel_vee_folder_add_folder ((CamelVeeFolder *) l->data, folder); l = l->next; } g_object_unref (folder); } }
static void mbox_import (EImport *ei, EImportTarget *target, EImportImporter *im) { EShell *shell; EShellBackend *shell_backend; EMailSession *session; MboxImporter *importer; gchar *filename; /* XXX Dig up the EMailSession from the default EShell. * Since the EImport framework doesn't allow for user * data, I don't see how else to get to it. */ shell = e_shell_get_default (); shell_backend = e_shell_get_backend_by_name (shell, "mail"); session = e_mail_backend_get_session (E_MAIL_BACKEND (shell_backend)); /* TODO: do we validate target? */ importer = g_malloc0 (sizeof (*importer)); g_datalist_set_data (&target->data, "mbox-data", importer); importer->import = ei; importer->target = target; g_mutex_init (&importer->status_lock); importer->status_timeout_id = e_named_timeout_add (100, mbox_status_timeout, importer); importer->cancellable = camel_operation_new (); g_signal_connect ( importer->cancellable, "status", G_CALLBACK (mbox_status), importer); filename = g_filename_from_uri ( ((EImportTargetURI *) target)->uri_src, NULL, NULL); mail_importer_import_mbox ( session, filename, ((EImportTargetURI *) target)->uri_dest, importer->cancellable, mbox_import_done, importer); g_free (filename); }
static void mail_store_load_accounts (EMailBackend *backend, const gchar *data_dir) { CamelStore *local_store; EMailSession *session; EAccountList *account_list; EIterator *iter; session = e_mail_backend_get_session (backend); /* Add the local store. */ e_mail_local_init (session, data_dir); local_store = e_mail_local_get_store (); mail_store_add ( backend, local_store, (AddStoreCallback) mail_store_add_local_done_cb); /* Add mail accounts.. */ account_list = e_get_account_list (); for (iter = e_list_get_iterator ((EList *) account_list); e_iterator_is_valid (iter); e_iterator_next (iter)) { EAccount *account; account = (EAccount *) e_iterator_get (iter); if (!account->enabled) continue; e_mail_store_add_by_account (backend, account); } g_object_unref (iter); }
void e_mail_store_remove (EMailBackend *backend, CamelStore *store) { EMailSession *session; MailFolderCache *folder_cache; EMFolderTreeModel *default_model; g_return_if_fail (E_IS_MAIL_BACKEND (backend)); g_return_if_fail (CAMEL_IS_STORE (store)); g_return_if_fail (store_table != NULL); session = e_mail_backend_get_session (backend); /* Because the store table holds a reference to each store used * as a key in it, none of them will ever be gc'ed, meaning any * call to camel_session_get_{service,store} with the same URL * will always return the same object. So this works. */ if (g_hash_table_lookup (store_table, store) == NULL) return; g_object_ref (store); g_hash_table_remove (store_table, store); folder_cache = e_mail_session_get_folder_cache (session); mail_folder_cache_note_store_remove (folder_cache, store); default_model = em_folder_tree_model_get_default (); em_folder_tree_model_remove_store (default_model, store); mail_disconnect_store (store); g_object_unref (store); }
CamelStore * e_mail_store_add_by_account (EMailBackend *backend, EAccount *account) { EMailSession *session; CamelService *service = NULL; CamelProvider *provider; CamelURL *url; gboolean skip = FALSE, transport_only; GError *error = NULL; g_return_val_if_fail (E_IS_MAIL_BACKEND (backend), NULL); g_return_val_if_fail (E_IS_ACCOUNT (account), NULL); session = e_mail_backend_get_session (backend); /* check whether it's transport-only accounts */ transport_only = !account->source || !account->source->url || !*account->source->url; if (transport_only) goto handle_transport; /* Load the service, but don't connect. Check its provider, * and if this belongs in the folder tree model, add it. */ provider = camel_provider_get (account->source->url, &error); if (provider == NULL) { /* In case we do not have a provider here, we handle * the special case of having multiple mail identities * eg. a dummy account having just SMTP server defined */ goto handle_transport; } service = camel_session_add_service ( CAMEL_SESSION (session), account->uid, account->source->url, CAMEL_PROVIDER_STORE, &error); camel_service_set_display_name (service, account->name); handle_transport: if (account->transport) { /* While we're at it, add the account's transport to the * CamelSession. The transport's UID is a kludge for now. * We take the EAccount's UID and tack on "-transport". */ gchar *transport_uid; GError *transport_error = NULL; transport_uid = g_strconcat ( account->uid, "-transport", NULL); camel_session_add_service ( CAMEL_SESSION (session), transport_uid, account->transport->url, CAMEL_PROVIDER_TRANSPORT, &transport_error); g_free (transport_uid); if (transport_error) { g_warning ( "%s: Failed to add transport service: %s", G_STRFUNC, transport_error->message); g_error_free (transport_error); } } if (transport_only) return NULL; if (!CAMEL_IS_STORE (service)) goto fail; /* Do not add local-delivery files, * but make them ready for later use. */ url = camel_url_new (account->source->url, NULL); if (url != NULL) { skip = em_utils_is_local_delivery_mbox_file (url); camel_url_free (url); } if (!skip && (provider->flags & CAMEL_PROVIDER_IS_STORAGE)) e_mail_store_add (backend, CAMEL_STORE (service)); return CAMEL_STORE (service); fail: /* FIXME: Show an error dialog. */ g_warning ( "Couldn't get service: %s: %s", account->name, error ? error->message : "Not a CamelStore"); if (error) g_error_free (error); return NULL; }
void e_mail_shell_view_update_sidebar (EMailShellView *mail_shell_view) { EMailShellContent *mail_shell_content; EShellBackend *shell_backend; EShellSidebar *shell_sidebar; EShellView *shell_view; EShell *shell; EMailReader *reader; EMailView *mail_view; ESourceRegistry *registry; CamelStore *parent_store; CamelFolder *folder; CamelFolderInfoFlags flags = 0; CamelFolderSummary *folder_summary; MailFolderCache *folder_cache; MessageList *message_list; guint selected_count; GString *buffer, *title_short = NULL; gboolean store_is_local, is_inbox; const gchar *display_name; const gchar *folder_name; const gchar *uid; gchar *title; guint32 num_deleted; guint32 num_junked; guint32 num_junked_not_deleted; guint32 num_unread; guint32 num_visible; g_return_if_fail (E_IS_MAIL_SHELL_VIEW (mail_shell_view)); mail_shell_content = mail_shell_view->priv->mail_shell_content; mail_view = e_mail_shell_content_get_mail_view (mail_shell_content); shell_view = E_SHELL_VIEW (mail_shell_view); shell_backend = e_shell_view_get_shell_backend (shell_view); shell_sidebar = e_shell_view_get_shell_sidebar (shell_view); shell = e_shell_backend_get_shell (shell_backend); registry = e_shell_get_registry (shell); reader = E_MAIL_READER (mail_view); folder = e_mail_reader_ref_folder (reader); /* If no folder is selected, reset the sidebar banners * to their default values and stop. */ if (folder == NULL) { GtkAction *action; gchar *label; action = e_shell_view_get_action (shell_view); g_object_get (action, "label", &label, NULL); e_shell_sidebar_set_secondary_text (shell_sidebar, NULL); e_shell_view_set_title (shell_view, label); g_free (label); return; } folder_name = camel_folder_get_display_name (folder); parent_store = camel_folder_get_parent_store (folder); folder_summary = camel_folder_get_folder_summary (folder); folder_cache = e_mail_session_get_folder_cache ( e_mail_backend_get_session (E_MAIL_BACKEND (shell_backend))); mail_folder_cache_get_folder_info_flags (folder_cache, parent_store, folder_name, &flags); is_inbox = (flags & CAMEL_FOLDER_TYPE_MASK) == CAMEL_FOLDER_TYPE_INBOX; num_deleted = camel_folder_summary_get_deleted_count (folder_summary); num_junked = camel_folder_summary_get_junk_count (folder_summary); num_junked_not_deleted = camel_folder_summary_get_junk_not_deleted_count (folder_summary); num_unread = camel_folder_summary_get_unread_count (folder_summary); num_visible = camel_folder_summary_get_visible_count (folder_summary); buffer = g_string_sized_new (256); message_list = MESSAGE_LIST (e_mail_reader_get_message_list (reader)); selected_count = message_list_selected_count (message_list); if (selected_count > 1) g_string_append_printf ( buffer, ngettext ("%d selected, ", "%d selected, ", selected_count), selected_count); /* "Trash" folder (virtual or real) */ if (camel_folder_get_flags (folder) & CAMEL_FOLDER_IS_TRASH) { if (CAMEL_IS_VTRASH_FOLDER (folder)) { /* For a virtual Trash folder, count * the messages marked for deletion. */ g_string_append_printf ( buffer, ngettext ("%d deleted", "%d deleted", num_deleted), num_deleted); } else { /* For a regular Trash folder, just * count the visible messages. * * XXX Open question: what to do about messages * marked for deletion in Trash? Probably * this is the wrong question to be asking * anyway. Deleting a message in a real * Trash should permanently expunge the * message (if the server supports that), * which would eliminate this corner case. */ if (!e_mail_reader_get_hide_deleted (reader)) num_visible += num_deleted; g_string_append_printf ( buffer, ngettext ("%d deleted", "%d deleted", num_visible), num_visible); } /* "Junk" folder (virtual or real) */ } else if (camel_folder_get_flags (folder) & CAMEL_FOLDER_IS_JUNK) { if (e_mail_reader_get_hide_deleted (reader)) { /* Junk folder with deleted messages hidden. */ g_string_append_printf ( buffer, ngettext ("%d junk", "%d junk", num_junked_not_deleted), num_junked_not_deleted); } else { /* Junk folder with deleted messages visible. */ g_string_append_printf ( buffer, ngettext ("%d junk", "%d junk", num_junked), num_junked); } /* "Drafts" folder */ } else if (!is_inbox && em_utils_folder_is_drafts (registry, folder)) { g_string_append_printf ( buffer, ngettext ("%d draft", "%d drafts", num_visible), num_visible); /* "Outbox" folder */ } else if (!is_inbox && em_utils_folder_is_outbox (registry, folder)) { g_string_append_printf ( buffer, ngettext ("%d unsent", "%d unsent", num_visible), num_visible); /* "Sent" folder */ } else if (!is_inbox && em_utils_folder_is_sent (registry, folder)) { g_string_append_printf ( buffer, ngettext ("%d sent", "%d sent", num_visible), num_visible); /* Normal folder */ } else { if (!e_mail_reader_get_hide_deleted (reader)) num_visible += num_deleted - num_junked + num_junked_not_deleted; if (num_unread > 0 && selected_count <= 1) { g_string_append_printf ( buffer, ngettext ("%d unread, ", "%d unread, ", num_unread), num_unread); title_short = g_string_sized_new (64); g_string_append_printf ( title_short, ngettext ("%d unread", "%d unread", num_unread), num_unread); } g_string_append_printf ( buffer, ngettext ("%d total", "%d total", num_visible), num_visible); } uid = camel_service_get_uid (CAMEL_SERVICE (parent_store)); store_is_local = (g_strcmp0 (uid, E_MAIL_SESSION_LOCAL_UID) == 0); /* Choose a suitable folder name for displaying. */ display_name = folder_name; if (store_is_local) { if (strcmp (folder_name, "Drafts") == 0) display_name = _("Drafts"); else if (strcmp (folder_name, "Inbox") == 0) display_name = _("Inbox"); else if (strcmp (folder_name, "Outbox") == 0) display_name = _("Outbox"); else if (strcmp (folder_name, "Sent") == 0) display_name = _("Sent"); else if (strcmp (folder_name, "Templates") == 0) display_name = _("Templates"); else if (strcmp (folder_name, "Trash") == 0) display_name = _("Trash"); } if (strcmp (folder_name, "INBOX") == 0) display_name = _("Inbox"); if (title_short && title_short->len > 0) title = g_strdup_printf ("%s (%s)", display_name, title_short->str); else title = g_strdup (display_name); e_shell_sidebar_set_secondary_text (shell_sidebar, buffer->str); e_shell_view_set_title (shell_view, title); g_free (title); g_string_free (buffer, TRUE); if (title_short) g_string_free (title_short, TRUE); g_clear_object (&folder); }
void e_mail_shell_view_private_constructed (EMailShellView *mail_shell_view) { EMailShellViewPrivate *priv = mail_shell_view->priv; EMailShellContent *mail_shell_content; EMailShellSidebar *mail_shell_sidebar; EShell *shell; EShellView *shell_view; EShellBackend *shell_backend; EShellContent *shell_content; EShellSidebar *shell_sidebar; EShellTaskbar *shell_taskbar; EShellWindow *shell_window; EShellSearchbar *searchbar; EMFolderTree *folder_tree; EActionComboBox *combo_box; ERuleContext *context; EFilterRule *rule = NULL; GtkTreeSelection *selection; GtkUIManager *ui_manager; GtkWidget *message_list; GSettings *settings; EMailLabelListStore *label_store; EMailBackend *backend; EMailSession *session; EMailReader *reader; EMailView *mail_view; EMailDisplay *display; const gchar *source; guint merge_id; gint ii = 0; shell_view = E_SHELL_VIEW (mail_shell_view); shell_backend = e_shell_view_get_shell_backend (shell_view); shell_content = e_shell_view_get_shell_content (shell_view); shell_sidebar = e_shell_view_get_shell_sidebar (shell_view); shell_taskbar = e_shell_view_get_shell_taskbar (shell_view); shell_window = e_shell_view_get_shell_window (shell_view); ui_manager = e_shell_window_get_ui_manager (shell_window); shell = e_shell_window_get_shell (shell_window); backend = E_MAIL_BACKEND (shell_backend); session = e_mail_backend_get_session (backend); label_store = e_mail_ui_session_get_label_store ( E_MAIL_UI_SESSION (session)); e_shell_window_add_action_group (shell_window, "mail"); e_shell_window_add_action_group (shell_window, "mail-filter"); e_shell_window_add_action_group (shell_window, "mail-label"); e_shell_window_add_action_group (shell_window, "search-folders"); merge_id = gtk_ui_manager_new_merge_id (ui_manager); priv->label_merge_id = merge_id; /* Cache these to avoid lots of awkward casting. */ priv->mail_shell_backend = g_object_ref (shell_backend); priv->mail_shell_content = g_object_ref (shell_content); priv->mail_shell_sidebar = g_object_ref (shell_sidebar); mail_shell_sidebar = E_MAIL_SHELL_SIDEBAR (shell_sidebar); folder_tree = e_mail_shell_sidebar_get_folder_tree (mail_shell_sidebar); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_tree)); mail_shell_content = E_MAIL_SHELL_CONTENT (shell_content); mail_view = e_mail_shell_content_get_mail_view (mail_shell_content); searchbar = e_mail_shell_content_get_searchbar (mail_shell_content); combo_box = e_shell_searchbar_get_scope_combo_box (searchbar); reader = E_MAIL_READER (shell_content); display = e_mail_reader_get_mail_display (reader); message_list = e_mail_reader_get_message_list (reader); em_folder_tree_set_selectable_widget (folder_tree, message_list); /* The folder tree and scope combo box are both insensitive * when searching beyond the currently selected folder. */ e_binding_bind_property ( folder_tree, "sensitive", combo_box, "sensitive", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); combo_box = e_shell_searchbar_get_filter_combo_box (searchbar); g_signal_connect_object ( combo_box, "changed", G_CALLBACK (mail_shell_view_search_filter_changed_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( folder_tree, "folder-selected", G_CALLBACK (mail_shell_view_folder_tree_selected_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( folder_tree, "key-press-event", G_CALLBACK (mail_shell_view_folder_tree_key_press_event_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( folder_tree, "popup-event", G_CALLBACK (mail_shell_view_folder_tree_popup_event_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( message_list, "key-press", G_CALLBACK (mail_shell_view_message_list_key_press_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( message_list, "popup-menu", G_CALLBACK (mail_shell_view_message_list_popup_menu_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( message_list, "right-click", G_CALLBACK (mail_shell_view_message_list_right_click_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( reader, "changed", G_CALLBACK (mail_shell_view_reader_changed_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( mail_view, "update-actions", G_CALLBACK (mail_shell_view_reader_update_actions_cb), mail_shell_view, 0); g_signal_connect_object ( reader, "folder-loaded", G_CALLBACK (e_mail_view_update_view_instance), mail_view, G_CONNECT_SWAPPED); /* Use the same callback as "changed". */ g_signal_connect_object ( reader, "folder-loaded", G_CALLBACK (mail_shell_view_reader_changed_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( reader, "folder-loaded", G_CALLBACK (e_mail_shell_view_restore_state), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( label_store, "changed", G_CALLBACK (e_mail_shell_view_update_search_filter), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( display, "key-press-event", G_CALLBACK (mail_shell_view_key_press_event_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( display, "popup-event", G_CALLBACK (mail_shell_view_popup_event_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( display, "status-message", G_CALLBACK (e_shell_taskbar_set_message), shell_taskbar, G_CONNECT_SWAPPED); g_signal_connect_object ( mail_shell_view, "toggled", G_CALLBACK (e_mail_shell_view_update_send_receive_menus), mail_shell_view, G_CONNECT_AFTER | G_CONNECT_SWAPPED); /* Need to keep the handler ID so we can disconnect it in * dispose(). The shell outlives us and we don't want it * invoking callbacks on finalized shell views. */ priv->prepare_for_quit_handler_id = g_signal_connect_object ( shell, "prepare-for-quit", G_CALLBACK (mail_shell_view_prepare_for_quit_cb), mail_shell_view, G_CONNECT_SWAPPED); e_mail_reader_init (reader, TRUE, FALSE); e_mail_shell_view_actions_init (mail_shell_view); e_mail_shell_view_update_search_filter (mail_shell_view); /* This binding must come after e_mail_reader_init(). */ e_binding_bind_property ( shell_content, "group-by-threads", mail_view, "group-by-threads", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); settings = e_util_ref_settings ("org.gnome.evolution.mail"); g_settings_bind ( settings, "vfolder-allow-expunge", mail_shell_view, "vfolder-allow-expunge", G_SETTINGS_BIND_GET); g_clear_object (&settings); /* Populate built-in rules for search entry popup menu. * Keep the assertions, please. If the conditions aren't * met we're going to crash anyway, just more mysteriously. */ context = E_SHELL_VIEW_GET_CLASS (shell_view)->search_context; source = E_FILTER_SOURCE_DEMAND; while ((rule = e_rule_context_next_rule (context, rule, source))) { if (!rule->system) continue; g_return_if_fail (ii < MAIL_NUM_SEARCH_RULES); priv->search_rules[ii++] = g_object_ref (rule); } g_return_if_fail (ii == MAIL_NUM_SEARCH_RULES); /* Now that we're all set up, simulate selecting a folder. */ g_signal_emit_by_name (selection, "changed"); }
static GtkWidget * create_send_receive_submenu (EMailShellView *mail_shell_view) { EShellView *shell_view; EShellWindow *shell_window; EShellBackend *shell_backend; EMailAccountStore *account_store; EMailBackend *backend; EMailSession *session; GtkWidget *menu; GtkAccelGroup *accel_group; GtkUIManager *ui_manager; GtkAction *action; GtkTreeModel *model; GtkTreeIter iter; SendReceiveData *data; g_return_val_if_fail (mail_shell_view != NULL, NULL); shell_view = E_SHELL_VIEW (mail_shell_view); shell_window = e_shell_view_get_shell_window (shell_view); shell_backend = e_shell_view_get_shell_backend (shell_view); backend = E_MAIL_BACKEND (shell_backend); session = e_mail_backend_get_session (backend); account_store = e_mail_ui_session_get_account_store (E_MAIL_UI_SESSION (session)); menu = gtk_menu_new (); ui_manager = e_shell_window_get_ui_manager (shell_window); accel_group = gtk_ui_manager_get_accel_group (ui_manager); action = e_shell_window_get_action (shell_window, "mail-send-receive"); gtk_action_set_accel_group (action, accel_group); gtk_menu_shell_append ( GTK_MENU_SHELL (menu), gtk_action_create_menu_item (action)); action = e_shell_window_get_action ( shell_window, "mail-send-receive-receive-all"); gtk_action_set_accel_group (action, accel_group); gtk_menu_shell_append ( GTK_MENU_SHELL (menu), gtk_action_create_menu_item (action)); action = e_shell_window_get_action ( shell_window, "mail-send-receive-send-all"); gtk_action_set_accel_group (action, accel_group); gtk_menu_shell_append ( GTK_MENU_SHELL (menu), gtk_action_create_menu_item (action)); gtk_menu_shell_append ( GTK_MENU_SHELL (menu), gtk_separator_menu_item_new ()); data = send_receive_data_new (mail_shell_view, menu); model = GTK_TREE_MODEL (account_store); if (gtk_tree_model_get_iter_first (model, &iter)) { CamelService *service; do { service = NULL; gtk_tree_model_get ( model, &iter, E_MAIL_ACCOUNT_STORE_COLUMN_SERVICE, &service, -1); if (send_receive_can_use_service (account_store, service, &iter)) send_receive_add_to_menu (data, service, -1); if (service) g_object_unref (service); } while (gtk_tree_model_iter_next (model, &iter)); } gtk_widget_show_all (menu); return menu; }
/** * mail_vfolder_add_folder: * @backend: an #EMailBackend * @store: a #CamelStore * @folder: a folder name * @remove: whether the folder should be removed or added * * Called when a new folder becomes (un)available. If @store is not a * CamelVeeStore, the folder is added/removed from the list of cached source * folders. Then each vfolder rule is checked to see if the specified folder * matches a source of the rule. It builds a list of vfolders that use (or * would use) the specified folder as a source. It then adds (or removes) * this folder to (from) those vfolders via camel_vee_folder_add/ * remove_folder() but does not modify the actual filters or write changes * to disk. * * NOTE: This function must be called from the main thread. */ static void mail_vfolder_add_folder (EMailBackend *backend, CamelStore *store, const gchar *folder_name, gint remove) { EMailSession *session; EFilterRule *rule; const gchar *source; CamelVeeFolder *vf; CamelProvider *provider; GList *folders = NULL, *link; GQueue *queue; gint remote; gint is_ignore; gchar *uri; session = e_mail_backend_get_session (backend); provider = camel_service_get_provider (CAMEL_SERVICE (store)); remote = (provider->flags & CAMEL_PROVIDER_IS_REMOTE) != 0; queue = remote ? &source_folders_remote : &source_folders_local; if (folder_is_spethal (store, folder_name)) return; g_return_if_fail (mail_in_main_thread ()); uri = e_mail_folder_uri_build (store, folder_name); is_ignore = uri_is_ignore (backend, uri); G_LOCK (vfolder); /* maintain the source folders lists for changed rules later on */ if (CAMEL_IS_VEE_STORE (store)) { is_ignore = TRUE; } else if (remove) { link = mv_find_folder (queue, session, uri); if (link != NULL) { g_free (link->data); g_queue_delete_link (queue, link); } } else if (!is_ignore) { /* we ignore drafts/sent/outbox here */ if (mv_find_folder (queue, session, uri) == NULL) g_queue_push_tail (queue, g_strdup (uri)); } if (context == NULL) goto done; rule = NULL; while ((rule = e_rule_context_next_rule ((ERuleContext *) context, rule, NULL))) { gint found = FALSE; if (!rule->name) { d(printf("invalid rule (%p): rule->name is set to NULL\n", rule)); continue; } /* Don't auto-add any sent/drafts folders etc, * they must be explictly listed as a source. */ if (rule->source && !is_ignore && ((((EMVFolderRule *) rule)->with == EM_VFOLDER_RULE_WITH_LOCAL && !remote) || (((EMVFolderRule *) rule)->with == EM_VFOLDER_RULE_WITH_REMOTE_ACTIVE && remote) || (((EMVFolderRule *) rule)->with == EM_VFOLDER_RULE_WITH_LOCAL_REMOTE_ACTIVE))) found = TRUE; source = NULL; while (!found && (source = em_vfolder_rule_next_source ( (EMVFolderRule *) rule, source))) { found = e_mail_folder_uri_equal ( CAMEL_SESSION (session), uri, source); } if (found) { vf = g_hash_table_lookup (vfolder_hash, rule->name); if (!vf) { g_warning ("vf is NULL for %s\n", rule->name); continue; } g_object_ref (vf); folders = g_list_prepend (folders, vf); } } done: G_UNLOCK (vfolder); if (folders != NULL) vfolder_adduri (backend, uri, folders, remove); g_free (uri); }
static void mail_attachment_handler_x_uid_list (EAttachmentView *view, GdkDragContext *drag_context, gint x, gint y, GtkSelectionData *selection_data, guint info, guint time, EAttachmentHandler *handler) { static GdkAtom atom = GDK_NONE; EMailAttachmentHandlerPrivate *priv; CamelDataWrapper *wrapper; CamelMimeMessage *message; CamelMultipart *multipart; CamelMimePart *mime_part; CamelFolder *folder = NULL; EAttachment *attachment; EAttachmentStore *store; EMailSession *session; GPtrArray *uids; const gchar *data; const gchar *cp, *end; gchar *description; gpointer parent; gint length; guint ii; GError *local_error = NULL; if (G_UNLIKELY (atom == GDK_NONE)) atom = gdk_atom_intern_static_string ("x-uid-list"); if (gtk_selection_data_get_target (selection_data) != atom) return; store = e_attachment_view_get_store (view); priv = E_MAIL_ATTACHMENT_HANDLER_GET_PRIVATE (handler); parent = gtk_widget_get_toplevel (GTK_WIDGET (view)); parent = gtk_widget_is_toplevel (parent) ? parent : NULL; uids = g_ptr_array_new (); data = (const gchar *) gtk_selection_data_get_data (selection_data); length = gtk_selection_data_get_length (selection_data); /* The UID list is delimited by NUL characters. * Brilliant. So we can't use g_strsplit(). */ cp = data; end = data + length; while (cp < end) { const gchar *start = cp; while (cp < end && *cp != '\0') cp++; /* Skip the first string. */ if (start > data) g_ptr_array_add (uids, g_strndup (start, cp - start)); cp++; } if (uids->len == 0) goto exit; session = e_mail_backend_get_session (priv->backend); /* The first string is the folder URI. */ /* FIXME Not passing a GCancellable here. */ folder = e_mail_session_uri_to_folder_sync ( session, data, 0, NULL, &local_error); if (folder == NULL) goto exit; /* Handle one message. */ if (uids->len == 1) { const gchar *message_uid; message_uid = g_ptr_array_index (uids, 0); /* FIXME Not passing a GCancellable here. */ message = camel_folder_get_message_sync ( folder, message_uid, NULL, &local_error); if (message == NULL) goto exit; attachment = e_attachment_new_for_message (message); e_attachment_store_add_attachment (store, attachment); e_attachment_load_async ( attachment, (GAsyncReadyCallback) call_attachment_load_handle_error, parent ? g_object_ref (parent) : NULL); g_object_unref (attachment); g_object_unref (message); goto exit; } /* Build a multipart/digest message out of the UIDs. */ multipart = camel_multipart_new (); wrapper = CAMEL_DATA_WRAPPER (multipart); camel_data_wrapper_set_mime_type (wrapper, "multipart/digest"); camel_multipart_set_boundary (multipart, NULL); for (ii = 0; ii < uids->len; ii++) { /* FIXME Not passing a GCancellable here. */ message = camel_folder_get_message_sync ( folder, uids->pdata[ii], NULL, &local_error); if (message == NULL) { g_object_unref (multipart); goto exit; } mime_part = camel_mime_part_new (); wrapper = CAMEL_DATA_WRAPPER (message); camel_mime_part_set_disposition (mime_part, "inline"); camel_medium_set_content ( CAMEL_MEDIUM (mime_part), wrapper); camel_mime_part_set_content_type (mime_part, "message/rfc822"); camel_multipart_add_part (multipart, mime_part); g_object_unref (mime_part); g_object_unref (message); } mime_part = camel_mime_part_new (); wrapper = CAMEL_DATA_WRAPPER (multipart); camel_medium_set_content (CAMEL_MEDIUM (mime_part), wrapper); description = g_strdup_printf ( ngettext ( "%d attached message", "%d attached messages", uids->len), uids->len); camel_mime_part_set_description (mime_part, description); g_free (description); attachment = e_attachment_new (); e_attachment_set_mime_part (attachment, mime_part); e_attachment_store_add_attachment (store, attachment); e_attachment_load_async ( attachment, (GAsyncReadyCallback) call_attachment_load_handle_error, parent ? g_object_ref (parent) : NULL); g_object_unref (attachment); g_object_unref (mime_part); g_object_unref (multipart); exit: if (local_error != NULL) { const gchar *folder_name = data; if (folder != NULL) folder_name = camel_folder_get_display_name (folder); e_alert_run_dialog_for_args ( parent, "mail-composer:attach-nomessages", folder_name, local_error->message, NULL); g_clear_error (&local_error); } if (folder != NULL) g_object_unref (folder); g_ptr_array_free (uids, TRUE); g_signal_stop_emission_by_name (view, "drag-data-received"); }
/** * mail_vfolder_delete_folder: * @backend: an #EMailBackend * @store: a #CamelStore * @folder_name: a folder name * * Looks through all vfolder rules to see if @folder_name is listed as a * source for any vfolder rules. If the folder is found in the source for * any rule, it is removed and the user is alerted to the fact that the * vfolder rules have been updated. The new vfolder rules are written * to disk. * * XXX: It doesn't appear that the changes to the vfolder rules are sent * down to the camel level, however. So the actual vfolders will not change * behavior until evolution is restarted (?) * * NOTE: This function must be called from the main thread. */ static void mail_vfolder_delete_folder (EMailBackend *backend, CamelStore *store, const gchar *folder_name) { ERuleContext *rule_context; EFilterRule *rule; EMailSession *session; const gchar *source; CamelVeeFolder *vf; GString *changed; GQueue *queue; guint changed_count; gchar *uri; GList *link; g_return_if_fail (E_IS_MAIL_BACKEND (backend)); g_return_if_fail (CAMEL_IS_STORE (store)); g_return_if_fail (folder_name != NULL); if (folder_is_spethal (store, folder_name)) return; d(printf ("Deleting uri to check: %s\n", uri)); g_return_if_fail (mail_in_main_thread ()); session = e_mail_backend_get_session (backend); uri = e_mail_folder_uri_build (store, folder_name); changed_count = 0; changed = g_string_new (""); G_LOCK (vfolder); if (context == NULL) goto done; rule_context = E_RULE_CONTEXT (context); /* see if any rules directly reference this removed uri */ rule = NULL; while ((rule = e_rule_context_next_rule (rule_context, rule, NULL))) { EMVFolderRule *vf_rule = EM_VFOLDER_RULE (rule); if (!rule->name) continue; source = NULL; while ((source = em_vfolder_rule_next_source (vf_rule, source))) { /* Remove all sources that match, ignore changed events though * because the adduri call above does the work async */ if (e_mail_folder_uri_equal (CAMEL_SESSION (session), uri, source)) { vf = g_hash_table_lookup ( vfolder_hash, rule->name); if (!vf) { g_warning ("vf is NULL for %s\n", rule->name); continue; } g_signal_handlers_disconnect_matched ( rule, G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, rule_changed, vf); em_vfolder_rule_remove_source (vf_rule, source); g_signal_connect ( rule, "changed", G_CALLBACK (rule_changed), vf); if (changed_count == 0) { g_string_append (changed, rule->name); } else { if (changed_count == 1) { g_string_prepend (changed, " "); g_string_append (changed, "\n"); } g_string_append_printf ( changed, " %s\n", rule->name); } changed_count++; source = NULL; } } } done: queue = &source_folders_remote; link = mv_find_folder (queue, session, uri); if (link != NULL) { g_free (link->data); g_queue_delete_link (queue, link); } queue = &source_folders_local; link = mv_find_folder (queue, session, uri); if (link != NULL) { g_free (link->data); g_queue_delete_link (queue, link); } G_UNLOCK (vfolder); if (changed_count > 0) { const gchar *config_dir; gchar *user, *info; info = g_strdup_printf (ngettext ( /* Translators: The first %s is name of the affected * search folder(s), the second %s is the URI of the * removed folder. For more than one search folder is * each of them on a separate line, with four spaces * in front of its name, without quotes. */ "The Search Folder \"%s\" has been modified to " "account for the deleted folder\n\"%s\".", "The following Search Folders\n%s have been modified " "to account for the deleted folder\n\"%s\".", changed_count), changed->str, uri); e_mail_backend_submit_alert ( backend, "mail:vfolder-updated", info, NULL); g_free (info); config_dir = mail_session_get_config_dir (); user = g_build_filename (config_dir, "vfolders.xml", NULL); e_rule_context_save ((ERuleContext *) context, user); g_free (user); } g_string_free (changed, TRUE); g_free (uri); }
static void rule_changed (EFilterRule *rule, CamelFolder *folder) { EMailBackend *backend; EMailSession *session; GList *sources_uri = NULL, *sources_folder = NULL; GString *query; const gchar *full_name; full_name = camel_folder_get_full_name (folder); backend = em_vfolder_rule_get_backend (EM_VFOLDER_RULE (rule)); session = e_mail_backend_get_session (backend); /* if the folder has changed name, then add it, then remove the old manually */ if (strcmp (full_name, rule->name) != 0) { gchar *oldname; gpointer key; gpointer oldfolder; G_LOCK (vfolder); d(printf("Changing folder name in hash table to '%s'\n", rule->name)); if (g_hash_table_lookup_extended (vfolder_hash, full_name, &key, &oldfolder)) { g_hash_table_remove (vfolder_hash, key); g_free (key); g_hash_table_insert (vfolder_hash, g_strdup (rule->name), folder); G_UNLOCK (vfolder); } else { G_UNLOCK (vfolder); g_warning("couldn't find a vfolder rule in our table? %s", full_name); } oldname = g_strdup (full_name); /* FIXME Not passing a GCancellable or GError. */ camel_store_rename_folder_sync ( vfolder_store, oldname, rule->name, NULL, NULL); g_free (oldname); } d(printf("Filter rule changed? for folder '%s'!!\n", folder->name)); /* find any (currently available) folders, and add them to the ones to open */ rule_add_sources ( session, &((EMVFolderRule *) rule)->sources, &sources_folder, &sources_uri); G_LOCK (vfolder); if (((EMVFolderRule *) rule)->with == EM_VFOLDER_RULE_WITH_LOCAL || ((EMVFolderRule *) rule)->with == EM_VFOLDER_RULE_WITH_LOCAL_REMOTE_ACTIVE) rule_add_sources ( session, &source_folders_local, &sources_folder, &sources_uri); if (((EMVFolderRule *) rule)->with == EM_VFOLDER_RULE_WITH_REMOTE_ACTIVE || ((EMVFolderRule *) rule)->with == EM_VFOLDER_RULE_WITH_LOCAL_REMOTE_ACTIVE) rule_add_sources ( session, &source_folders_remote, &sources_folder, &sources_uri); G_UNLOCK (vfolder); query = g_string_new(""); e_filter_rule_build_code (rule, query); vfolder_setup (session, folder, query->str, sources_uri, sources_folder); g_string_free (query, TRUE); }
static void dbx_import_file (DbxImporter *m) { EShell *shell; EShellBackend *shell_backend; EMailSession *session; GCancellable *cancellable; gchar *filename; CamelFolder *folder; gint tmpfile; gint i; gint missing = 0; m->status_what = NULL; filename = g_filename_from_uri ( ((EImportTargetURI *) m->target)->uri_src, NULL, NULL); /* Destination folder, was set in our widget */ m->parent_uri = g_strdup (((EImportTargetURI *) m->target)->uri_dest); cancellable = m->base.cancellable; /* XXX Dig up the EMailSession from the default EShell. * Since the EImport framework doesn't allow for user * data, I don't see how else to get to it. */ shell = e_shell_get_default (); shell_backend = e_shell_get_backend_by_name (shell, "mail"); session = e_mail_backend_get_session (E_MAIL_BACKEND (shell_backend)); camel_operation_push_message (NULL, _("Importing “%s”"), filename); folder = e_mail_session_uri_to_folder_sync ( session, m->parent_uri, CAMEL_STORE_FOLDER_CREATE, cancellable, &m->base.error); if (!folder) return; d (printf ("importing to %s\n", camel_folder_get_full_name (folder))); camel_folder_freeze (folder); filename = g_filename_from_uri ( ((EImportTargetURI *) m->target)->uri_src, NULL, NULL); m->dbx_fd = g_open (filename, O_RDONLY, 0); g_free (filename); if (m->dbx_fd == -1) { g_set_error ( &m->base.error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, "Failed to open import file"); goto out; } if (!dbx_load_indices (m)) goto out; tmpfile = e_mkstemp ("dbx-import-XXXXXX"); if (tmpfile == -1) { g_set_error ( &m->base.error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, "Failed to create temporary file for import"); goto out; } for (i = 0; i < m->index_count; i++) { CamelMessageInfo *info; CamelMimeMessage *msg; CamelMimeParser *mp; gint dbx_flags = 0; gint flags = 0; gboolean success; camel_operation_progress (NULL, 100 * i / m->index_count); camel_operation_progress (cancellable, 100 * i / m->index_count); if (!dbx_read_email (m, m->indices[i], tmpfile, &dbx_flags)) { d ( printf ("Cannot read email index %d at %x\n", i, m->indices[i])); if (m->base.error != NULL) goto out; missing++; continue; } if (dbx_flags & 0x40) flags |= CAMEL_MESSAGE_DELETED; if (dbx_flags & 0x80) flags |= CAMEL_MESSAGE_SEEN; if (dbx_flags & 0x80000) flags |= CAMEL_MESSAGE_ANSWERED; mp = camel_mime_parser_new (); lseek (tmpfile, 0, SEEK_SET); camel_mime_parser_init_with_fd (mp, tmpfile); msg = camel_mime_message_new (); if (!camel_mime_part_construct_from_parser_sync ( (CamelMimePart *) msg, mp, NULL, NULL)) { /* set exception? */ g_object_unref (msg); g_object_unref (mp); break; } info = camel_message_info_new (NULL); camel_message_info_set_flags (info, flags, ~0); success = camel_folder_append_message_sync ( folder, msg, info, NULL, cancellable, &m->base.error); g_clear_object (&info); g_object_unref (msg); if (!success) { g_object_unref (mp); break; } } out: if (m->dbx_fd != -1) close (m->dbx_fd); if (m->indices) g_free (m->indices); /* FIXME Not passing GCancellable or GError here. */ camel_folder_synchronize_sync (folder, FALSE, NULL, NULL); camel_folder_thaw (folder); g_object_unref (folder); if (missing && m->base.error == NULL) { g_set_error ( &m->base.error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, "%d messages imported correctly; %d message " "bodies were not present in the DBX file", m->index_count - missing, missing); } camel_operation_pop_message (NULL); }
void vfolder_edit_rule (EMailBackend *backend, const gchar *folder_uri) { GtkWidget *dialog; GtkWidget *widget; GtkWidget *container; EFilterRule *rule = NULL; EFilterRule *newrule; EMailSession *session; gchar *folder_name = NULL; g_return_if_fail (E_IS_MAIL_BACKEND (backend)); g_return_if_fail (folder_uri != NULL); session = e_mail_backend_get_session (backend); e_mail_folder_uri_parse ( CAMEL_SESSION (session), folder_uri, NULL, &folder_name, NULL); if (folder_name != NULL) { rule = e_rule_context_find_rule ( (ERuleContext *) context, folder_name, NULL); g_free (folder_name); } if (rule == NULL) { /* TODO: we should probably just create it ... */ e_mail_backend_submit_alert ( backend, "mail:vfolder-notexist", folder_uri, NULL); return; } g_object_ref (rule); newrule = e_filter_rule_clone (rule); dialog = gtk_dialog_new_with_buttons ( _("Edit Search Folder"), NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_container_set_border_width (GTK_CONTAINER (dialog), 6); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_window_set_default_size (GTK_WINDOW (dialog), 500, 500); gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE); container = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_box_set_spacing (GTK_BOX (container), 6); widget = e_filter_rule_get_widget ( (EFilterRule *) newrule, (ERuleContext *) context); gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0); gtk_widget_show (widget); g_object_set_data_full (G_OBJECT (dialog), "vfolder-rule", rule, g_object_unref); g_object_set_data_full (G_OBJECT (dialog), "vfolder-newrule", newrule, g_object_unref); g_signal_connect (dialog, "response", G_CALLBACK (vfolder_edit_response_cb), NULL); gtk_widget_show (dialog); }
static void mail_shell_view_execute_search (EShellView *shell_view) { EMailShellViewPrivate *priv; EMailShellContent *mail_shell_content; EMailShellSidebar *mail_shell_sidebar; EShellWindow *shell_window; EShellBackend *shell_backend; EShellContent *shell_content; EShellSidebar *shell_sidebar; EShellSearchbar *searchbar; EActionComboBox *combo_box; EMailBackend *backend; EMailSession *session; ESourceRegistry *registry; EMFolderTree *folder_tree; GtkWidget *message_list; EFilterRule *rule; EMailReader *reader; EMailView *mail_view; CamelVeeFolder *search_folder; CamelFolder *folder; CamelService *service; CamelStore *store; GtkAction *action; EMailLabelListStore *label_store; GtkTreePath *path; GtkTreeIter tree_iter; GString *string; GList *list, *iter; GSList *search_strings = NULL; const gchar *text; gboolean valid; gchar *query; gchar *temp; gchar *tag; const gchar *use_tag; gint value; priv = E_MAIL_SHELL_VIEW_GET_PRIVATE (shell_view); shell_window = e_shell_view_get_shell_window (shell_view); shell_backend = e_shell_view_get_shell_backend (shell_view); shell_content = e_shell_view_get_shell_content (shell_view); shell_sidebar = e_shell_view_get_shell_sidebar (shell_view); backend = E_MAIL_BACKEND (shell_backend); session = e_mail_backend_get_session (backend); mail_shell_content = E_MAIL_SHELL_CONTENT (shell_content); mail_view = e_mail_shell_content_get_mail_view (mail_shell_content); searchbar = e_mail_shell_content_get_searchbar (mail_shell_content); mail_shell_sidebar = E_MAIL_SHELL_SIDEBAR (shell_sidebar); folder_tree = e_mail_shell_sidebar_get_folder_tree (mail_shell_sidebar); reader = E_MAIL_READER (mail_view); folder = e_mail_reader_ref_folder (reader); message_list = e_mail_reader_get_message_list (reader); registry = e_mail_session_get_registry (session); label_store = e_mail_ui_session_get_label_store ( E_MAIL_UI_SESSION (session)); action = ACTION (MAIL_SEARCH_SUBJECT_OR_ADDRESSES_CONTAIN); value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action)); text = e_shell_searchbar_get_search_text (searchbar); if (value == MAIL_SEARCH_ADVANCED || text == NULL || *text == '\0') { if (value != MAIL_SEARCH_ADVANCED) e_shell_view_set_search_rule (shell_view, NULL); query = e_shell_view_get_search_query (shell_view); if (!query) query = g_strdup (""); goto filter; } /* Replace variables in the selected rule with the * current search text and extract a query string. */ g_return_if_fail (value >= 0 && value < MAIL_NUM_SEARCH_RULES); rule = priv->search_rules[value]; /* Set the search rule in EShellView so that "Create * Search Folder from Search" works for quick searches. */ e_shell_view_set_search_rule (shell_view, rule); for (iter = rule->parts; iter != NULL; iter = iter->next) { EFilterPart *part = iter->data; EFilterElement *element = NULL; if (strcmp (part->name, "subject") == 0) element = e_filter_part_find_element (part, "subject"); else if (strcmp (part->name, "body") == 0) element = e_filter_part_find_element (part, "word"); else if (strcmp (part->name, "sender") == 0) element = e_filter_part_find_element (part, "sender"); else if (strcmp (part->name, "to") == 0) element = e_filter_part_find_element (part, "recipient"); if (strcmp (part->name, "body") == 0) { struct _camel_search_words *words; gint ii; words = camel_search_words_split ((guchar *) text); for (ii = 0; ii < words->len; ii++) search_strings = g_slist_prepend ( search_strings, g_strdup ( words->words[ii]->word)); camel_search_words_free (words); } if (element != NULL) { EFilterInput *input = E_FILTER_INPUT (element); e_filter_input_set_value (input, text); } } string = g_string_sized_new (1024); e_filter_rule_build_code (rule, string); query = g_string_free (string, FALSE); filter: /* Apply selected filter. */ combo_box = e_shell_searchbar_get_filter_combo_box (searchbar); value = e_action_combo_box_get_current_value (combo_box); switch (value) { case MAIL_FILTER_ALL_MESSAGES: break; case MAIL_FILTER_UNREAD_MESSAGES: temp = g_strdup_printf ( "(and %s (match-all (not " "(system-flag \"Seen\"))))", query); g_free (query); query = temp; break; case MAIL_FILTER_NO_LABEL: string = g_string_sized_new (1024); g_string_append_printf ( string, "(and %s (and ", query); valid = gtk_tree_model_get_iter_first ( GTK_TREE_MODEL (label_store), &tree_iter); while (valid) { tag = e_mail_label_list_store_get_tag ( label_store, &tree_iter); use_tag = tag; if (g_str_has_prefix (use_tag, "$Label")) use_tag += 6; g_string_append_printf ( string, " (match-all (not (or " "(= (user-tag \"label\") \"%s\") " "(user-flag \"$Label%s\") " "(user-flag \"%s\"))))", use_tag, use_tag, use_tag); g_free (tag); valid = gtk_tree_model_iter_next ( GTK_TREE_MODEL (label_store), &tree_iter); } g_string_append_len (string, "))", 2); g_free (query); query = g_string_free (string, FALSE); break; case MAIL_FILTER_READ_MESSAGES: temp = g_strdup_printf ( "(and %s (match-all " "(system-flag \"Seen\")))", query); g_free (query); query = temp; break; case MAIL_FILTER_LAST_5_DAYS_MESSAGES: if (em_utils_folder_is_sent (registry, folder)) temp = g_strdup_printf ( "(and %s (match-all " "(> (get-sent-date) " "(- (get-current-date) 432000))))", query); else temp = g_strdup_printf ( "(and %s (match-all " "(> (get-received-date) " "(- (get-current-date) 432000))))", query); g_free (query); query = temp; break; case MAIL_FILTER_MESSAGES_WITH_ATTACHMENTS: temp = g_strdup_printf ( "(and %s (match-all " "(system-flag \"Attachments\")))", query); g_free (query); query = temp; break; case MAIL_FILTER_IMPORTANT_MESSAGES: temp = g_strdup_printf ( "(and %s (match-all " "(system-flag \"Flagged\")))", query); g_free (query); query = temp; break; case MAIL_FILTER_MESSAGES_NOT_JUNK: temp = g_strdup_printf ( "(and %s (match-all (not " "(system-flag \"junk\"))))", query); g_free (query); query = temp; break; default: /* The action value also serves as a path for * the label list store. That's why we number * the label actions from zero. */ path = gtk_tree_path_new_from_indices (value, -1); gtk_tree_model_get_iter ( GTK_TREE_MODEL (label_store), &tree_iter, path); gtk_tree_path_free (path); tag = e_mail_label_list_store_get_tag ( label_store, &tree_iter); use_tag = tag; if (g_str_has_prefix (use_tag, "$Label")) use_tag += 6; temp = g_strdup_printf ( "(and %s (match-all (or " "(= (user-tag \"label\") \"%s\") " "(user-flag \"$Label%s\") " "(user-flag \"%s\"))))", query, use_tag, use_tag, use_tag); g_free (tag); g_free (query); query = temp; break; } /* Apply selected scope. */ combo_box = e_shell_searchbar_get_scope_combo_box (searchbar); value = e_action_combo_box_get_current_value (combo_box); switch (value) { case MAIL_SCOPE_CURRENT_FOLDER: goto execute; case MAIL_SCOPE_CURRENT_ACCOUNT: goto current_account; case MAIL_SCOPE_ALL_ACCOUNTS: goto all_accounts; default: g_warn_if_reached (); goto execute; } all_accounts: /* Prepare search folder for all accounts. */ /* If the search text is empty, cancel any * account-wide searches still in progress. */ text = e_shell_searchbar_get_search_text (searchbar); if (text == NULL || *text == '\0') { CamelStore *selected_store = NULL; gchar *selected_folder_name = NULL; if (priv->search_account_all != NULL) { g_object_unref (priv->search_account_all); priv->search_account_all = NULL; } if (priv->search_account_cancel != NULL) { g_cancellable_cancel (priv->search_account_cancel); g_object_unref (priv->search_account_cancel); priv->search_account_cancel = NULL; } /* Reset the message list to the current folder tree * selection. This needs to happen synchronously to * avoid search conflicts, so we can't just grab the * folder URI and let the asynchronous callbacks run * after we've already kicked off the search. */ em_folder_tree_get_selected ( folder_tree, &selected_store, &selected_folder_name); if (selected_store != NULL && selected_folder_name != NULL) { folder = camel_store_get_folder_sync ( selected_store, selected_folder_name, CAMEL_STORE_FOLDER_INFO_FAST, NULL, NULL); e_mail_reader_set_folder (reader, folder); g_object_unref (folder); } g_clear_object (&selected_store); g_free (selected_folder_name); gtk_widget_set_sensitive (GTK_WIDGET (combo_box), TRUE); goto execute; } search_folder = priv->search_account_all; /* Skip the search if we already have the results. */ if (search_folder != NULL) { const gchar *vf_query; vf_query = camel_vee_folder_get_expression (search_folder); if (g_strcmp0 (query, vf_query) == 0) goto all_accounts_setup; } /* Disable the scope combo while search is in progress. */ gtk_widget_set_sensitive (GTK_WIDGET (combo_box), FALSE); /* If we already have a search folder, reuse it. */ if (search_folder != NULL) { if (priv->search_account_cancel != NULL) { g_cancellable_cancel (priv->search_account_cancel); g_object_unref (priv->search_account_cancel); priv->search_account_cancel = NULL; } camel_vee_folder_set_expression (search_folder, query); goto all_accounts_setup; } /* Create a new search folder. */ /* FIXME Complete lack of error checking here. */ service = camel_session_ref_service ( CAMEL_SESSION (session), E_MAIL_SESSION_VFOLDER_UID); camel_service_connect_sync (service, NULL, NULL); search_folder = (CamelVeeFolder *) camel_vee_folder_new ( CAMEL_STORE (service), _("All Account Search"), CAMEL_STORE_FOLDER_PRIVATE); priv->search_account_all = search_folder; g_object_unref (service); camel_vee_folder_set_expression (search_folder, query); all_accounts_setup: list = em_folder_tree_model_list_stores (EM_FOLDER_TREE_MODEL ( gtk_tree_view_get_model (GTK_TREE_VIEW (folder_tree)))); g_list_foreach (list, (GFunc) g_object_ref, NULL); priv->search_account_cancel = camel_operation_new (); /* This takes ownership of the stores list. */ mail_shell_view_setup_search_results_folder ( CAMEL_FOLDER (search_folder), list, priv->search_account_cancel); mail_shell_view_show_search_results_folder ( E_MAIL_SHELL_VIEW (shell_view), CAMEL_FOLDER (search_folder)); goto execute; current_account: /* Prepare search folder for current account only. */ /* If the search text is empty, cancel any * account-wide searches still in progress. */ text = e_shell_searchbar_get_search_text (searchbar); if (text == NULL || *text == '\0') { CamelStore *selected_store = NULL; gchar *selected_folder_name = NULL; if (priv->search_account_current != NULL) { g_object_unref (priv->search_account_current); priv->search_account_current = NULL; } if (priv->search_account_cancel != NULL) { g_cancellable_cancel (priv->search_account_cancel); g_object_unref (priv->search_account_cancel); priv->search_account_cancel = NULL; } /* Reset the message list to the current folder tree * selection. This needs to happen synchronously to * avoid search conflicts, so we can't just grab the * folder URI and let the asynchronous callbacks run * after we've already kicked off the search. */ em_folder_tree_get_selected ( folder_tree, &selected_store, &selected_folder_name); if (selected_store != NULL && selected_folder_name != NULL) { folder = camel_store_get_folder_sync ( selected_store, selected_folder_name, CAMEL_STORE_FOLDER_INFO_FAST, NULL, NULL); e_mail_reader_set_folder (reader, folder); g_object_unref (folder); } g_clear_object (&selected_store); g_free (selected_folder_name); gtk_widget_set_sensitive (GTK_WIDGET (combo_box), TRUE); goto execute; } search_folder = priv->search_account_current; /* Skip the search if we already have the results. */ if (search_folder != NULL) { const gchar *vf_query; vf_query = camel_vee_folder_get_expression (search_folder); if (g_strcmp0 (query, vf_query) == 0) goto current_accout_setup; } /* Disable the scope combo while search is in progress. */ gtk_widget_set_sensitive (GTK_WIDGET (combo_box), FALSE); /* If we already have a search folder, reuse it. */ if (search_folder != NULL) { if (priv->search_account_cancel != NULL) { g_cancellable_cancel (priv->search_account_cancel); g_object_unref (priv->search_account_cancel); priv->search_account_cancel = NULL; } camel_vee_folder_set_expression (search_folder, query); goto current_accout_setup; } /* Create a new search folder. */ /* FIXME Complete lack of error checking here. */ service = camel_session_ref_service ( CAMEL_SESSION (session), E_MAIL_SESSION_VFOLDER_UID); camel_service_connect_sync (service, NULL, NULL); search_folder = (CamelVeeFolder *) camel_vee_folder_new ( CAMEL_STORE (service), _("Account Search"), CAMEL_STORE_FOLDER_PRIVATE); priv->search_account_current = search_folder; g_object_unref (service); camel_vee_folder_set_expression (search_folder, query); current_accout_setup: if (folder != NULL && folder != CAMEL_FOLDER (search_folder)) { store = camel_folder_get_parent_store (folder); if (store != NULL) g_object_ref (store); } else { store = NULL; em_folder_tree_get_selected (folder_tree, &store, NULL); } list = NULL; /* list of CamelStore-s */ if (store != NULL) list = g_list_append (NULL, store); priv->search_account_cancel = camel_operation_new (); /* This takes ownership of the stores list. */ mail_shell_view_setup_search_results_folder ( CAMEL_FOLDER (search_folder), list, priv->search_account_cancel); mail_shell_view_show_search_results_folder ( E_MAIL_SHELL_VIEW (shell_view), CAMEL_FOLDER (search_folder)); execute: /* Finally, execute the search. */ message_list_set_search (MESSAGE_LIST (message_list), query); e_mail_view_set_search_strings (mail_view, search_strings); g_slist_foreach (search_strings, (GFunc) g_free, NULL); g_slist_free (search_strings); g_free (query); g_clear_object (&folder); }
static void mail_browser_constructed (GObject *object) { EMailBrowser *browser; EMailReader *reader; EMailBackend *backend; EMailSession *session; EShellBackend *shell_backend; EShell *shell; EFocusTracker *focus_tracker; GtkAccelGroup *accel_group; GtkActionGroup *action_group; GtkAction *action; GtkUIManager *ui_manager; GtkWidget *container; GtkWidget *display; GtkWidget *widget; const gchar *domain; const gchar *id; guint merge_id; /* Chain up to parent's constructed() method. */ G_OBJECT_CLASS (e_mail_browser_parent_class)->constructed (object); browser = E_MAIL_BROWSER (object); reader = E_MAIL_READER (object); backend = e_mail_reader_get_backend (reader); session = e_mail_backend_get_session (backend); shell_backend = E_SHELL_BACKEND (backend); shell = e_shell_backend_get_shell (shell_backend); ui_manager = gtk_ui_manager_new (); browser->priv->ui_manager = ui_manager; domain = GETTEXT_PACKAGE; gtk_application_add_window ( GTK_APPLICATION (shell), GTK_WINDOW (object)); /* The message list is a widget, but it is not shown in the browser. * Unfortunately, the widget is inseparable from its model, and the * model is all we need. */ browser->priv->message_list = message_list_new (session); g_object_ref_sink (browser->priv->message_list); g_signal_connect_swapped ( browser->priv->message_list, "message-selected", G_CALLBACK (mail_browser_message_selected_cb), object); g_signal_connect_swapped ( browser->priv->message_list, "message-list-built", G_CALLBACK (mail_browser_message_list_built_cb), object); display = e_mail_display_new (e_mail_backend_get_remote_content (backend)); e_mail_display_set_mode ( E_MAIL_DISPLAY (display), browser->priv->display_mode); g_signal_connect_swapped ( display, "popup-event", G_CALLBACK (mail_browser_popup_event_cb), object); g_signal_connect_swapped ( display, "status-message", G_CALLBACK (mail_browser_status_message_cb), object); widget = e_preview_pane_new (E_WEB_VIEW (display)); browser->priv->preview_pane = g_object_ref (widget); gtk_widget_show (widget); action_group = gtk_action_group_new (ACTION_GROUP_STANDARD); gtk_action_group_set_translation_domain (action_group, domain); gtk_action_group_add_actions ( action_group, mail_browser_entries, G_N_ELEMENTS (mail_browser_entries), object); e_action_group_add_popup_actions ( action_group, mail_browser_popup_entries, G_N_ELEMENTS (mail_browser_popup_entries)); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); /* For easy access. Takes ownership of the reference. */ g_object_set_data_full ( object, ACTION_GROUP_STANDARD, action_group, (GDestroyNotify) g_object_unref); action_group = gtk_action_group_new (ACTION_GROUP_SEARCH_FOLDERS); gtk_action_group_set_translation_domain (action_group, domain); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); /* For easy access. Takes ownership of the reference. */ g_object_set_data_full ( object, ACTION_GROUP_SEARCH_FOLDERS, action_group, (GDestroyNotify) g_object_unref); e_mail_reader_init (reader, TRUE, TRUE); e_load_ui_manager_definition (ui_manager, E_MAIL_READER_UI_DEFINITION); gtk_ui_manager_add_ui_from_string (ui_manager, ui, -1, NULL); merge_id = gtk_ui_manager_new_merge_id (ui_manager); e_mail_reader_create_charset_menu (reader, ui_manager, merge_id); accel_group = gtk_ui_manager_get_accel_group (ui_manager); gtk_window_add_accel_group (GTK_WINDOW (object), accel_group); g_signal_connect_swapped ( ui_manager, "connect-proxy", G_CALLBACK (mail_browser_connect_proxy_cb), object); e_mail_reader_connect_remote_content (reader); /* Configure an EFocusTracker to manage selection actions. */ focus_tracker = e_focus_tracker_new (GTK_WINDOW (object)); action = e_mail_reader_get_action (reader, "cut-clipboard"); e_focus_tracker_set_cut_clipboard_action (focus_tracker, action); action = e_mail_reader_get_action (reader, "copy-clipboard"); e_focus_tracker_set_copy_clipboard_action (focus_tracker, action); action = e_mail_reader_get_action (reader, "paste-clipboard"); e_focus_tracker_set_paste_clipboard_action (focus_tracker, action); action = e_mail_reader_get_action (reader, "select-all"); e_focus_tracker_set_select_all_action (focus_tracker, action); browser->priv->focus_tracker = focus_tracker; /* Construct window widgets. */ widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (object), widget); gtk_widget_show (widget); container = widget; widget = gtk_statusbar_new (); gtk_box_pack_end (GTK_BOX (container), widget, FALSE, FALSE, 0); browser->priv->statusbar = g_object_ref (widget); gtk_widget_show (widget); widget = gtk_ui_manager_get_widget (ui_manager, "/main-menu"); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); browser->priv->main_menu = g_object_ref (widget); gtk_widget_show (widget); widget = gtk_ui_manager_get_widget (ui_manager, "/main-toolbar"); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); browser->priv->main_toolbar = g_object_ref (widget); gtk_widget_show (widget); gtk_style_context_add_class ( gtk_widget_get_style_context (widget), GTK_STYLE_CLASS_PRIMARY_TOOLBAR); gtk_box_pack_start ( GTK_BOX (container), browser->priv->preview_pane, TRUE, TRUE, 0); id = "org.gnome.evolution.mail.browser"; e_plugin_ui_register_manager (ui_manager, id, object); e_plugin_ui_enable_manager (ui_manager, id); e_extensible_load_extensions (E_EXTENSIBLE (object)); }
static GtkWidget * mbox_getwidget (EImport *ei, EImportTarget *target, EImportImporter *im) { EShell *shell; EShellBackend *shell_backend; EMailBackend *backend; EMailSession *session; GtkWindow *window; GtkWidget *hbox, *w; GtkLabel *label; gchar *select_uri = NULL; /* XXX Dig up the mail backend from the default EShell. * Since the EImport framework doesn't allow for user * data, I don't see how else to get to it. */ shell = e_shell_get_default (); shell_backend = e_shell_get_backend_by_name (shell, "mail"); backend = E_MAIL_BACKEND (shell_backend); session = e_mail_backend_get_session (backend); /* preselect the folder selected in a mail view */ window = e_shell_get_active_window (shell); if (E_IS_SHELL_WINDOW (window)) { EShellWindow *shell_window; const gchar *view; shell_window = E_SHELL_WINDOW (window); view = e_shell_window_get_active_view (shell_window); if (view && g_str_equal (view, "mail")) { EShellView *shell_view; EShellSidebar *shell_sidebar; EMFolderTree *folder_tree = NULL; shell_view = e_shell_window_get_shell_view ( shell_window, view); shell_sidebar = e_shell_view_get_shell_sidebar (shell_view); g_object_get ( shell_sidebar, "folder-tree", &folder_tree, NULL); select_uri = em_folder_tree_get_selected_uri (folder_tree); g_object_unref (folder_tree); } } if (!select_uri) { const gchar *uri; uri = e_mail_session_get_local_folder_uri ( session, E_MAIL_LOCAL_FOLDER_INBOX); select_uri = g_strdup (uri); } hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); w = gtk_label_new_with_mnemonic (_("_Destination folder:")); gtk_box_pack_start ((GtkBox *) hbox, w, FALSE, TRUE, 6); label = GTK_LABEL (w); w = em_folder_selection_button_new ( session, _("Select folder"), _("Select folder to import into")); gtk_label_set_mnemonic_widget (label, w); em_folder_selection_button_set_folder_uri ( EM_FOLDER_SELECTION_BUTTON (w), select_uri); folder_selected ( EM_FOLDER_SELECTION_BUTTON (w), (EImportTargetURI *) target); g_signal_connect ( w, "selected", G_CALLBACK (folder_selected), target); gtk_box_pack_start ((GtkBox *) hbox, w, FALSE, TRUE, 6); w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start ((GtkBox *) w, hbox, FALSE, FALSE, 0); gtk_widget_show_all (w); g_free (select_uri); return w; }
void vfolder_load_storage (EMailBackend *backend) { /* lock for loading storage, it is safe to call it more than once */ G_LOCK_DEFINE_STATIC (vfolder_hash); CamelService *service; const gchar *key; const gchar *data_dir; const gchar *config_dir; gchar *user, *storeuri; EFilterRule *rule; MailFolderCache *folder_cache; EMailSession *session; gchar *xmlfile; GConfClient *client; g_return_if_fail (E_IS_MAIL_BACKEND (backend)); G_LOCK (vfolder_hash); if (vfolder_hash) { /* we have already initialized */ G_UNLOCK (vfolder_hash); return; } vfolder_hash = g_hash_table_new (g_str_hash, g_str_equal); G_UNLOCK (vfolder_hash); data_dir = mail_session_get_data_dir (); config_dir = mail_session_get_config_dir (); session = e_mail_backend_get_session (backend); /* first, create the vfolder store, and set it up */ storeuri = g_strdup_printf("vfolder:%s/vfolder", data_dir); service = camel_session_add_service ( CAMEL_SESSION (session), "vfolder", storeuri, CAMEL_PROVIDER_STORE, NULL); if (service != NULL) { camel_service_set_display_name (service, _("Search Folders")); em_utils_connect_service_sync (service, NULL, NULL); } else { g_warning("Cannot open vfolder store - no vfolders available"); return; } g_return_if_fail (CAMEL_IS_STORE (service)); vfolder_store = CAMEL_STORE (service); g_signal_connect ( service, "folder-deleted", G_CALLBACK (store_folder_deleted_cb), backend); g_signal_connect ( service, "folder-renamed", G_CALLBACK (store_folder_renamed_cb), NULL); /* load our rules */ user = g_build_filename (config_dir, "vfolders.xml", NULL); context = em_vfolder_context_new (backend); xmlfile = g_build_filename (EVOLUTION_PRIVDATADIR, "vfoldertypes.xml", NULL); if (e_rule_context_load ((ERuleContext *) context, xmlfile, user) != 0) { g_warning("cannot load vfolders: %s\n", ((ERuleContext *)context)->error); } g_free (xmlfile); g_free (user); g_signal_connect ( context, "rule_added", G_CALLBACK (context_rule_added), context); g_signal_connect ( context, "rule_removed", G_CALLBACK (context_rule_removed), context); /* load store to mail component */ e_mail_store_add (backend, vfolder_store); /* and setup the rules we have */ rule = NULL; while ((rule = e_rule_context_next_rule ((ERuleContext *) context, rule, NULL))) { if (rule->name) { d(printf("rule added: %s\n", rule->name)); context_rule_added ((ERuleContext *) context, rule); } else { d(printf("invalid rule (%p) encountered: rule->name is NULL\n", rule)); } } g_free (storeuri); /* reenable the feature if required */ client = gconf_client_get_default (); key = "/apps/evolution/mail/display/enable_vfolders"; if (!gconf_client_get_bool (client, key, NULL)) gconf_client_set_bool (client, key, TRUE, NULL); g_object_unref (client); folder_cache = e_mail_session_get_folder_cache (session); g_signal_connect ( folder_cache, "folder-available", G_CALLBACK (folder_available_cb), backend); g_signal_connect ( folder_cache, "folder-unavailable", G_CALLBACK (folder_unavailable_cb), backend); g_signal_connect ( folder_cache, "folder-deleted", G_CALLBACK (folder_deleted_cb), backend); g_signal_connect ( folder_cache, "folder-renamed", G_CALLBACK (folder_renamed_cb), NULL); }