/** * e_account_list_save: * @account_list: an #EAccountList * * Saves @account_list to GConf. Signals will be emitted for changes. **/ void e_account_list_save (EAccountList *account_list) { GSList *list = NULL; EAccount *account; EIterator *iter; char *xmlbuf; for (iter = e_list_get_iterator (E_LIST (account_list)); e_iterator_is_valid (iter); e_iterator_next (iter)) { account = (EAccount *)e_iterator_get (iter); xmlbuf = e_account_to_xml (account); if (xmlbuf) list = g_slist_append (list, xmlbuf); } g_object_unref (iter); gconf_client_set_list (account_list->priv->gconf, "/apps/evolution/mail/accounts", GCONF_VALUE_STRING, list, NULL); while (list) { g_free (list->data); list = g_slist_remove (list, list->data); } gconf_client_suggest_sync (account_list->priv->gconf, NULL); }
/** * e_account_list_get_default: * @accounts: * * Get the default account. If no default is specified, or the default * has become stale, then the first account is made the default. * * Return value: The account or NULL if no accounts are defined. **/ const EAccount * e_account_list_get_default(EAccountList *accounts) { char *uid; EIterator *it; const EAccount *account = NULL; uid = gconf_client_get_string (accounts->priv->gconf, "/apps/evolution/mail/default_account", NULL); it = e_list_get_iterator ((EList *)accounts); if (uid) { for (;e_iterator_is_valid (it);e_iterator_next (it)) { account = (const EAccount *)e_iterator_get (it); if (!strcmp(uid, account->uid)) break; account = NULL; } e_iterator_reset(it); } /* no uid or uid not found, @it will be at the first account */ if (account == NULL && e_iterator_is_valid(it)) { account = (const EAccount *) e_iterator_get (it); gconf_client_set_string (accounts->priv->gconf, "/apps/evolution/mail/default_account", account->uid, NULL); } g_object_unref(it); g_free(uid); return account; }
static void load_accounts (MailComponent *component, EAccountList *accounts) { EIterator *iter; /* Load each service (don't connect!). Check its provider and * see if this belongs in the shell's folder list. If so, add * it. */ iter = e_list_get_iterator ((EList *) accounts); while (e_iterator_is_valid (iter)) { EAccountService *service; EAccount *account; const char *name; account = (EAccount *) e_iterator_get (iter); service = account->source; name = account->name; /* HACK: mbox url's are handled by the local store setup above, any that come through as account sources are really movemail sources! */ if (account->enabled && service->url != NULL && service->url[0] && strncmp(service->url, "mbox:", 5) != 0) mail_component_load_store_by_uri (component, service->url, name); e_iterator_next (iter); } g_object_unref (iter); }
/* load list of enabled accessible EEE accounts */ void eee_accounts_manager_load_access_accounts_list(EeeAccountsManager *self) { EIterator *iter; g_slist_foreach(self->priv->access_accounts, (GFunc)g_free, NULL); g_slist_free(self->priv->access_accounts); self->priv->access_accounts = NULL; for (iter = e_list_get_iterator(E_LIST(self->priv->ealist)); e_iterator_is_valid(iter); e_iterator_next(iter)) { EAccount *account = E_ACCOUNT(e_iterator_get(iter)); const char *name = e_account_get_string(account, E_ACCOUNT_ID_ADDRESS); if (!account->enabled) { continue; } if (eee_accounts_manager_account_is_disabled(self, name)) { continue; } if (g_slist_find_custom(self->priv->access_accounts, (gpointer)name, (GCompareFunc)strcmp)) { continue; } self->priv->access_accounts = g_slist_append(self->priv->access_accounts, g_strdup(name)); } }
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; }
/** * e_account_list_find: * @accounts: * @type: Type of search. * @key: Search key. * * Perform a search of the account list on a single key. * * @type must be set from one of the following search types: * E_ACCOUNT_FIND_NAME - Find an account by account name. * E_ACCOUNT_FIND_ID_NAME - Find an account by the owner's identity name. * E_ACCOUNT_FIND_ID_ADDRESS - Find an account by the owner's identity address. * * Return value: The account or NULL if it doesn't exist. **/ const EAccount * e_account_list_find(EAccountList *accounts, e_account_find_t type, const char *key) { char *val; EIterator *it; const EAccount *account = NULL; /* this could use a callback for more flexibility ... ... but this makes the common cases easier */ if (!key) return NULL; for (it = e_list_get_iterator ((EList *)accounts); e_iterator_is_valid (it); e_iterator_next (it)) { int found = 0; account = (const EAccount *)e_iterator_get (it); val = NULL; switch(type) { case E_ACCOUNT_FIND_NAME: found = strcmp(account->name, key) == 0; break; case E_ACCOUNT_FIND_UID: found = strcmp(account->uid, key) == 0; break; case E_ACCOUNT_FIND_ID_NAME: if (account->id) found = strcmp(account->id->name, key) == 0; break; case E_ACCOUNT_FIND_ID_ADDRESS: if (account->id) found = g_ascii_strcasecmp(account->id->address, key) == 0; break; case E_ACCOUNT_FIND_PARENT_UID: if (account->parent_uid) found = strcmp(account->parent_uid, key) == 0; break; } if (found) break; account = NULL; } g_object_unref(it); return account; }
static void auto_online(CamelObject *o, void *ed, void *d) { EIterator *iter; EAccountList *accounts; struct _auto_data *info; if (!GPOINTER_TO_INT(ed)) return; accounts = mail_config_get_accounts (); for (iter = e_list_get_iterator((EList *)accounts);e_iterator_is_valid(iter);e_iterator_next(iter)) { info = g_object_get_data((GObject *)e_iterator_get(iter), "mail-autoreceive"); if (info && info->timeout_id) auto_timeout(info); } }
void e_account_list_prune_proxies (EAccountList *account_list) { EAccount *account; EIterator *iter; for (iter = e_list_get_iterator (E_LIST (account_list)); e_iterator_is_valid (iter); e_iterator_next (iter)) { account = (EAccount *)e_iterator_get (iter); if (account->parent_uid) e_account_list_remove (account_list, account); } e_account_list_save (account_list); g_object_unref (iter); }
/* FIXME: Need a cleanup funciton for when object is deactivated */ void mail_autoreceive_init(void) { EAccountList *accounts; EIterator *iter; if (auto_active) return; accounts = mail_config_get_accounts (); auto_active = g_hash_table_new(g_str_hash, g_str_equal); g_signal_connect(accounts, "account-added", G_CALLBACK(auto_account_added), NULL); g_signal_connect(accounts, "account-removed", G_CALLBACK(auto_account_removed), NULL); g_signal_connect(accounts, "account-changed", G_CALLBACK(auto_account_changed), NULL); for (iter = e_list_get_iterator((EList *)accounts);e_iterator_is_valid(iter);e_iterator_next(iter)) auto_account_added(accounts, (EAccount *)e_iterator_get(iter), NULL); camel_object_hook_event(mail_component_peek_session(NULL), "online", auto_online, NULL); }
static void get_supported_fields_cb (EBookTestClosure *closure) { /* XXX: assuming an empty list is valid, we'll just print out anything * we do get */ if (closure->list) { EIterator *iter; const gchar *field; test_print ("supported fields:\n"); iter = e_list_get_iterator (closure->list); while ((field = e_iterator_get (iter))) { test_print (" %s\n", field); e_iterator_next (iter); } test_print ("----------------\n"); g_object_unref (closure->list); } g_main_loop_quit ((GMainLoop *) (closure->user_data)); }
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); }
static struct _send_data * build_dialog (EAccountList *accounts, CamelFolder *outbox, const char *destination) { GtkDialog *gd; GtkWidget *table; int row, num_sources; GList *list = NULL; struct _send_data *data; GtkWidget *send_icon; GtkWidget *recv_icon; GtkWidget *scrolled_window; GtkWidget *label; GtkWidget *status_label; GtkWidget *progress_bar; GtkWidget *cancel_button; struct _send_info *info; char *pretty_url; EAccount *account; EIterator *iter; GList *icon_list; EMEventTargetSendReceive *target; gd = (GtkDialog *)(send_recv_dialog = gtk_dialog_new_with_buttons(_("Send & Receive Mail"), NULL, GTK_DIALOG_NO_SEPARATOR, NULL)); gtk_window_set_modal ((GtkWindow *) gd, FALSE); gconf_bridge_bind_window_size ( gconf_bridge_get (), GCONF_KEY_PREFIX, GTK_WINDOW (send_recv_dialog)); gtk_widget_ensure_style ((GtkWidget *)gd); gtk_container_set_border_width ((GtkContainer *)gd->vbox, 0); gtk_container_set_border_width ((GtkContainer *)gd->action_area, 6); cancel_button = gtk_button_new_with_mnemonic (_("Cancel _All")); gtk_button_set_image ( GTK_BUTTON (cancel_button), gtk_image_new_from_stock ( GTK_STOCK_CANCEL, GTK_ICON_SIZE_BUTTON)); gtk_widget_show (cancel_button); gtk_dialog_add_action_widget (gd, cancel_button, GTK_RESPONSE_CANCEL); icon_list = e_icon_factory_get_icon_list ("mail-send-receive"); if (icon_list) { gtk_window_set_icon_list (GTK_WINDOW (gd), icon_list); g_list_foreach (icon_list, (GFunc) g_object_unref, NULL); g_list_free (icon_list); } num_sources = 0; iter = e_list_get_iterator ((EList *) accounts); while (e_iterator_is_valid (iter)) { account = (EAccount *) e_iterator_get (iter); if (account->source->url) num_sources++; e_iterator_next (iter); } g_object_unref (iter); table = gtk_table_new (num_sources, 4, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_set_border_width ( GTK_CONTAINER (scrolled_window), 6); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport ( GTK_SCROLLED_WINDOW (scrolled_window), table); gtk_box_pack_start ( GTK_BOX (gd->vbox), scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); /* must bet setup after send_recv_dialog as it may re-trigger send-recv button */ data = setup_send_data (); row = 0; iter = e_list_get_iterator ((EList *) accounts); while (e_iterator_is_valid (iter)) { EAccountService *source; account = (EAccount *) e_iterator_get (iter); source = account->source; if (!account->enabled || !source->url) { e_iterator_next (iter); continue; } /* see if we have an outstanding download active */ info = g_hash_table_lookup (data->active, source->url); if (info == NULL) { send_info_t type; type = get_receive_type (source->url); if (type == SEND_INVALID || type == SEND_SEND) { e_iterator_next (iter); continue; } info = g_malloc0 (sizeof (*info)); info->type = type; d(printf("adding source %s\n", source->url)); info->uri = g_strdup (source->url); info->keep = source->keep_on_server; info->cancel = camel_operation_new (operation_status, info); info->state = SEND_ACTIVE; info->timeout_id = g_timeout_add (STATUS_TIMEOUT, operation_status_timeout, info); g_hash_table_insert (data->active, info->uri, info); list = g_list_prepend (list, info); } else if (info->progress_bar != NULL) { /* incase we get the same source pop up again */ e_iterator_next (iter); continue; } else if (info->timeout_id == 0) info->timeout_id = g_timeout_add (STATUS_TIMEOUT, operation_status_timeout, info); recv_icon = e_icon_factory_get_image ( "mail-inbox", E_ICON_SIZE_LARGE_TOOLBAR); pretty_url = format_url (source->url, account->name); label = gtk_label_new (NULL); gtk_label_set_ellipsize ( GTK_LABEL (label), PANGO_ELLIPSIZE_END); gtk_label_set_markup (GTK_LABEL (label), pretty_url); g_free (pretty_url); progress_bar = gtk_progress_bar_new (); cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); status_label = gtk_label_new ( (info->type == SEND_UPDATE) ? _("Updating...") : _("Waiting...")); gtk_label_set_ellipsize ( GTK_LABEL (status_label), PANGO_ELLIPSIZE_END); /* g_object_set(data->label, "bold", TRUE, NULL); */ gtk_misc_set_alignment (GTK_MISC (label), 0, .5); gtk_misc_set_alignment (GTK_MISC (status_label), 0, .5); gtk_table_attach ( GTK_TABLE (table), recv_icon, 0, 1, row, row+2, 0, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), label, 1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), progress_bar, 2, 3, row, row+2, 0, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), cancel_button, 3, 4, row, row+2, 0, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), status_label, 1, 2, row+1, row+2, GTK_EXPAND | GTK_FILL, 0, 0, 0); info->progress_bar = progress_bar; info->status_label = status_label; info->cancel_button = cancel_button; info->data = data; g_signal_connect ( cancel_button, "clicked", G_CALLBACK (receive_cancel), info); e_iterator_next (iter); row = row + 2; } g_object_unref (iter); /* Hook: If some one wants to hook on to the sendreceive dialog, this is the way to go. */ target = em_event_target_new_send_receive (em_event_peek(), table, data, row, EM_EVENT_SEND_RECEIVE); e_event_emit ((EEvent *)em_event_peek (), "mail.sendreceive", (EEventTarget *) target); if (outbox && destination) { info = g_hash_table_lookup (data->active, SEND_URI_KEY); if (info == NULL) { info = g_malloc0 (sizeof (*info)); info->type = SEND_SEND; d(printf("adding dest %s\n", destination)); info->uri = g_strdup (destination); info->keep = FALSE; info->cancel = camel_operation_new (operation_status, info); info->state = SEND_ACTIVE; info->timeout_id = g_timeout_add (STATUS_TIMEOUT, operation_status_timeout, info); g_hash_table_insert (data->active, SEND_URI_KEY, info); list = g_list_prepend (list, info); } else if (info->timeout_id == 0) info->timeout_id = g_timeout_add (STATUS_TIMEOUT, operation_status_timeout, info); send_icon = e_icon_factory_get_image ( "mail-outbox", E_ICON_SIZE_LARGE_TOOLBAR); pretty_url = format_url (destination, NULL); label = gtk_label_new (NULL); gtk_label_set_ellipsize ( GTK_LABEL (label), PANGO_ELLIPSIZE_END); gtk_label_set_markup (GTK_LABEL (label), pretty_url); g_free (pretty_url); progress_bar = gtk_progress_bar_new (); cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); status_label = gtk_label_new (_("Waiting...")); gtk_label_set_ellipsize ( GTK_LABEL (status_label), PANGO_ELLIPSIZE_END); gtk_misc_set_alignment (GTK_MISC (label), 0, .5); gtk_misc_set_alignment (GTK_MISC (status_label), 0, .5); gtk_table_attach ( GTK_TABLE (table), send_icon, 0, 1, row, row+2, 0, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), label, 1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), progress_bar, 2, 3, row, row+2, 0, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), cancel_button, 3, 4, row, row+2, 0, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), status_label, 1, 2, row+1, row+2, GTK_EXPAND | GTK_FILL, 0, 0, 0); info->progress_bar = progress_bar; info->cancel_button = cancel_button; info->data = data; info->status_label = status_label; g_signal_connect ( cancel_button, "clicked", G_CALLBACK (receive_cancel), info); gtk_widget_show_all (table); } gtk_widget_show (GTK_WIDGET (gd)); g_signal_connect (gd, "response", G_CALLBACK (dialog_response), data); g_object_weak_ref ((GObject *) gd, (GWeakNotify) dialog_destroy_cb, data); data->infos = list; data->gd = gd; return data; }
static void gconf_accounts_changed (GConfClient *client, guint cnxn_id, GConfEntry *entry, gpointer user_data) { EAccountList *account_list = user_data; GSList *list, *l, *new_accounts = NULL; EAccount *account; EList *old_accounts; EIterator *iter; char *uid; old_accounts = e_list_duplicate (E_LIST (account_list)); list = gconf_client_get_list (client, "/apps/evolution/mail/accounts", GCONF_VALUE_STRING, NULL); for (l = list; l; l = l->next) { uid = e_account_uid_from_xml (l->data); if (!uid) continue; /* See if this is an existing account */ for (iter = e_list_get_iterator (old_accounts); e_iterator_is_valid (iter); e_iterator_next (iter)) { account = (EAccount *)e_iterator_get (iter); if (!strcmp (account->uid, uid)) { /* The account still exists, so remove * it from "old_accounts" and update it. */ e_iterator_delete (iter); if (e_account_set_from_xml (account, l->data)) g_signal_emit (account_list, signals[ACCOUNT_CHANGED], 0, account); goto next; } } /* Must be a new account */ account = e_account_new_from_xml (l->data); e_list_append (E_LIST (account_list), account); new_accounts = g_slist_prepend (new_accounts, account); next: g_free (uid); g_object_unref (iter); } if (list) { g_slist_foreach (list, (GFunc) g_free, NULL); g_slist_free (list); } /* Now emit signals for each added account. (We do this after * adding all of them because otherwise if the signal handler * calls e_account_list_get_default_account() it will end up * causing the first account in the list to become the * default.) */ for (l = new_accounts; l; l = l->next) { account = l->data; g_signal_emit (account_list, signals[ACCOUNT_ADDED], 0, account); g_object_unref (account); } g_slist_free (new_accounts); /* Anything left in old_accounts must have been deleted */ for (iter = e_list_get_iterator (old_accounts); e_iterator_is_valid (iter); e_iterator_next (iter)) { account = (EAccount *)e_iterator_get (iter); e_list_remove (E_LIST (account_list), account); g_signal_emit (account_list, signals[ACCOUNT_REMOVED], 0, account); } g_object_unref (iter); g_object_unref (old_accounts); }