X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmodest-account-mgr.c;h=56e29ab752a99febae815ef7ade09f1dd93ce57d;hp=85b4a8b5382ea45159f7e6c8f8bc852dc91c8438;hb=40a8f5cbe03bd040fe3403dbfa6806df4fb6bc8a;hpb=b54ca9c03e98c7cf3baa11d452cee75f6bb79d9c

diff --git a/src/modest-account-mgr.c b/src/modest-account-mgr.c
index 85b4a8b..56e29ab 100644
--- a/src/modest-account-mgr.c
+++ b/src/modest-account-mgr.c
@@ -37,73 +37,188 @@
 static void modest_account_mgr_class_init (ModestAccountMgrClass * klass);
 static void modest_account_mgr_init       (ModestAccountMgr * obj);
 static void modest_account_mgr_finalize   (GObject * obj);
+static void modest_account_mgr_base_init  (gpointer g_class);
 
 /* list my signals */
 enum {
+	ACCOUNT_INSERTED_SIGNAL,
 	ACCOUNT_CHANGED_SIGNAL,
 	ACCOUNT_REMOVED_SIGNAL,
+	ACCOUNT_BUSY_SIGNAL,
 	LAST_SIGNAL
 };
 
-
 /* globals */
 static GObjectClass *parent_class = NULL;
 static guint signals[LAST_SIGNAL] = {0};
 
+/* is the account already in the queue? */
+static gboolean
+in_change_queue (GSList *change_queue, const gchar *account)
+{
+	GSList *cursor = change_queue;
+	while (cursor) {
+		const gchar *acc = cursor->data;
+		if (acc && strcmp (acc, account) == 0)
+			return TRUE;
+		cursor = g_slist_next (cursor);
+	}
+	return FALSE;
+}
+
+static GSList*
+add_to_change_queue (GSList *change_queue, const gchar *account_name)
+{
+	g_return_val_if_fail (account_name, change_queue);	
+	return g_slist_prepend (change_queue, g_strdup (account_name));
+}
+
+
+/* we don't need to track specific accounts, as in our UI case
+ * it's impossible to change two accounts within .5 seconds.
+ * still, we might want to allow that later, and then this func
+ * will come in handy */
+#if 0
+static GSList*
+remove_from_queue (GSList *change_queue, const gchar *account)
+{
+	GSList *cursor = change_queue;
+	while (cursor) {
+		const gchar *acc = cursor->data;
+		if (acc && strcmp (acc, account) == 0) {
+			g_free (acc);
+			return g_slist_delete_link (change_queue, cursor);
+		}
+		cursor = g_slist_next (cursor);
+	}
+	return change_queue;
+}
+#endif
+
+static gboolean
+on_timeout_notify_changes (gpointer data)
+{
+	ModestAccountMgr *self = MODEST_ACCOUNT_MGR (data);
+	ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+		
+	GSList *cursor = priv->change_queue;
+	while (cursor) {
+		const gchar *account = cursor->data;
+		if (account)
+			g_signal_emit (G_OBJECT(self), signals[ACCOUNT_CHANGED_SIGNAL], 0, 
+				       account);
+		cursor = g_slist_next (cursor);
+	}
+	
+	/* free our queue */
+	g_slist_foreach (priv->change_queue, (GFunc)g_free, NULL);
+	g_slist_free (priv->change_queue);
+	priv->change_queue = NULL;
+	priv->timeout = 0; /* hmmm */
+	
+	return FALSE; /* don't call me again */
+}
+
+
+/* little hack to retrieve the account name from a server account name,
+ * by relying on the convention for that. Note: this changes the
+ * string in-place
+ *
+ * server accounts look like fooID_transport or fooID_store
+ * FIXME: make the suffixes more explicit in the account setup
+ */
 static void
-on_key_change (ModestConf *conf, const gchar *key, ModestConfEvent event, gpointer user_data)
+get_account_name_from_server_account (gchar *server_account_name)
 {
-	ModestAccountMgr *self;
-	ModestAccountMgrPrivate *priv;
+	static const gchar *t = "ID_transport";
+	static const gchar *s = "ID_store";
+	const guint len_t = strlen (t);
+	const guint len_s = strlen (s);
+	
+	guint len_a = strlen (server_account_name);
+		
+	if (g_str_has_suffix (server_account_name, t)) 
+		server_account_name [len_a - len_t] = '\0';
+	else if (g_str_has_suffix (server_account_name, s)) 
+		server_account_name [len_a - len_s] = '\0';
+}
 
-	gchar *account;
-	gboolean is_account_key, is_server_account;
-	gboolean enabled;
 
