#include "modest-tny-platform-factory.h"
#include <tny-gtk-lockable.h>
#include <camel/camel.h>
+#include <modest-platform.h>
#ifdef MODEST_PLATFORM_MAEMO
#include <tny-maemo-conic-device.h>
-#ifdef MODEST_HAVE_HILDON0_WIDGETS
-#include <hildon-widgets/hildon-note.h>
-#include <hildon-widgets/hildon-banner.h>
-#else
-#include <hildon/hildon-note.h>
-#include <hildon/hildon-banner.h>
-#endif
#endif
#include <libgnomevfs/gnome-vfs-volume-monitor.h>
/* 'private'/'protected' functions */
static void modest_tny_account_store_class_init (ModestTnyAccountStoreClass *klass);
-
static void modest_tny_account_store_finalize (GObject *obj);
-
static void modest_tny_account_store_instance_init (ModestTnyAccountStore *obj);
-
static void modest_tny_account_store_init (gpointer g, gpointer iface_data);
-
static void modest_tny_account_store_base_init (gpointer g_class);
static void on_account_inserted (ModestAccountMgr *acc_mgr,
static void modest_tny_account_store_forget_password_in_memory (ModestTnyAccountStore *self,
const gchar *server_account_name);
-static void add_connection_specific_transport_accounts (ModestTnyAccountStore *self,
- const gchar *account_name);
+static void add_connection_specific_transport_accounts (ModestTnyAccountStore *self);
/* list my signals */
enum {
TnyList *store_accounts;
TnyList *transport_accounts;
TnyList *store_accounts_outboxes;
+
+ /* Matches transport accounts and outbox folder */
+ GHashTable *outbox_of_transport;
};
#define MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
priv->session = NULL;
priv->device = NULL;
+ priv->outbox_of_transport =
+ g_hash_table_new_full (g_direct_hash,
+ g_direct_equal,
+ NULL,
+ NULL);
+
/* An in-memory store of passwords,
* for passwords that are not remembered in the configuration,
* so they need to be asked for from the user once in each session:
* so we can avoid showing the account settings twice for the same modest account: */
priv->account_settings_dialog_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, NULL);
-
+
/* Respond to volume mounts and unmounts, such
* as the insertion/removal of the memory card: */
+ /* This is a singleton, so it does not need to be unrefed. */
monitor = gnome_vfs_get_volume_monitor();
priv->volume_mounted_handler = g_signal_connect (G_OBJECT(monitor),
/********************************************************************/
/* Control the state of the MMC local account */
/********************************************************************/
+
+/** Only call this if the memory card is really mounted.
+ */
+static void
+add_mmc_account(ModestTnyAccountStore *self, gboolean emit_insert_signal)
+{
+ ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+ g_return_if_fail (priv->session);
+
+ TnyAccount *mmc_account = modest_tny_account_new_for_local_folders (priv->account_mgr,
+ priv->session,
+ MODEST_MCC1_VOLUMEPATH);
+
+ /* Add to the list of store accounts */
+ tny_list_append (priv->store_accounts, G_OBJECT (mmc_account));
+
+ if (emit_insert_signal) {
+ g_signal_emit (G_OBJECT (self),
+ signals [ACCOUNT_INSERTED_SIGNAL],
+ 0, mmc_account);
+ }
+
+ /* Free */
+ g_object_unref (mmc_account);
+}
+
static void
on_vfs_volume_mounted(GnomeVFSVolumeMonitor *volume_monitor,
GnomeVFSVolume *volume,
uri = gnome_vfs_volume_get_activation_uri (volume);
if (uri && (!strcmp (uri, MODEST_MCC1_VOLUMEPATH_URI))) {
- TnyAccount *mmc_account;
-
- mmc_account = modest_tny_account_new_for_local_folders (priv->account_mgr,
- priv->session,
- MODEST_MCC1_VOLUMEPATH);
-
- /* Add to the list of store accounts */
- tny_list_append (priv->store_accounts, G_OBJECT (mmc_account));
-
- g_signal_emit (G_OBJECT (self),
- signals [ACCOUNT_INSERTED_SIGNAL],
- 0, mmc_account);
- /* Free */
- g_object_unref (mmc_account);
+ add_mmc_account (self, TRUE /* emit the insert signal. */);
}
+
g_free (uri);
}
g_hash_table_remove (priv->account_settings_dialog_hash, modest_account_name);
}
-static gboolean
-on_idle_wrong_password_warning_only (gpointer user_data)
+static void
+show_password_warning_only ()
{
- gdk_threads_enter();
-
ModestWindow *main_window =
modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ());
/* Show an explanatory temporary banner: */
hildon_banner_show_information (
GTK_WIDGET(main_window), NULL, _("mcen_ib_username_pw_incorrect"));
-
- gdk_threads_leave();
-
- return FALSE; /* Don't show again. */
}
-static gboolean
-on_idle_wrong_password (gpointer user_data)
+static void
+show_wrong_password_dialog (TnyAccount *account)
{
- TnyAccount *account = (TnyAccount*)user_data;
/* This is easier than using a struct for the user_data: */
ModestTnyAccountStore *self = modest_runtime_get_account_store();
ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
if (!modest_account_name) {
g_warning ("%s: modest_tny_account_get_parent_modest_account_name_for_server_account() failed.\n",
__FUNCTION__);
-
- g_object_unref (account);
- return FALSE;
}
-
/* Check whether this window is already open,
* for instance because of a previous get_password() call:
*/
ModestWindow *main_window =
modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ());
- gdk_threads_enter ();
gboolean created_dialog = FALSE;
if (!found || !dialog) {
dialog = modest_account_settings_dialog_new ();
* though it is probably open already: */
gtk_window_present (GTK_WINDOW (dialog));
}
-
- g_object_unref (account);
- gdk_threads_leave ();
-
- return FALSE; /* Dont' call this again. */
}
-typedef struct
-{
- GMainLoop *loop;
- ModestTnyAccountStore* account_store;
- const gchar* server_account_id;
- gchar **username;
- gchar **password;
- gboolean *cancel;
- gboolean *remember;
-} IdlePasswordRequest;
-
-static gboolean
-on_idle_request_password (gpointer user_data)
-{
- gdk_threads_enter();
-
- IdlePasswordRequest* info = (IdlePasswordRequest*)user_data;
- g_signal_emit (G_OBJECT(info->account_store), signals[PASSWORD_REQUESTED_SIGNAL], 0,
- info->server_account_id, /* server_account_name */
- info->username, info->password, info->cancel, info->remember);
-
- if (info->loop)
- g_main_loop_quit (info->loop);
-
- gdk_threads_leave();
-
- return FALSE; /* Don't call again. */
-}
+
static void
-request_password_in_main_loop_and_wait (ModestTnyAccountStore *account_store,
+request_password_and_wait (ModestTnyAccountStore *account_store,
const gchar* server_account_id,
gchar **username,
gchar **password,
gboolean *cancel,
gboolean *remember)
{
- IdlePasswordRequest *data = g_slice_new0 (IdlePasswordRequest);
- data->account_store = account_store;
- data->server_account_id = server_account_id;
- data->username = username;
- data->password = password;
- data->cancel = cancel;
- data->remember = remember;
-
- data->loop = g_main_loop_new (NULL, FALSE /* not running */);
-
- /* Cause the function to be run in an idle-handler, which is always
- * in the main thread:
- */
- g_idle_add (&on_idle_request_password, data);
-
- /* This main loop will run until the idle handler has stopped it: */
- printf ("DEBUG: %s: before g_main_loop_run()\n", __FUNCTION__);
- GDK_THREADS_LEAVE();
- g_main_loop_run (data->loop);
- GDK_THREADS_ENTER();
- printf ("DEBUG: %s: after g_main_loop_run()\n", __FUNCTION__);
- printf ("DEBUG: %s: Finished\n", __FUNCTION__);
- g_main_loop_unref (data->loop);
-
- g_slice_free (IdlePasswordRequest, data);
+ g_signal_emit (G_OBJECT(account_store), signals[PASSWORD_REQUESTED_SIGNAL], 0,
+ server_account_id, /* server_account_name */
+ username, password, cancel, remember);
}
/* This callback will be called by Tinymail when it needs the password
modest_server_account_get_has_password (priv->account_mgr, server_account_name);
printf ("DEBUG: modest: %s: settings_have_password=%d\n", __FUNCTION__, settings_have_password);
if (settings_have_password) {
-
-
/* The password must be wrong, so show the account settings dialog so it can be corrected: */
- /* We show it in the main loop, because this function might not be in the main loop. */
- g_object_ref (account); /* unrefed in the idle handler. */
- g_idle_add (on_idle_wrong_password, account);
+ show_wrong_password_dialog (account);
if (cancel)
*cancel = TRUE;
if (already_asked) {
/* Show an info banner, before we show the protected password dialog: */
- g_idle_add (on_idle_wrong_password_warning_only, NULL);
+ show_password_warning_only();
}
- request_password_in_main_loop_and_wait (self, account_id,
+ request_password_and_wait (self, account_id,
&username, &pwd, cancel, &remember);
if (!*cancel) {
priv->password_hash = NULL;
}
+ if (priv->account_settings_dialog_hash) {
+ g_hash_table_destroy (priv->account_settings_dialog_hash);
+ priv->account_settings_dialog_hash = NULL;
+ }
+
+ if (priv->outbox_of_transport) {
+ g_hash_table_destroy (priv->outbox_of_transport);
+ priv->outbox_of_transport = NULL;
+ }
+
+
/* Disconnect VFS signals */
volume_monitor = gnome_vfs_get_volume_monitor ();
if (g_signal_handler_is_connected (volume_monitor,
G_OBJECT_CLASS(parent_class)->finalize (obj);
}
+gboolean
+volume_path_is_mounted (const gchar* path)
+{
+ g_return_val_if_fail (path, FALSE);
+
+ gboolean result = FALSE;
+ gchar * path_as_uri = g_filename_to_uri (path, NULL, NULL);
+ g_return_val_if_fail (path_as_uri, FALSE);
+
+ /* Get the monitor singleton: */
+ GnomeVFSVolumeMonitor *monitor = gnome_vfs_get_volume_monitor();
+
+ /* This seems like a simpler way to do this, but it returns a
+ * GnomeVFSVolume even if the drive is not mounted: */
+ /*
+ GnomeVFSVolume *volume = gnome_vfs_volume_monitor_get_volume_for_path (monitor,
+ MODEST_MCC1_VOLUMEPATH);
+ if (volume) {
+ gnome_vfs_volume_unref(volume);
+ }
+ */
+
+ /* Get the mounted volumes from the monitor: */
+ GList *list = gnome_vfs_volume_monitor_get_mounted_volumes (monitor);
+ GList *iter = list;
+ for (iter = list; iter; iter = g_list_next (iter)) {
+ GnomeVFSVolume *volume = (GnomeVFSVolume*)iter->data;
+ if (volume) {
+ /*
+ char *display_name =
+ gnome_vfs_volume_get_display_name (volume);
+ printf ("volume display name=%s\n", display_name);
+ g_free (display_name);
+ */
+
+ char *uri =
+ gnome_vfs_volume_get_activation_uri (volume);
+ /* printf (" uri=%s\n", uri); */
+ if (uri && (strcmp (uri, path_as_uri) == 0))
+ result = TRUE;
+
+ g_free (uri);
+
+ gnome_vfs_volume_unref (volume);
+ }
+ }
+
+ g_list_free (list);
+
+ g_free (path_as_uri);
+
+ return result;
+}
ModestTnyAccountStore*
modest_tny_account_store_new (ModestAccountMgr *account_mgr,
tny_list_append (priv->store_accounts, G_OBJECT(local_account));
g_object_unref (local_account);
- /* Add the other remote accounts. Do this before adding the
+ /* Add the other remote accounts. Do this after adding the
local account, because we need to add our outboxes to the
global OUTBOX hosted in the local account */
add_existing_accounts (MODEST_TNY_ACCOUNT_STORE (obj));
-
+
+
+ /* Create the memory card account if the card is mounted: */
+
+ /* This is a singleton, so it does not need to be unrefed. */
+ if (volume_path_is_mounted (MODEST_MCC1_VOLUMEPATH)) {
+ /* It is mounted: */
+ add_mmc_account (MODEST_TNY_ACCOUNT_STORE (obj), FALSE /* don't emit the insert signal. */);
+ }
+
return MODEST_TNY_ACCOUNT_STORE(obj);
}
static gboolean
-modest_tny_account_store_alert (TnyAccountStore *self, TnyAccount *account, TnyAlertType type,
- gboolean question, const GError *error)
+modest_tny_account_store_alert (TnyAccountStore *self,
+ TnyAccount *account,
+ TnyAlertType type,
+ gboolean question,
+ const GError *error)
{
- g_return_val_if_fail (error, FALSE);
+ ModestTransportStoreProtocol proto =
+ MODEST_PROTOCOL_TRANSPORT_STORE_UNKNOWN;
+ const gchar* server_name = NULL;
+ gchar *prompt = NULL;
+ gboolean retval;
- if ((error->domain != TNY_ACCOUNT_ERROR)
- && (error->domain != TNY_ACCOUNT_STORE_ERROR)) {
- g_warning("modest: %s: Unexpected error domain: != TNY_ACCOUNT_ERROR: %d, message=%s",
- __FUNCTION__, error->domain, error->message);
-
- return FALSE;
- }
+ g_return_val_if_fail (account, FALSE);
+ g_return_val_if_fail (error, FALSE);
- printf("DEBUG: %s: GError code: %d, message=%s\n",
- __FUNCTION__, error->code, error->message);
+ if ((error->domain != TNY_ACCOUNT_ERROR) && (error->domain != TNY_ACCOUNT_STORE_ERROR))
+ return FALSE;
/* Get the server name: */
- const gchar* server_name = NULL;
- if (account && TNY_IS_ACCOUNT (account)) {
- server_name = tny_account_get_hostname (account);
- printf ("modest: %s: account name = %s, server_name=%s\n", __FUNCTION__,
- tny_account_get_id (account), server_name);
- }
-
- if (!server_name)
- server_name = _("Unknown Server");
-
- ModestTransportStoreProtocol proto = MODEST_PROTOCOL_STORE_POP; /* Arbitrary default. */
+ server_name = tny_account_get_hostname (account);
+
if (account) {
const gchar *proto_name = tny_account_get_proto (account);
if (proto_name)
proto = modest_protocol_info_get_transport_store_protocol (proto_name);
else {
g_warning("modest: %s: account with id=%s has no proto.\n", __FUNCTION__,
- tny_account_get_id (account));
+ tny_account_get_id (account));
+ return FALSE;
}
}
-
- /* const gchar *prompt = NULL; */
- gchar *prompt = NULL;
+
switch (error->code) {
- case TNY_ACCOUNT_STORE_ERROR_CANCEL_ALERT:
- case TNY_ACCOUNT_ERROR_TRY_CONNECT_USER_CANCEL:
- /* Don't show waste the user's time by showing him a dialog telling
- * him that he has just cancelled something: */
- g_debug ("%s: Handling GError domain=%d, code=%d (cancelled) without showing a dialog, message=%s",
- __FUNCTION__, error->domain, error->code, error->message);
- prompt = NULL;
+ case TNY_ACCOUNT_STORE_ERROR_CANCEL_ALERT:
+ case TNY_ACCOUNT_ERROR_TRY_CONNECT_USER_CANCEL:
+ /* Don't show waste the user's time by showing him a dialog telling
+ * him that he has just cancelled something: */
+ return TRUE;
+
+ case TNY_ACCOUNT_ERROR_TRY_CONNECT_HOST_LOOKUP_FAILED:
+ case TNY_ACCOUNT_ERROR_TRY_CONNECT_SERVICE_UNAVAILABLE:
+ /* TODO: Show the appropriate message, depending on whether it's POP or IMAP: */
+ switch (proto) {
+ case MODEST_PROTOCOL_STORE_POP:
+ prompt = g_strdup_printf (_("emev_ni_ui_pop3_msg_connect_error"),
+ server_name);
break;
-
- case TNY_ACCOUNT_ERROR_TRY_CONNECT_HOST_LOOKUP_FAILED:
- /* TODO: Show the appropriate message, depending on whether it's POP or IMAP: */
- g_debug ("%s: Handling GError domain=%d, code=%d (lookup failed), message=%s",
- __FUNCTION__, error->domain, error->code, error->message);
-
- switch (proto) {
- case MODEST_PROTOCOL_STORE_POP:
- prompt = g_strdup_printf (_("emev_ni_ui_pop3_msg_connect_error"), server_name);
- break;
- case MODEST_PROTOCOL_STORE_IMAP:
- prompt = g_strdup_printf (_("emev_ni_ui_imap_connect_server_error"), server_name);
- break;
- case MODEST_PROTOCOL_TRANSPORT_SMTP:
- default: /* Arbitrary default. */
- prompt = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"), server_name);
- break;
- }
-
- /*
- prompt = g_strdup_printf(
- _("Incorrect Account Settings:\n Host lookup failed.%s"),
- error->message);
- */
+ case MODEST_PROTOCOL_STORE_IMAP:
+ prompt = g_strdup_printf (_("emev_ni_ui_imap_connect_server_error"),
+ server_name);
break;
-
- case TNY_ACCOUNT_ERROR_TRY_CONNECT_AUTHENTICATION_NOT_SUPPORTED:
- g_debug ("%s: Handling GError domain=%d, code=%d (authentication not supported), message=%s",
- __FUNCTION__, error->domain, error->code, error->message);
- /* TODO: This needs a logical ID for the string: */
- prompt = g_strdup_printf(
- _("Incorrect Account Settings:\nThe secure authentication method is not supported.\n%s"),
- error->message);
+ case MODEST_PROTOCOL_TRANSPORT_SMTP:
+ prompt = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"),
+ server_name);
break;
+ default:
+ g_return_val_if_reached (FALSE);
+ }
+ break;
+
+ case TNY_ACCOUNT_ERROR_TRY_CONNECT_AUTHENTICATION_NOT_SUPPORTED:
+ /* This is "Secure connection failed", even though the logical
+ * ID has _certificate_ in the name: */
+ prompt = g_strdup (_("mail_ni_ssl_certificate_error"));
+ break;
- case TNY_ACCOUNT_ERROR_TRY_CONNECT_CERTIFICATE:
- g_debug ("%s: Handling GError domain=%d, code=%d (certificatae), message=%s",
- __FUNCTION__, error->domain, error->code, error->message);
- prompt = g_strdup_printf(
- _("Certificate Problem:\n%s"),
- error->message);
- break;
+ case TNY_ACCOUNT_ERROR_TRY_CONNECT_CERTIFICATE:
+ /* We'll show the proper dialog later */
+ break;
- case TNY_ACCOUNT_ERROR_TRY_CONNECT:
+ case TNY_ACCOUNT_ERROR_TRY_CONNECT:
/* The tinymail camel implementation just sends us this for almost
* everything, so we have to guess at the cause.
* It could be a wrong password, or inability to resolve a hostname,
* specific dialog messages from Chapter 12 of the UI spec.
*/
case TNY_ACCOUNT_STORE_ERROR_UNKNOWN_ALERT:
- /* This debug output is useful. Please keep it uncommented until
- * we have fixed the problems in this function: */
- g_debug ("%s: Handling GError domain=%d, code=%d, message=%s",
- __FUNCTION__, error->domain, error->code, error->message);
/* TODO: Remove the internal error message for the real release.
* This is just so the testers can give us more information: */
+ /* However, I haven't seen this for a few weeks, so maybe the users
+ * will never see it. murrayc. */
/* prompt = _("Modest account not yet fully configured."); */
prompt = g_strdup_printf(
"%s\n (Internal error message, often very misleading):\n%s",
_("Incorrect Account Settings"),
error->message);
-
+
/* Note: If the password was wrong then get_password() would be called again,
* instead of this vfunc being called. */
-
break;
-
- default:
- g_warning ("%s: Unhandled GError code: %d, message=%s",
- __FUNCTION__, error->code, error->message);
- prompt = NULL;
- break;
+
+ default:
+ g_return_val_if_reached (FALSE);
}
- if (!prompt)
- return FALSE;
- ModestWindow *main_window =
- modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ());
- gboolean retval = TRUE;
- if (question) {
- /* The Tinymail documentation says that we should show Yes and No buttons,
- * when it is a question.
- * Obviously, we need tinymail to use more specific error codes instead,
- * so we know what buttons to show. */
-
- /* TODO: Do this in the main context: */
- GtkWidget *dialog = GTK_WIDGET (hildon_note_new_confirmation (GTK_WINDOW (main_window),
- prompt));
- const int response = gtk_dialog_run (GTK_DIALOG (dialog));
- if (question) {
- retval = (response == GTK_RESPONSE_YES) ||
- (response == GTK_RESPONSE_OK);
- }
-
- gtk_widget_destroy (dialog);
+ if (error->code == TNY_ACCOUNT_ERROR_TRY_CONNECT_CERTIFICATE)
+ retval = modest_platform_run_certificate_conformation_dialog (server_name,
+ error->message);
+ else
+ retval = modest_platform_run_alert_dialog (prompt, question);
- } else {
- /* Just show the error text and use the default response: */
- modest_maemo_show_information_note_in_main_context_and_forget (GTK_WINDOW (main_window),
- prompt);
- }
+ if (prompt)
+ g_free (prompt);
- /* TODO: Don't free this when we no longer strdup the message for testers. */
- g_free (prompt);
-
-
- /* printf("DEBUG: %s: returning %d\n", __FUNCTION__, retval); */
return retval;
}
static TnyAccount*
get_smtp_specific_transport_account_for_open_connection (ModestTnyAccountStore *self,
- const gchar *account_name)
+ const gchar *account_name)
{
/* Get the current connection: */
TnyDevice *device = modest_runtime_get_device ();
return NULL;
g_return_val_if_fail (self, NULL);
- g_return_val_if_fail (account_name, NULL);
#ifdef MODEST_PLATFORM_MAEMO
/* Get the connection-specific transport acccount, if any: */
ModestAccountMgr *account_manager = modest_runtime_get_account_mgr ();
+
+ /* Check if this account has connection-specific SMTP enabled */
+ if (!modest_account_mgr_get_use_connection_specific_smtp (account_manager, account_name)) {
+ return NULL;
+ }
+
gchar* server_account_name = modest_account_mgr_get_connection_specific_smtp (account_manager,
- account_name, connection_name);
+ connection_name);
/* printf ("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
if (!server_account_name) {
return NULL;
/* Get the connection-specific transport acccount, if any: */
+ /* Note: This gives us a reference: */
TnyAccount *account =
get_smtp_specific_transport_account_for_open_connection (self, account_name);
/* The special local folders don't have transport accounts. */
if (strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) == 0)
account = NULL;
- else
+ else {
+ /* Note: This gives us a reference: */
account = modest_tny_account_store_get_server_account (self, account_name,
TNY_ACCOUNT_TYPE_TRANSPORT);
+ }
}
-
+
+ /* returns a reference. */
return account;
}
/* Add account to the list */
tny_list_append (priv->transport_accounts, G_OBJECT (transport_account));
+ g_assert (TNY_IS_ACCOUNT (transport_account));
/* Add connection-specific transport accounts */
- add_connection_specific_transport_accounts (self, account);
+ add_connection_specific_transport_accounts (self);
/* Create per account local outbox */
account_outbox =
folders = tny_simple_list_new ();
tny_folder_store_get_folders (TNY_FOLDER_STORE (account_outbox),
folders, NULL, NULL);
- g_assert (tny_list_get_length (folders) == 1);
+ if (tny_list_get_length (folders) != 1)
+ g_warning ("%s: there should be only one outbox folder, but found %d!",
+ __FUNCTION__, tny_list_get_length (folders));
iter_folders = tny_list_create_iterator (folders);
per_account_outbox = TNY_FOLDER (tny_iterator_get_current (iter_folders));
g_object_unref (iter_folders);
+ g_object_unref (folders);
g_object_unref (account_outbox);
/* Add the outbox of the new per-account-local-outbox
local_account = modest_tny_account_store_get_local_folders_account (MODEST_TNY_ACCOUNT_STORE (self));
modest_tny_local_folders_account_add_folder_to_outbox (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (local_account),
per_account_outbox);
+ /* Add the pair to the hash table */
+ g_hash_table_insert (priv->outbox_of_transport,
+ transport_account,
+ per_account_outbox);
+
+ /* Notify that the local folders account chaned */
+ if (notify)
+ g_signal_emit (G_OBJECT (self), signals [ACCOUNT_CHANGED_SIGNAL], 0, local_account);
+
g_object_unref (local_account);
g_object_unref (per_account_outbox);
/* If there was any problem creating the account, for example,
with the configuration system this could not exist */
if (transport_account) {
+ TnyAccount *local_account = NULL;
+ TnyFolder *outbox = NULL;
+ ModestTnyAccountStorePrivate *priv = NULL;
+
+ /* Remove the OUTBOX of the account from the global outbox */
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+ outbox = g_hash_table_lookup (priv->outbox_of_transport, transport_account);
+
+ if (TNY_IS_FOLDER (outbox)) {
+ local_account = modest_tny_account_store_get_local_folders_account (self);
+ modest_tny_local_folders_account_remove_folder_from_outbox (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (local_account),
+ outbox);
+ g_hash_table_remove (priv->outbox_of_transport, transport_account);
+
+ /* Notify the change in the local account */
+ g_signal_emit (G_OBJECT (self), signals [ACCOUNT_CHANGED_SIGNAL], 0, local_account);
+ g_object_unref (local_account);
+ } else {
+ g_warning ("Removing a transport account that has no outbox");
+ }
+
/* Notify the observers */
g_signal_emit (G_OBJECT (self), signals [ACCOUNT_REMOVED_SIGNAL], 0, transport_account);
g_object_unref (transport_account);
}
static void
-add_connection_specific_transport_accounts (ModestTnyAccountStore *self,
- const gchar *account_name)
+add_connection_specific_transport_accounts (ModestTnyAccountStore *self)
{
ModestTnyAccountStorePrivate *priv = NULL;
GSList *list_specifics = NULL, *iter = NULL;
priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
- list_specifics = modest_account_mgr_get_list (priv->account_mgr,
- account_name,
- MODEST_ACCOUNT_CONNECTION_SPECIFIC_SMTP_LIST,
- MODEST_CONF_VALUE_STRING, FALSE);
+ ModestConf *conf = modest_runtime_get_conf ();
+
+ GError *err = NULL;
+ list_specifics = modest_conf_get_list (conf,
+ MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST,
+ MODEST_CONF_VALUE_STRING, &err);
+ if (err) {
+ g_printerr ("modest: %s: error getting list: %s\n.", __FUNCTION__, err->message);
+ g_error_free (err);
+ err = NULL;
+ }
/* Look at each connection-specific transport account for the
* modest account: */
priv->session,
transport_account_name);
if (tny_account) {
- modest_tny_account_set_parent_modest_account_name_for_server_account (tny_account,
- account_name);
g_object_set_data (G_OBJECT(tny_account),
"account_store",
(gpointer)self);
tny_list_append (priv->transport_accounts, G_OBJECT (tny_account));
+ g_object_unref (tny_account);
} else
g_printerr ("modest: failed to create smtp-specific account for %s\n",
transport_account_name);