-	self = MODEST_ACCOUNT_MGR (user_data);
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+
+static void
+on_key_change (ModestConf *conf, const gchar *key, ModestConfEvent event,
+	       ModestConfNotificationId id, gpointer user_data)
+{
+	ModestAccountMgr *self = MODEST_ACCOUNT_MGR (user_data);
+	ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+
+	gboolean is_account_key;
+	gboolean is_server_account;
+	gchar* account_name = NULL;
 
 	/* there is only one not-really-account key which will still emit
 	 * a signal: a change in MODEST_CONF_DEFAULT_ACCOUNT */
 	if (key && strcmp (key, MODEST_CONF_DEFAULT_ACCOUNT) == 0) {
-		gchar *default_account =
-			modest_account_mgr_get_default_account (self);
-		g_signal_emit (G_OBJECT(self), signals[ACCOUNT_CHANGED_SIGNAL], 0,
-			       default_account, key, FALSE);
-		g_free (default_account);
-		return;
+		/* Get the default account instead. */
+		gchar *default_account =  modest_account_mgr_get_default_account (self);
+		if (!default_account) {
+			g_warning ("BUG: cannot find default account");
+			return;
+		} else {
+			g_signal_emit (G_OBJECT(self), signals[ACCOUNT_CHANGED_SIGNAL], 0, 
+				       default_account);
+			g_free(default_account);
+			return;
+		}	
 	}
 	
-	account = _modest_account_mgr_account_from_key (key, &is_account_key, &is_server_account);
-	
+	is_account_key = FALSE;
+	is_server_account = FALSE;
+	account_name = _modest_account_mgr_account_from_key (key, &is_account_key,
+							     &is_server_account);
+
 	/* if this is not an account-related key change, ignore */
-	if (!account)
+	if (!account_name)
 		return;
 
-	/* account was removed -- emit this, even if the account was disabled */
-	if (is_account_key && event == MODEST_CONF_EVENT_KEY_UNSET) {
-		g_signal_emit (G_OBJECT(self), signals[ACCOUNT_REMOVED_SIGNAL], 0,
-			       account, is_server_account);
-		g_free (account);
+	/* ignore server account changes */
+	if (is_server_account)
+		/* change in place: retrieve the parent account name */
+		get_account_name_from_server_account (account_name);
+
+	/* account was removed. Do not emit an account removed signal
+	   because it was already being done in the remove_account
+	   method. Do not notify also the removal of the server
+	   account keys for the same reason */
+	if ((is_account_key || is_server_account) &&
+	    event == MODEST_CONF_EVENT_KEY_UNSET) {
+		g_free (account_name);
 		return;
 	}
 
 	/* is this account enabled? */
+	gboolean enabled = FALSE;
 	if (is_server_account)
 		enabled = TRUE;
-	else 
-		enabled = modest_account_mgr_get_enabled (self, account);
+	else
+		enabled = modest_account_mgr_get_enabled (self, account_name);
 
-	/* server account was changed, default account was changed
-	 * and always notify when enabled/disabled changes
+	/* Notify is server account was changed, default account was changed
+	 * or when enabled/disabled changes:
 	 */
-	if (enabled ||
-	    g_str_has_suffix (key, MODEST_ACCOUNT_ENABLED) ||
-	    strcmp (key, MODEST_CONF_DEFAULT_ACCOUNT) == 0)
-		g_signal_emit (G_OBJECT(self), signals[ACCOUNT_CHANGED_SIGNAL], 0,
-			       account, key, is_server_account);
-
-	g_free (account);
+	if (!is_server_account)
+	if (enabled || g_str_has_suffix (key, MODEST_ACCOUNT_ENABLED) ||
+	    strcmp (key, MODEST_CONF_DEFAULT_ACCOUNT) == 0) {
+		if (!in_change_queue (priv->change_queue, account_name)) {
+			priv->change_queue = add_to_change_queue (priv->change_queue,
+								  account_name);
+			/* hmm, small race when this object is destroyed within
+			 * 500ms of the last change, and there are multiple timeouts... */
+			priv->timeout = g_timeout_add (500, (GSourceFunc)on_timeout_notify_changes,
+						       self);
+		}   
+	}
+	g_free (account_name);
 }
 
 
@@ -115,7 +230,7 @@ modest_account_mgr_get_type (void)
 	if (!my_type) {
 		static const GTypeInfo my_info = {
 			sizeof (ModestAccountMgrClass),
-			NULL,	/* base init */
+			modest_account_mgr_base_init,	/* base init */
 			NULL,	/* base finalize */
 			(GClassInitFunc) modest_account_mgr_class_init,
 			NULL,	/* class finalize */
@@ -133,6 +248,53 @@ modest_account_mgr_get_type (void)
 	return my_type;
 }
 
+static void 
+modest_account_mgr_base_init (gpointer g_class)
+{
+	static gboolean modest_account_mgr_initialized = FALSE;
+
+	if (!modest_account_mgr_initialized) {
+		/* signal definitions */
+		signals[ACCOUNT_INSERTED_SIGNAL] =
+			g_signal_new ("account_inserted",
+				      MODEST_TYPE_ACCOUNT_MGR,
+				      G_SIGNAL_RUN_FIRST,
+				      G_STRUCT_OFFSET(ModestAccountMgrClass,account_inserted),
+				      NULL, NULL,
+				      g_cclosure_marshal_VOID__STRING,
+				      G_TYPE_NONE, 1, G_TYPE_STRING);
+
+		signals[ACCOUNT_REMOVED_SIGNAL] =
+			g_signal_new ("account_removed",
+				      MODEST_TYPE_ACCOUNT_MGR,
+				      G_SIGNAL_RUN_FIRST,
+				      G_STRUCT_OFFSET(ModestAccountMgrClass,account_removed),
+				      NULL, NULL,
+				      g_cclosure_marshal_VOID__STRING,
+				      G_TYPE_NONE, 1, G_TYPE_STRING);
+
+		signals[ACCOUNT_CHANGED_SIGNAL] =
+			g_signal_new ("account_changed",
+				      MODEST_TYPE_ACCOUNT_MGR,
+				      G_SIGNAL_RUN_FIRST,
+				      G_STRUCT_OFFSET(ModestAccountMgrClass,account_changed),
+				      NULL, NULL,
+				      g_cclosure_marshal_VOID__STRING,
+				      G_TYPE_NONE, 1, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
+
+		signals[ACCOUNT_BUSY_SIGNAL] =
+			g_signal_new ("account_busy_changed",
+				      MODEST_TYPE_ACCOUNT_MGR,
+				      G_SIGNAL_RUN_FIRST,
+				      G_STRUCT_OFFSET(ModestAccountMgrClass,account_busy_changed),
+				      NULL, NULL,
+				      modest_marshal_VOID__STRING_BOOLEAN,
+				      G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_BOOLEAN);
+
+		modest_account_mgr_initialized = TRUE;
+	}
+}
+
 static void
 modest_account_mgr_class_init (ModestAccountMgrClass * klass)
 {
@@ -144,24 +306,6 @@ modest_account_mgr_class_init (ModestAccountMgrClass * klass)
 
 	g_type_class_add_private (gobject_class,
 				  sizeof (ModestAccountMgrPrivate));
-
-	/* signal definitions */
-	signals[ACCOUNT_REMOVED_SIGNAL] =
- 		g_signal_new ("account_removed",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET(ModestAccountMgrClass,account_removed),
-			      NULL, NULL,
-			      modest_marshal_VOID__STRING_BOOLEAN,
-			      G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_BOOLEAN);
-	signals[ACCOUNT_CHANGED_SIGNAL] =
- 		g_signal_new ("account_changed",
-	                       G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET(ModestAccountMgrClass,account_changed),
-			      NULL, NULL,
-			      modest_marshal_VOID__STRING_STRING_BOOLEAN,
-			      G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
 }
 
 
@@ -171,26 +315,48 @@ modest_account_mgr_init (ModestAccountMgr * obj)
 	ModestAccountMgrPrivate *priv =
 		MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
 
-	priv->modest_conf = NULL;
+	priv->modest_conf   = NULL;
+	priv->busy_accounts = NULL;
+	priv->change_queue  = NULL;
+	priv->timeout       = 0;
+	
+	priv->notification_id_accounts = g_hash_table_new_full (g_int_hash, g_int_equal, g_free, g_free);
 }
 
 static void
 modest_account_mgr_finalize (GObject * obj)
 {
-	ModestAccountMgrPrivate *priv =
+	ModestAccountMgrPrivate *priv = 
 		MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
 
+	if (priv->notification_id_accounts) {
+		/* TODO: forget dirs */
+
+		g_hash_table_destroy (priv->notification_id_accounts);
+	}
+
+	if (priv->key_changed_handler_uid) {
+		g_signal_handler_disconnect (priv->modest_conf, 
+					     priv->key_changed_handler_uid);
+		priv->key_changed_handler_uid = 0;
+	}
+
 	if (priv->modest_conf) {
 		g_object_unref (G_OBJECT(priv->modest_conf));
 		priv->modest_conf = NULL;
 	}
 
+	if (priv->timeout)
+		g_source_remove (priv->timeout);
+	priv->timeout = 0;
+
+
 	G_OBJECT_CLASS(parent_class)->finalize (obj);
 }
 
 
 ModestAccountMgr *
-modest_account_mgr_new (ModestConf * conf)
+modest_account_mgr_new (ModestConf *conf)
 {
 	GObject *obj;
 	ModestAccountMgrPrivate *priv;
@@ -203,9 +369,10 @@ modest_account_mgr_new (ModestConf * conf)
 	g_object_ref (G_OBJECT(conf));
 	priv->modest_conf = conf;
 
-	g_signal_connect (G_OBJECT (conf), "key_changed",
-	                  G_CALLBACK (on_key_change),
-			  obj);
+ 	priv->key_changed_handler_uid = 
+ 		g_signal_connect (G_OBJECT (conf), "key_changed",
+ 				  G_CALLBACK (on_key_change),
+ 				  obj);
 	
 	return MODEST_ACCOUNT_MGR (obj);
 }
@@ -223,181 +390,334 @@ modest_account_mgr_add_account (ModestAccountMgr *self,
 				const gchar *name,
 				const gchar *store_account,
 				const gchar *transport_account,
-				GError **err)
+				gboolean enabled)
 {
 	ModestAccountMgrPrivate *priv;
 	gchar *key;
 	gboolean ok;
 	gchar *default_account;
+	GError *err = NULL;
 	
-	g_return_val_if_fail (self, FALSE);
+	g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
 	g_return_val_if_fail (name, FALSE);
 	g_return_val_if_fail (strchr(name, '/') == NULL, FALSE);
 	
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-	
+
 	/*
 	 * we create the account by adding an account 'dir', with the name <name>,
 	 * and in that the 'display_name' string key
 	 */
 	key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_DISPLAY_NAME, FALSE);
-	if (modest_account_mgr_account_exists (self, key, FALSE, err)) {
+	if (modest_account_mgr_account_exists (self, key, FALSE)) {
 		g_printerr ("modest: account already exists\n");
 		g_free (key);
 		return FALSE;
 	}
 	
-	ok = modest_conf_set_string (priv->modest_conf, key, name, err);
+	ok = modest_conf_set_string (priv->modest_conf, key, name, &err);
 	g_free (key);
 	if (!ok) {
 		g_printerr ("modest: cannot set display name\n");
+		if (err) {
+			g_printerr ("modest: Error adding account conf: %s\n", err->message);
+			g_error_free (err);
+		}
 		return FALSE;
 	}
 	
 	if (store_account) {
 		key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_STORE_ACCOUNT, FALSE);
-		ok = modest_conf_set_string (priv->modest_conf, key, store_account, err);
+		ok = modest_conf_set_string (priv->modest_conf, key, store_account, &err);
 		g_free (key);
 		if (!ok) {
 			g_printerr ("modest: failed to set store account '%s'\n",
 				store_account);
+			if (err) {
+				g_printerr ("modest: Error adding store account conf: %s\n", err->message);
+				g_error_free (err);
+			}
 			return FALSE;
 		}
 	}
-
+	
 	if (transport_account) {
-		key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_TRANSPORT_ACCOUNT, FALSE);
-		ok = modest_conf_set_string (priv->modest_conf, key, transport_account, err);
+		key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_TRANSPORT_ACCOUNT,
+							       FALSE);
+		ok = modest_conf_set_string (priv->modest_conf, key, transport_account, &err);
 		g_free (key);
 		if (!ok) {
 			g_printerr ("modest: failed to set transport account '%s'\n",
-				transport_account);
+				    transport_account);
+			if (err) {
+				g_printerr ("modest: Error adding transport account conf: %s\n", err->message);
+				g_error_free (err);
+			}	
 			return FALSE;
 		}
 	}
-	modest_account_mgr_set_enabled (self, name, TRUE);
+
+	/* Make sure that leave-messages-on-server is enabled by default, 
+	 * as per the UI spec, though it is only meaningful for accounts using POP.
+	 * (possibly this gconf key should be under the server account): */
+	modest_account_mgr_set_bool (self, name,
+		MODEST_ACCOUNT_LEAVE_ON_SERVER, TRUE, FALSE /* not server account */);
+
+
+	modest_account_mgr_set_enabled (self, name, enabled);
+
+	/* Notify the observers */
+	g_signal_emit (self, signals[ACCOUNT_INSERTED_SIGNAL], 0, name);
 
 	/* if no default account has been defined yet, do so now */
 	default_account = modest_account_mgr_get_default_account (self);
 	if (!default_account)
 		modest_account_mgr_set_default_account (self, name);
 	g_free (default_account);
-	
+
 	return TRUE;
 }
 
 
-
-
 gboolean
 modest_account_mgr_add_server_account (ModestAccountMgr * self,
 				       const gchar * name, const gchar *hostname,
+				       guint portnumber,
 				       const gchar * username, const gchar * password,
-				       ModestProtocol proto)
+				       ModestTransportStoreProtocol proto,
+				       ModestConnectionProtocol security,
+				       ModestAuthProtocol auth)
 {
 	ModestAccountMgrPrivate *priv;
 	gchar *key;
-	ModestProtocolType proto_type;
-	
-	g_return_val_if_fail (self, FALSE);
+	gboolean ok = TRUE;
+	GError *err = NULL;
+
+	g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
 	g_return_val_if_fail (name, FALSE);
 	g_return_val_if_fail (strchr(name, '/') == NULL, FALSE);
-
-	proto_type = modest_protocol_info_get_protocol_type (proto);
-	g_return_val_if_fail (proto_type == MODEST_PROTOCOL_TYPE_TRANSPORT ||
-			      proto_type == MODEST_PROTOCOL_TYPE_STORE, FALSE);
 			      
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-	
+
 	/* hostname */
 	key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_HOSTNAME, TRUE);
-	if (modest_conf_key_exists (priv->modest_conf, key, NULL)) {
-		g_printerr ("modest: server account '%s' already exists", name);
+	if (modest_conf_key_exists (priv->modest_conf, key, &err)) {
+		g_printerr ("modest: server account '%s' already exists\n", name);
 		g_free (key);
-		return FALSE;
+		ok =  FALSE;
 	}
+	if (!ok)
+		goto cleanup;
 	
-	modest_conf_set_string (priv->modest_conf, key, null_means_empty(hostname), NULL);
+	modest_conf_set_string (priv->modest_conf, key, null_means_empty(hostname), &err);
+	if (err) {
+		g_printerr ("modest: failed to set %s: %s\n", key, err->message);
+		g_error_free (err);
+		ok = FALSE;
+	}
 	g_free (key);
-
+	if (!ok)
+		goto cleanup;
+	
 	/* username */
 	key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_USERNAME, TRUE);
-	modest_conf_set_string (priv->modest_conf, key,	null_means_empty (username), NULL);
+	ok = modest_conf_set_string (priv->modest_conf, key, null_means_empty (username), &err);
+	if (err) {
+		g_printerr ("modest: failed to set %s: %s\n", key, err->message);
+		g_error_free (err);
+		ok = FALSE;
+	}
 	g_free (key);
-
+	if (!ok)
+		goto cleanup;
+	
+	
 	/* password */
 	key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_PASSWORD, TRUE);
-	modest_conf_set_string (priv->modest_conf, key,	null_means_empty (password), NULL);
+	ok = modest_conf_set_string (priv->modest_conf, key, null_means_empty (password), &err);
+	if (err) {
+		g_printerr ("modest: failed to set %s: %s\n", key, err->message);
+		g_error_free (err);
+		ok = FALSE;
+	}
 	g_free (key);
+	if (!ok)
+		goto cleanup;
 
 	/* proto */
 	key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_PROTO, TRUE);
-	modest_conf_set_string (priv->modest_conf, key,
-				modest_protocol_info_get_protocol_name(proto),
-				NULL);
+	ok = modest_conf_set_string (priv->modest_conf, key,
+				     modest_protocol_info_get_transport_store_protocol_name(proto),
+				     &err);
+	if (err) {
+		g_printerr ("modest: failed to set %s: %s\n", key, err->message);
+		g_error_free (err);
+		ok = FALSE;
+	}
+	g_free (key);
+	if (!ok)
+		goto cleanup;
+
+
+	/* portnumber */
+	key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_PORT, TRUE);
+	ok = modest_conf_set_int (priv->modest_conf, key, portnumber, &err);
+	if (err) {
+		g_printerr ("modest: failed to set %s: %s\n", key, err->message);
+		g_error_free (err);
+		ok = FALSE;
+	}
 	g_free (key);
+	if (!ok)
+		goto cleanup;
+
 	
+	/* auth mechanism */
+	key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_AUTH_MECH, TRUE);
+	ok = modest_conf_set_string (priv->modest_conf, key,
+				     modest_protocol_info_get_auth_protocol_name (auth),
+				     &err);
+	if (err) {
+		g_printerr ("modest: failed to set %s: %s\n", key, err->message);
+		g_error_free (err);
+		ok = FALSE;
+	}
+	g_free (key);
+	if (!ok)
+		goto cleanup;
+	
+	/* Add the security settings: */
+	modest_server_account_set_security (self, name, security);
+	
+cleanup:
+	if (!ok) {
+		g_printerr ("modest: failed to add server account\n");
+		return FALSE;
+	}
+
 	return TRUE;
 }
 
-
+/** modest_account_mgr_add_server_account_uri:
+ * Only used for mbox and maildir accounts.
+ */
 gboolean
 modest_account_mgr_add_server_account_uri (ModestAccountMgr * self,
-					   const gchar *name, ModestProtocol proto,
+					   const gchar *name, ModestTransportStoreProtocol proto,
 					   const gchar *uri)
 {
 	ModestAccountMgrPrivate *priv;
 	gchar *key;
+	gboolean ok;
 	
-	g_return_val_if_fail (self, FALSE);
+	g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
 	g_return_val_if_fail (name, FALSE);
 	g_return_val_if_fail (strchr(name, '/') == NULL, FALSE);
 	g_return_val_if_fail (uri, FALSE);
 	
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-
-
+	
+	
 	/* proto */
 	key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_PROTO, TRUE);
-	modest_conf_set_string (priv->modest_conf, key,
-				modest_protocol_info_get_protocol_name(proto), NULL);
+	ok = modest_conf_set_string (priv->modest_conf, key,
+				     modest_protocol_info_get_transport_store_protocol_name(proto),
+				     NULL);
 	g_free (key);
+
+	if (!ok) {
+		g_printerr ("modest: failed to set proto\n");
+		return FALSE;
+	}
 	
 	/* uri */
 	key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_URI, TRUE);
-	modest_conf_set_string (priv->modest_conf, key,	uri, NULL);
+	ok = modest_conf_set_string (priv->modest_conf, key, uri, NULL);
 	g_free (key);
 
+	if (!ok) {
+		g_printerr ("modest: failed to set uri\n");
+		return FALSE;
+	}
 	return TRUE;
 }
 
+/* 
+ * Utility function used by modest_account_mgr_remove_account
+ */
+static void
+real_remove_account (ModestConf *conf,
+		     const gchar *acc_name,
+		     gboolean server_account)
+{
+	GError *err = NULL;
+	gchar *key = NULL;
 
+	key = _modest_account_mgr_get_account_keyname (acc_name, NULL, server_account);
+	modest_conf_remove_key (conf, key, &err);
+	g_free (key);       
+
+	if (err) {
+		g_printerr ("modest: error removing key: %s\n", err->message);
+		g_error_free (err);
+	}
+}
 
 gboolean
 modest_account_mgr_remove_account (ModestAccountMgr * self,
-				   const gchar * name,
-				   gboolean server_account,
-				   GError ** err)
+				   const gchar* name)
 {
 	ModestAccountMgrPrivate *priv;
-	gchar *key;
-	gboolean retval;
+	gchar *default_account_name, *store_acc_name, *transport_acc_name;
+	gboolean default_account_deleted;
 
-	g_return_val_if_fail (self, FALSE);
+	g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
 	g_return_val_if_fail (name, FALSE);
 
-	if (!modest_account_mgr_account_exists (self, name, server_account, err)) {
-		g_printerr ("modest: account '%s' does not exist\n", name);
+	if (!modest_account_mgr_account_exists (self, name, FALSE)) {
+		g_printerr ("modest: %s: account '%s' does not exist\n", __FUNCTION__, name);
 		return FALSE;
 	}
 
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-	key = _modest_account_mgr_get_account_keyname (name, NULL, server_account);
+	default_account_deleted = FALSE;
 
-	retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
+	/* If this was the default, then remove that setting: */
+	default_account_name = modest_account_mgr_get_default_account (self);
+	if (default_account_name && (strcmp (default_account_name, name) == 0)) {
+		modest_account_mgr_unset_default_account (self);
+		default_account_deleted = TRUE;
+	}
+	g_free (default_account_name);
+
+	/* Delete transport and store accounts */
+	store_acc_name = modest_account_mgr_get_string (self, name, 
+							MODEST_ACCOUNT_STORE_ACCOUNT, FALSE);
+	if (store_acc_name)
+		real_remove_account (priv->modest_conf, store_acc_name, TRUE);
+
+	transport_acc_name = modest_account_mgr_get_string (self, name, 
+							    MODEST_ACCOUNT_TRANSPORT_ACCOUNT, FALSE);
+	if (transport_acc_name)
+		real_remove_account (priv->modest_conf, transport_acc_name, TRUE);
+			
+	/* Remove the modest account */
+	real_remove_account (priv->modest_conf, name, FALSE);
+
+	if (default_account_deleted) {	
+		/* pick another one as the new default account. We do
+		   this *after* deleting the keys, because otherwise a
+		   call to account_names will retrieve also the
+		   deleted account */
+		modest_account_mgr_set_first_account_as_default (self);
+	}
+	
+	/* Notify the observers. We do this *after* deleting
+	   the keys, because otherwise a call to account_names
+	   will retrieve also the deleted account */
+	g_signal_emit (G_OBJECT(self), signals[ACCOUNT_REMOVED_SIGNAL], 0, name);
 
-	g_free (key);
-	return retval;
+	return TRUE;
 }
 
 
@@ -419,93 +739,113 @@ strip_prefix_from_elements (GSList * lst, guint n)
 
 
 GSList*
-modest_account_mgr_search_server_accounts (ModestAccountMgr * self,
-					   const gchar * account_name,
-					   ModestProtocolType type,
-					   ModestProtocol proto)
+modest_account_mgr_account_names (ModestAccountMgr * self, gboolean only_enabled)
 {
 	GSList *accounts;
-	GSList *cursor;
 	ModestAccountMgrPrivate *priv;
-	gchar *key;
 	GError *err = NULL;
 	
+	const size_t prefix_len = strlen (MODEST_ACCOUNT_NAMESPACE "/");
+
 	g_return_val_if_fail (self, NULL);
 
-	if (proto != MODEST_PROTOCOL_UNKNOWN) {
-		ModestProtocolType proto_type;
-		proto_type = modest_protocol_info_get_protocol_type (proto);
-		g_return_val_if_fail (proto_type == MODEST_PROTOCOL_TYPE_TRANSPORT ||
-				      proto_type == MODEST_PROTOCOL_TYPE_STORE, NULL);
-	}
-	
-	key      = _modest_account_mgr_get_account_keyname (account_name, NULL, TRUE);
-	priv     = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-	
-	/* get the list of all server accounts */
-	accounts = modest_conf_list_subkeys (priv->modest_conf, key, &err);
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+	accounts = modest_conf_list_subkeys (priv->modest_conf,
+                                             MODEST_ACCOUNT_NAMESPACE, &err);
+
 	if (err) {
+		g_printerr ("modest: failed to get subkeys (%s): %s\n",
+			    MODEST_ACCOUNT_NAMESPACE, err->message);
 		g_error_free (err);
-		g_printerr ("modest: failed to get subkeys for '%s'\n", key);
-		return NULL;
+		return NULL; /* assume accounts did not get value when err is set...*/
 	}
 	
-	/* filter out the ones with the wrong protocol */
-	/* we could optimize for unknown proto / unknown type, but it will only
-	 * make the code more complex */
-	cursor = accounts;
-	while (cursor) { 
-		gchar *account   = _modest_account_mgr_account_from_key ((gchar*)cursor->data, NULL, NULL);
-		gchar *acc_proto = modest_account_mgr_get_string (self, account, MODEST_ACCOUNT_PROTO,
-								  TRUE, NULL);
-		ModestProtocol     this_proto = modest_protocol_info_get_protocol (acc_proto);
-		ModestProtocolType this_type  = modest_protocol_info_get_protocol_type (this_proto);
-
-		if ((this_type  != MODEST_PROTOCOL_TYPE_UNKNOWN && this_type  != type) ||
-		    (this_proto != MODEST_PROTOCOL_UNKNOWN      && this_proto != proto)) {
-			GSList *nxt = cursor->next;
-			accounts = g_slist_delete_link (accounts, cursor);
-			cursor = nxt;
-		} else
-			cursor = cursor->next;
+	strip_prefix_from_elements (accounts, prefix_len);
 		
-		g_free (account);
-		g_free (acc_proto);
+	GSList *result = NULL;
+	
+	/* Unescape the keys to get the account names: */
+	GSList *iter = accounts;
+	while (iter) {
+		if (!(iter->data))
+			continue;
+			
+		const gchar* account_name_key = (const gchar*)iter->data;
+		gchar* unescaped_name = account_name_key ? 
+			modest_conf_key_unescape (account_name_key) 
+			: NULL;
+		
+		gboolean add = TRUE;
+		if (only_enabled) {
+			if (unescaped_name && 
+				!modest_account_mgr_get_enabled (self, unescaped_name)) {
+				add = FALSE;
+			}
+		}
+		
+		/* Ignore modest accounts whose server accounts don't exist: 
+		 * (We could be getting this list while the account is being deleted, 
+		 * while the child server accounts have already been deleted, but the 
+		 * parent modest account already exists.
+		 */
+		if (add) {
+			gchar* server_account_name = modest_account_mgr_get_string (self, account_name_key, MODEST_ACCOUNT_STORE_ACCOUNT,
+									    FALSE);
+			if (server_account_name) {
+				if (!modest_account_mgr_account_exists (self, server_account_name, TRUE))
+					add = FALSE;
+				g_free (server_account_name);
+			}
+		}
+		
+		if (add) {
+			gchar* server_account_name = modest_account_mgr_get_string (self, account_name_key, MODEST_ACCOUNT_TRANSPORT_ACCOUNT,
+									    FALSE);
+			if (server_account_name) {
+				if (!modest_account_mgr_account_exists (self, server_account_name, TRUE))
+					add = FALSE;
+				g_free (server_account_name);
+			}
+		}
+		
+		if (add) 	
+			result = g_slist_append (result, unescaped_name);
+		else 
+			g_free (unescaped_name);
+
+		g_free (iter->data);
+		iter->data = NULL;
+		
+		iter = g_slist_next (iter);	
 	}
 	
-	/* +1 because we must remove the ending '/' as well */
-	strip_prefix_from_elements (accounts, strlen(key)+1);
-	return accounts;	
+
+	/* we already freed the strings in the loop */
+	g_slist_free (accounts);
+	
+	accounts = NULL;
+	return result;
 }
 
 
-GSList*
-modest_account_mgr_account_names (ModestAccountMgr * self, GError ** err)
+void
+modest_account_mgr_free_account_names (GSList *account_names)
 {
-	GSList *accounts;
-	ModestAccountMgrPrivate *priv;
-	const size_t prefix_len = strlen (MODEST_ACCOUNT_NAMESPACE "/");
-
-	g_return_val_if_fail (self, NULL);
-
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-
-	accounts = modest_conf_list_subkeys (priv->modest_conf,
-                                             MODEST_ACCOUNT_NAMESPACE, err);
-	
-	strip_prefix_from_elements (accounts, prefix_len);
-	return accounts;
+	g_slist_foreach (account_names, (GFunc)g_free, NULL);
+	g_slist_free (account_names);
 }
 
 
+
 gchar *
 modest_account_mgr_get_string (ModestAccountMgr *self, const gchar *name,
-			       const gchar *key, gboolean server_account, GError **err) {
+			       const gchar *key, gboolean server_account) {
 
 	ModestAccountMgrPrivate *priv;
 
 	gchar *keyname;
 	gchar *retval;
+	GError *err = NULL;
 
 	g_return_val_if_fail (self, NULL);
 	g_return_val_if_fail (name, NULL);
@@ -514,30 +854,51 @@ modest_account_mgr_get_string (ModestAccountMgr *self, const gchar *name,
 	keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
 	
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-	retval = modest_conf_get_string (priv->modest_conf, keyname, err);
+	retval = modest_conf_get_string (priv->modest_conf, keyname, &err);	
+	if (err) {
+		g_printerr ("modest: error getting string '%s': %s\n", keyname, err->message);
+		g_error_free (err);
+		retval = NULL;
+	}
 	g_free (keyname);
 
 	return retval;
 }
 
 
+gchar *
+modest_account_mgr_get_password (ModestAccountMgr *self, const gchar *name,
+			       const gchar *key, gboolean server_account)
+{
+	return modest_account_mgr_get_string (self, name, key, server_account);
+
+}
+
+
+
 gint
-modest_account_mgr_get_int (ModestAccountMgr *self, const gchar *name,
-			    const gchar *key, gboolean server_account, GError **err)
+modest_account_mgr_get_int (ModestAccountMgr *self, const gchar *name, const gchar *key,
+			    gboolean server_account)
 {
 	ModestAccountMgrPrivate *priv;
 
 	gchar *keyname;
 	gint retval;
-
-	g_return_val_if_fail (self, -1);
+	GError *err = NULL;
+	
+	g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), -1);
 	g_return_val_if_fail (name, -1);
 	g_return_val_if_fail (key, -1);
 
 	keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
 
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-	retval = modest_conf_get_int (priv->modest_conf, keyname, err);
+	retval = modest_conf_get_int (priv->modest_conf, keyname, &err);
+	if (err) {
+		g_printerr ("modest: error getting int '%s': %s\n", keyname, err->message);
+		g_error_free (err);
+		retval = -1;
+	}
 	g_free (keyname);
 
 	return retval;
@@ -547,22 +908,59 @@ modest_account_mgr_get_int (ModestAccountMgr *self, const gchar *name,
 
 gboolean
 modest_account_mgr_get_bool (ModestAccountMgr * self, const gchar *account,
-			     const gchar * key, gboolean server_account, GError ** err)
+			     const gchar * key, gboolean server_account)
 {
 	ModestAccountMgrPrivate *priv;
 
 	gchar *keyname;
 	gboolean retval;
+	GError *err = NULL;
 
-	g_return_val_if_fail (self, FALSE);
+	g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
 	g_return_val_if_fail (account, FALSE);
 	g_return_val_if_fail (key, FALSE);
 
 	keyname = _modest_account_mgr_get_account_keyname (account, key, server_account);
 	
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-	retval = modest_conf_get_bool (priv->modest_conf, keyname, err);
-		
+	retval = modest_conf_get_bool (priv->modest_conf, keyname, &err);		
+	if (err) {
+		g_printerr ("modest: error getting bool '%s': %s\n", keyname, err->message);
+		g_error_free (err);
+		retval = FALSE;
+	}
+	g_free (keyname);
+
+	return retval;
+}
+
+
+
+GSList * 
+modest_account_mgr_get_list (ModestAccountMgr *self, const gchar *name,
+			     const gchar *key, ModestConfValueType list_type,
+			     gboolean server_account)
+{
+	ModestAccountMgrPrivate *priv;
+
+	gchar *keyname;
+	GSList *retval;
+	GError *err = NULL;
+	
+	g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), NULL);
+	g_return_val_if_fail (name, NULL);
+	g_return_val_if_fail (key, NULL);
+
+	keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
+	
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+	retval = modest_conf_get_list (priv->modest_conf, keyname, list_type, &err);
+	if (err) {
+		g_printerr ("modest: error getting list '%s': %s\n", keyname,
+			    err->message);
+		g_error_free (err);
+		retval = FALSE;
+	}
 	g_free (keyname);
 
 	return retval;
@@ -571,15 +969,15 @@ modest_account_mgr_get_bool (ModestAccountMgr * self, const gchar *account,
 
 gboolean
 modest_account_mgr_set_string (ModestAccountMgr * self, const gchar * name,
-			       const gchar * key, const gchar * val,
-			       gboolean server_account, GError ** err)
+			       const gchar * key, const gchar * val, gboolean server_account)
 {
 	ModestAccountMgrPrivate *priv;
 
 	gchar *keyname;
 	gboolean retval;
+	GError *err = NULL;
 
-	g_return_val_if_fail (self, FALSE);
+	g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
 	g_return_val_if_fail (name, FALSE);
 	g_return_val_if_fail (key, FALSE);
 
@@ -587,25 +985,37 @@ modest_account_mgr_set_string (ModestAccountMgr * self, const gchar * name,
 	
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 
-	retval = modest_conf_set_string (priv->modest_conf, keyname, val,
-					 err);
-
-	g_free (keyname);
+	retval = modest_conf_set_string (priv->modest_conf, keyname, val, &err);
+	if (err) {
+		g_printerr ("modest: error setting string '%s': %s\n", keyname, err->message);
+		g_error_free (err);
+		retval = FALSE;
+	}
+	g_free (keyname);	
 	return retval;
 }
 
 
 gboolean
+modest_account_mgr_set_password (ModestAccountMgr * self, const gchar * name,
+				 const gchar * key, const gchar * val, gboolean server_account)
+{
+	return modest_account_mgr_set_password (self, name, key, val, server_account);
+}
+
+
+
+gboolean
 modest_account_mgr_set_int (ModestAccountMgr * self, const gchar * name,
-			    const gchar * key, int val, gboolean server_account,
-			    GError ** err)
+			    const gchar * key, int val, gboolean server_account)
 {
 	ModestAccountMgrPrivate *priv;
 
 	gchar *keyname;
 	gboolean retval;
-
-	g_return_val_if_fail (self, FALSE);
+	GError *err = NULL;
+	
+	g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
 	g_return_val_if_fail (name, FALSE);
 	g_return_val_if_fail (key, FALSE);
 
@@ -613,8 +1023,12 @@ modest_account_mgr_set_int (ModestAccountMgr * self, const gchar * name,
 	
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 
-	retval = modest_conf_set_int (priv->modest_conf, keyname, val, err);
-
+	retval = modest_conf_set_int (priv->modest_conf, keyname, val, &err);
+	if (err) {
+		g_printerr ("modest: error setting int '%s': %s\n", keyname, err->message);
+		g_error_free (err);
+		retval = FALSE;
+	}
 	g_free (keyname);
 	return retval;
 }
@@ -623,15 +1037,15 @@ modest_account_mgr_set_int (ModestAccountMgr * self, const gchar * name,
 
 gboolean
 modest_account_mgr_set_bool (ModestAccountMgr * self, const gchar * name,
-			     const gchar * key, gboolean val, gboolean server_account, 
-			     GError ** err)
+			     const gchar * key, gboolean val, gboolean server_account)
 {
 	ModestAccountMgrPrivate *priv;
 
 	gchar *keyname;
 	gboolean retval;
+	GError *err = NULL;
 
-	g_return_val_if_fail (self, FALSE);
+	g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
 	g_return_val_if_fail (name, FALSE);
 	g_return_val_if_fail (key, FALSE);
 
@@ -639,106 +1053,315 @@ modest_account_mgr_set_bool (ModestAccountMgr * self, const gchar * name,
 
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 
-	retval = modest_conf_set_bool (priv->modest_conf, keyname, val, err);
-
+	retval = modest_conf_set_bool (priv->modest_conf, keyname, val, &err);
+	if (err) {
+		g_printerr ("modest: error setting bool '%s': %s\n", keyname, err->message);
+		g_error_free (err);
+		retval = FALSE;
+	}
 	g_free (keyname);
 	return retval;
 }
 
-void 
+
+gboolean
 modest_account_mgr_set_list (ModestAccountMgr *self,
 			     const gchar *name,
 			     const gchar *key,
 			     GSList *val,
 			     ModestConfValueType list_type,
-			     gboolean server_account,
-			     GError **err)
+			     gboolean server_account)
 {
 	ModestAccountMgrPrivate *priv;
 	gchar *keyname;
+	GError *err = NULL;
+	gboolean retval;
 	
-	g_return_if_fail (self);
-	g_return_if_fail (name);
-	g_return_if_fail (key);
-	g_return_if_fail (val);
+	g_return_val_if_fail (self, FALSE);
+	g_return_val_if_fail (name, FALSE);
+	g_return_val_if_fail (key,  FALSE);
+	g_return_val_if_fail (val,  FALSE);
 
 	keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
 	
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-	modest_conf_set_list (priv->modest_conf, keyname, val, list_type, err);
+	retval = modest_conf_set_list (priv->modest_conf, keyname, val, list_type, &err);
+	if (err) {
+		g_printerr ("modest: error setting list '%s': %s\n", keyname, err->message);
+		g_error_free (err);
+		retval = FALSE;
+	}
 	g_free (keyname);
+
+	return retval;
 }
 
 gboolean
-modest_account_mgr_account_exists (ModestAccountMgr * self, const gchar * name,
-				   gboolean server_account, GError ** err)
+modest_account_mgr_account_exists (ModestAccountMgr * self, const gchar* name,
+				   gboolean server_account)
 {
 	ModestAccountMgrPrivate *priv;
 
 	gchar *keyname;
 	gboolean retval;
+	GError *err = NULL;
 
 	g_return_val_if_fail (self, FALSE);
         g_return_val_if_fail (name, FALSE);
 
 	keyname = _modest_account_mgr_get_account_keyname (name, NULL, server_account);
-
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-	retval = modest_conf_key_exists (priv->modest_conf, keyname, err);
-
+	retval = modest_conf_key_exists (priv->modest_conf, keyname, &err);
+	if (err) {
+		g_printerr ("modest: error determining existance of '%s': %s\n", keyname,
+			    err->message);
+		g_error_free (err);
+		retval = FALSE;
+	}
 	g_free (keyname);
 	return retval;
 }
 
-
-GSList * 
-modest_account_mgr_get_list (ModestAccountMgr *self,
-			     const gchar *name,
-			     const gchar *key,
-			     ModestConfValueType list_type,
-			     gboolean server_account,
-			     GError **err)
+gboolean
+modest_account_mgr_account_with_display_name_exists  (ModestAccountMgr *self, const gchar *display_name)
 {
-	ModestAccountMgrPrivate *priv;
-
-	gchar *keyname;
-	GSList *retval;
+	GSList *account_names = NULL;
+	GSList *cursor = NULL;
 	
-	g_return_val_if_fail (self, NULL);
-	g_return_val_if_fail (name, NULL);
-	g_return_val_if_fail (key, NULL);
+	cursor = account_names = modest_account_mgr_account_names (self, 
+								   TRUE /* enabled accounts, because disabled accounts are not user visible. */);
 
-	keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
+	gboolean found = FALSE;
 	
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-	retval = modest_conf_get_list (priv->modest_conf, keyname, list_type, err);
-	g_free (keyname);
+	/* Look at each non-server account to check their display names; */
+	while (cursor) {
+		const gchar * account_name = (gchar*)cursor->data;
+		
+		ModestAccountData *account_data = modest_account_mgr_get_account_data (self, account_name);
+		if (!account_data) {
+			g_printerr ("modest: failed to get account data for %s\n", account_name);
+			continue;
+		}
 
-	return retval;
+		if(account_data->display_name && (strcmp (account_data->display_name, display_name) == 0)) {
+			found = TRUE;
+			break;
+		}
+
+		modest_account_mgr_free_account_data (self, account_data);
+		cursor = cursor->next;
+	}
+	modest_account_mgr_free_account_names (account_names);
+	account_names = NULL;
+	
+	return found;
 }
 
 
+
+
 gboolean 
-modest_account_mgr_unset (ModestAccountMgr *self,
-			  const gchar *name,
-			  const gchar *key,
-			  gboolean server_account,
-			  GError **err)
+modest_account_mgr_unset (ModestAccountMgr *self, const gchar *name,
+			  const gchar *key, gboolean server_account)
 {
 	ModestAccountMgrPrivate *priv;
-
+	
 	gchar *keyname;
 	gboolean retval;
-
-	g_return_val_if_fail (self, FALSE);
+	GError *err = NULL;
+	
+	g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
         g_return_val_if_fail (name, FALSE);
         g_return_val_if_fail (key, FALSE);
 
 	keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
 
 	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-	retval = modest_conf_remove_key (priv->modest_conf, keyname, err);
-
+	retval = modest_conf_remove_key (priv->modest_conf, keyname, &err);
+	if (err) {
+		g_printerr ("modest: error unsetting'%s': %s\n", keyname,
+			    err->message);
+		g_error_free (err);
+		retval = FALSE;
+	}
 	g_free (keyname);
 	return retval;
 }
+
+gchar*
+_modest_account_mgr_account_from_key (const gchar *key, gboolean *is_account_key, gboolean *is_server_account)
+{
+	/* Initialize input parameters: */
+	if (is_account_key)
+		*is_account_key = FALSE;
+
+	if (is_server_account)
+		*is_server_account = FALSE;
+
+	const gchar* account_ns        = MODEST_ACCOUNT_NAMESPACE "/";
+	const gchar* server_account_ns = MODEST_SERVER_ACCOUNT_NAMESPACE "/";
+	gchar *cursor;
+	gchar *account = NULL;
+
+	/* determine whether it's an account or a server account,
+	 * based on the prefix */
+	if (g_str_has_prefix (key, account_ns)) {
+
+		if (is_server_account)
+			*is_server_account = FALSE;
+		
+		account = g_strdup (key + strlen (account_ns));
+
+	} else if (g_str_has_prefix (key, server_account_ns)) {
+
+		if (is_server_account)
+			*is_server_account = TRUE;
+		
+		account = g_strdup (key + strlen (server_account_ns));	
+	} else
+		return NULL;
+
+	/* if there are any slashes left in the key, it's not
+	 * the toplevel entry for an account
+	 */
+	cursor = strstr(account, "/");
+	
+	if (is_account_key && cursor)
+		*is_account_key = TRUE;
+
+	/* put a NULL where the first slash was */
+	if (cursor)
+		*cursor = '\0';
+
+	if (account) {
+		/* The key is an escaped string, so unescape it to get the actual account name: */
+		gchar *unescaped_name = modest_conf_key_unescape (account);
+		g_free (account);
+		return unescaped_name;
+	} else
+		return NULL;
+}
+
+
+
+
+/* optimization: only with non-alphanum chars, escaping is needed */
+inline static gboolean
+is_alphanum (const gchar* str)
+{
+	const gchar *cursor;
+	for (cursor = str; cursor && *cursor; ++cursor) {
+		const char c = *cursor;
+		/* we cannot trust isalnum(3), because it might consider locales */
+		/*       numbers            ALPHA            alpha       */
+		if (!((c>=48 && c<=57)||(c>=65 && c<=90)||(c>=97 && c<=122)))
+			return FALSE;
+	}
+	return TRUE;
+}
+		
+
+/* must be freed by caller */
+gchar *
+_modest_account_mgr_get_account_keyname (const gchar *account_name, const gchar * name, gboolean server_account)
+{
+	gchar *retval = NULL;	
+	gchar *namespace = server_account ? MODEST_SERVER_ACCOUNT_NAMESPACE : MODEST_ACCOUNT_NAMESPACE;
+	gchar *escaped_account_name, *escaped_name;
+	
+	if (!account_name)
+		return g_strdup (namespace);
+	
+	/* optimization: only escape names when need to be escaped */
+	if (is_alphanum (account_name))
+		escaped_account_name = (gchar*)account_name;
+	else
+		escaped_account_name = modest_conf_key_escape (account_name);
+	
+	if (is_alphanum (name))
+		escaped_name = (gchar*)name;
+	else
+		escaped_name = modest_conf_key_escape (name);
+	//////////////////////////////////////////////////////////////
+
+	if (escaped_account_name && escaped_name)
+		retval = g_strconcat (namespace, "/", escaped_account_name, "/", escaped_name, NULL);
+	else if (escaped_account_name)
+		retval = g_strconcat (namespace, "/", escaped_account_name, NULL);
+
+	/* Sanity check: */
+	if (!modest_conf_key_is_valid (retval)) {
+		g_warning ("%s: Generated conf key was invalid: %s", __FUNCTION__, retval);
+		g_free (retval);
+		retval = NULL;
+	}
+
+	/* g_free is only needed if we actually allocated anything */
+	if (name != escaped_name)
+		g_free (escaped_name);
+	if (account_name != escaped_account_name)
+		g_free (escaped_account_name);
+	
+	return retval;
+}
+
+gboolean
+modest_account_mgr_has_accounts (ModestAccountMgr* self, gboolean enabled)
+{
+	/* Check that at least one account exists: */
+	GSList *account_names = modest_account_mgr_account_names (self,
+								  enabled);
+	gboolean accounts_exist = account_names != NULL;
+	
+	modest_account_mgr_free_account_names (account_names);
+	account_names = NULL;
+	
+	return accounts_exist;
+}
+
+static int
+compare_account_name(gconstpointer a, gconstpointer b)
+{
+	const gchar* account_name = (const gchar*) a;
+	const gchar* account_name2 = (const gchar*) b;
+	return strcmp(account_name, account_name2);
+}
+
+void 
+modest_account_mgr_set_account_busy(ModestAccountMgr* self, const gchar* account_name, 
+				    gboolean busy)
+{
+	ModestAccountMgrPrivate* priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+	if (busy)
+	{
+		GSList *account_names = modest_account_mgr_account_names (self,
+				TRUE);
+		GSList* account = 
+			g_slist_find_custom(account_names, account_name, (GCompareFunc) compare_account_name);
+		if (account && !modest_account_mgr_account_is_busy(self, account_name))
+		{
+			priv->busy_accounts = g_slist_append(priv->busy_accounts, g_strdup(account_name));
+			g_signal_emit_by_name(G_OBJECT(self), "account-busy-changed", account_name, TRUE);
+		}
+		modest_account_mgr_free_account_names (account_names);
+		account_names = NULL;
+	} else {
+		GSList* account = 
+			g_slist_find_custom(priv->busy_accounts, account_name, (GCompareFunc) compare_account_name);
+		if (account)
+		{
+			g_free(account->data);
+			priv->busy_accounts = g_slist_delete_link(priv->busy_accounts, account);
+			g_signal_emit_by_name(G_OBJECT(self), "account-busy-changed", account_name, FALSE);
+		}
+	}
+}
+
+gboolean
+modest_account_mgr_account_is_busy(ModestAccountMgr* self, const gchar* account_name)
+{
+	ModestAccountMgrPrivate* priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+	return (g_slist_find_custom(priv->busy_accounts, account_name, (GCompareFunc) compare_account_name)
+					!= NULL);
+}
+