X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmodest-account-mgr-helpers.c;h=3891d646798e9775026a45ded6eccce4e0e5100f;hp=2d38cb083a26339494da4a86e38fa821ab68d091;hb=71ee02905c83ab1eb1f0b4236384cdcc9ed2c8a3;hpb=54954202742a0fde0fc9abe866aa650fea0e21b9

diff --git a/src/modest-account-mgr-helpers.c b/src/modest-account-mgr-helpers.c
index 2d38cb0..3891d64 100644
--- a/src/modest-account-mgr-helpers.c
+++ b/src/modest-account-mgr-helpers.c
@@ -47,104 +47,83 @@ modest_account_mgr_get_enabled (ModestAccountMgr *self, const gchar* name)
 	return modest_account_mgr_get_bool (self, name, MODEST_ACCOUNT_ENABLED, FALSE);
 }
 
-#if 0 /* Not needed, but works. */
-static gint
-compare_option_strings_for_name (const gchar* a, const gchar* b)
-{
-	/* printf("  debug: compare_option_strings_for_name():a=%s, b=%s\n", a, b); */
-	const gchar* sep = strchr(a, '=');
-	if (!sep)
-		return -1;
-		
-	gint len = sep - a;
-	if(len <= 0)
-		return -1;
-		
-	/* Get the part of the string before the =.
-	 * Note that this allocation is inefficient just so we can do a strcmp. */
-	gchar* name = g_malloc (len+1);
-	memcpy(name, a, len);
-	name[len] = 0; /* Null-termination. */
-	
-	/* printf("    debug: name=%s\n", name); */
-
-	gint result = strcmp (name, b);
-	
-	g_free (name);
-	
+gboolean modest_account_mgr_set_signature (ModestAccountMgr *self, const gchar* name, 
+	const gchar* signature, gboolean use_signature)
+{
+	gboolean result = modest_account_mgr_set_bool (self, name, MODEST_ACCOUNT_USE_SIGNATURE, 
+		use_signature, FALSE);
+	result = result && modest_account_mgr_set_string (self, name, MODEST_ACCOUNT_SIGNATURE, 
+		signature, FALSE);
 	return result;
 }
-           
-gchar*
-modest_server_account_data_get_option_string (GSList* options_list, const gchar* option_name)
+
+gchar* modest_account_mgr_get_signature (ModestAccountMgr *self, const gchar* name, 
+	gboolean* use_signature)
 {
-	if (!options_list)
-		return NULL;
-	
-	gchar *result = NULL;
-	GSList* option = g_slist_find_custom(options_list, option_name, (GCompareFunc)compare_option_strings_for_name);
-	if(option) {
-		/* Get the value part of the key=value pair: */
-		const gchar* pair = (const gchar*)option->data;
-		
-		const gchar* sep = strchr(pair, '=');
-		if (sep) {
-			gint len = sep - pair;
-			if(len > 0) {
-				result = g_strdup(sep+1);
-				
-				/* Avoid returning an empty string instead of NULL. */
-				if(result && strlen(result) == 0) {
-					g_free(result);
-					result = NULL;
-				}
-			}
-		}
+	if (use_signature) {
+		*use_signature = 
+			modest_account_mgr_get_bool (self, name, MODEST_ACCOUNT_USE_SIGNATURE, FALSE);
 	}
-		
-	return result;
+	
+	return modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_SIGNATURE, FALSE);
 }
 
-gboolean
-modest_server_account_data_get_option_bool (GSList* options_list, const gchar* option_name)
+
+ModestTransportStoreProtocol modest_account_mgr_get_store_protocol (ModestAccountMgr *self, const gchar* name)
 {
-	if (!options_list)
-		return FALSE;
+	ModestTransportStoreProtocol result = MODEST_PROTOCOL_STORE_POP; /* Arbitrary default */
 	
-	gboolean result = FALSE;
-	GSList* option = g_slist_find_custom(options_list, option_name, (GCompareFunc)strcmp);
-	if(option) {
-		return TRUE;
-	}
+	gchar *server_account_name = modest_account_mgr_get_string (self, name,
+							MODEST_ACCOUNT_STORE_ACCOUNT,
+							FALSE);
+	if (server_account_name) {
+		ModestServerAccountData* server_data = 
+			modest_account_mgr_get_server_account_data (self, server_account_name);
+		result = server_data->proto;
+			
+		modest_account_mgr_free_server_account_data (self, server_data);
 		
+		g_free (server_account_name);
+	}
+	
 	return result;
 }
-#endif
-
 
 gboolean modest_account_mgr_set_connection_specific_smtp (ModestAccountMgr *self, 
-	const gchar* account_name,
 	const gchar* connection_name, const gchar* server_account_name)
 {
-	modest_account_mgr_remove_connection_specific_smtp (self, account_name, connection_name);
-	
-	GSList *list = modest_account_mgr_get_list (self, account_name, 
-							MODEST_ACCOUNT_CONNECTION_SPECIFIC_SMTP_LIST,
-						    MODEST_CONF_VALUE_STRING, TRUE);
-		
-	/* The server account is in the item after the connection name: */
-	GSList *list_connection = g_slist_append (list, (gpointer)connection_name);
-	g_slist_append (list_connection, (gpointer)server_account_name);
+	modest_account_mgr_remove_connection_specific_smtp (self, connection_name);
 	
-	/* Reset the changed list: */
-	modest_account_mgr_set_list (self, account_name, 
-							MODEST_ACCOUNT_CONNECTION_SPECIFIC_SMTP_LIST, list,
-						    MODEST_CONF_VALUE_STRING, TRUE);
+	ModestConf *conf = MODEST_ACCOUNT_MGR_GET_PRIVATE (self)->modest_conf;
+
+	gboolean result = TRUE;
+	GError *err = NULL;
+	GSList *list = 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;
+		result = FALSE;
+	} else {	
+		/* The server account is in the item after the connection name: */
+		GSList *list_connection = g_slist_append (list, (gpointer)connection_name);
+		list_connection = g_slist_append (list_connection, (gpointer)server_account_name);
+	
+		/* Reset the changed list: */
+		modest_conf_set_list (conf, MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST, list_connection,
+						    MODEST_CONF_VALUE_STRING, &err);
+		if (err) {
+			g_printerr ("modest: %s: error setting list: %s.\n", __FUNCTION__, err->message);
+			g_error_free (err);
+			result = FALSE;
+		}
+	}
 				
 	/* TODO: Should we free the items too, or just the list? */
 	g_slist_free (list);
 	
-	return TRUE;
+	return result;
 }
 
 /**
@@ -158,61 +137,117 @@ gboolean modest_account_mgr_set_connection_specific_smtp (ModestAccountMgr *self
  * Returns: TRUE if it worked, FALSE otherwise
  */				 
 gboolean modest_account_mgr_remove_connection_specific_smtp (ModestAccountMgr *self, 
-	const gchar* account_name, const gchar* connection_name)
+	const gchar* connection_name)
 {
-	GSList *list = modest_account_mgr_get_list (self, account_name, 
-							MODEST_ACCOUNT_CONNECTION_SPECIFIC_SMTP_LIST,
-						    MODEST_CONF_VALUE_STRING, TRUE);
+	ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+	
+	gboolean result = TRUE;
+	GError *err = NULL;
+	GSList *list = modest_conf_get_list (priv->modest_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;
+		result = FALSE;
+	}
+
 	if (!list)
 		return FALSE;
 		
 	/* The server account is in the item after the connection name: */
 	GSList *list_connection = g_slist_find_custom (list, connection_name, (GCompareFunc)strcmp);
 	if (list_connection) {
+		GSList *account_node = g_slist_next (list_connection);
 		/* remove both items: */
-		GSList *temp = g_slist_delete_link(list_connection, list_connection);
-		g_slist_delete_link(temp, g_slist_next(temp));
+		list = g_slist_delete_link(list, list_connection);
+		list = g_slist_delete_link(list, account_node);
 	}
 	
 	/* Reset the changed list: */
-	modest_account_mgr_set_list (self, account_name, 
-							MODEST_ACCOUNT_CONNECTION_SPECIFIC_SMTP_LIST, list,
-						    MODEST_CONF_VALUE_STRING, TRUE);
+	modest_conf_set_list (priv->modest_conf, MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST, list,
+						    MODEST_CONF_VALUE_STRING, &err);
+	if (err) {
+		g_printerr ("modest: %s: error setting list: %s.\n", __FUNCTION__, err->message);
+		g_error_free (err);
+		result = FALSE;
+	}
 				
 	/* TODO: Should we free the items too, or just the list? */
 	g_slist_free (list);
 	
-	return TRUE;
+	return result;
+}
+
+
+gboolean modest_account_mgr_get_use_connection_specific_smtp (ModestAccountMgr *self, const gchar* account_name)
+{
+	return modest_account_mgr_get_bool (self, account_name, 
+		MODEST_ACCOUNT_USE_CONNECTION_SPECIFIC_SMTP, FALSE);
+}
+
+gboolean modest_account_mgr_set_use_connection_specific_smtp (ModestAccountMgr *self, const gchar* account_name, 
+	gboolean new_value)
+{
+	return modest_account_mgr_set_bool (self, account_name, MODEST_ACCOUNT_USE_CONNECTION_SPECIFIC_SMTP, 
+		new_value, FALSE);
 }
 
 /**
  * modest_account_mgr_get_connection_specific_smtp
  * @self: a ModestAccountMgr instance
- * @name: the account name
  * @connection_name: A libconic IAP connection name
  * 
  * Retrieve a server account to use with this specific connection for this account.
  *
  * Returns: a server account name to use for this connection, or NULL if none is specified.
  */			 
-gchar* modest_account_mgr_get_connection_specific_smtp (ModestAccountMgr *self, const gchar* account_name,
-					 const gchar* connection_name)
+gchar* modest_account_mgr_get_connection_specific_smtp (ModestAccountMgr *self,  const gchar* connection_name)
 {
 	gchar *result = NULL;
 	
-	GSList *list = modest_account_mgr_get_list (self, account_name, 
-							MODEST_ACCOUNT_CONNECTION_SPECIFIC_SMTP_LIST,
-						    MODEST_CONF_VALUE_STRING, TRUE);
+	ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+	
+	GError *err = NULL;
+	GSList *list = modest_conf_get_list (priv->modest_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;
+	}
+
 	if (!list)
 		return NULL;
-		
+
 	/* The server account is in the item after the connection name: */
-	GSList *list_connection = g_slist_find_custom (list, connection_name, (GCompareFunc)strcmp);
-	if (list_connection) {
-		GSList * list_server_account = g_slist_next(list_connection);
-		if (list_server_account)
-			result = g_strdup ((gchar*)(list_server_account->data));
+	GSList *iter = list;
+	while (iter) {
+		const gchar* this_connection_name = (const gchar*)(iter->data);
+		if (strcmp (this_connection_name, connection_name) == 0) {
+			iter = g_slist_next (iter);
+			
+			if (iter) {
+				const gchar* account_name = (const gchar*)(iter->data);
+				if (account_name) {
+					result = g_strdup (account_name);
+					break;
+				}
+			}
+		}
+		
+		/* Skip 2 to go to the next connection in the list: */
+		iter = g_slist_next (iter);
+		if (iter)
+			iter = g_slist_next (iter);
+	}
+		
+	/*
+	if (!result) {
+		printf ("  debug: no server found for connection_name=%s.\n", connection_name);	
 	}
+	*/
 				
 	/* TODO: Should we free the items too, or just the list? */
 	g_slist_free (list);
@@ -220,12 +255,106 @@ gchar* modest_account_mgr_get_connection_specific_smtp (ModestAccountMgr *self,
 	return result;
 }
 					 
-					 
+gchar*
+modest_account_mgr_get_server_account_username (ModestAccountMgr *self, const gchar* account_name)
+{
+	return modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_USERNAME, 
+		TRUE /* server account */);
+}
+
+void
+modest_account_mgr_set_server_account_username (ModestAccountMgr *self, const gchar* account_name, 
+	const gchar* username)
+{
+	/* Note that this won't work properly as long as the gconf cache is broken 
+	 * in Maemo Bora: */
+	gchar *existing_username = modest_account_mgr_get_server_account_username(self, 
+		account_name);
+	
+	modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_USERNAME, 
+		username, TRUE /* server account */);
+		
+	/* We don't know anything about new usernames: */
+	if (strcmp (existing_username, username) != 0)
+		modest_account_mgr_get_server_account_username_has_succeeded (self, account_name);
+		
+	g_free (existing_username);
+}
+
+gboolean
+modest_account_mgr_get_server_account_username_has_succeeded (ModestAccountMgr *self, const gchar* account_name)
+{
+	return modest_account_mgr_get_bool (self, account_name, MODEST_ACCOUNT_USERNAME_HAS_SUCCEEDED, 
+					    TRUE /* server account */);
+}
+
+void
+modest_account_mgr_set_server_account_username_has_succeeded (ModestAccountMgr *self, 
+						  const gchar* account_name, 
+						  gboolean succeeded)
+{
+	modest_account_mgr_set_bool (self, account_name, MODEST_ACCOUNT_USERNAME_HAS_SUCCEEDED, 
+				     succeeded, TRUE /* server account */);
+}
+
+void
+modest_account_mgr_set_server_account_password (ModestAccountMgr *self, const gchar* account_name, 
+				    const gchar* password)
+{
+	modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_PASSWORD, 
+				       password, TRUE /* server account */);
+}
+
+	
+gchar*
+modest_account_mgr_get_server_account_password (ModestAccountMgr *self, const gchar* account_name)
+{
+	return modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_PASSWORD, 
+		TRUE /* server account */);	
+}
+
+gboolean
+modest_account_mgr_get_server_account_has_password (ModestAccountMgr *self, const gchar* account_name)
+{
+	gboolean result = FALSE;
+	gchar *password = modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_PASSWORD, 
+		TRUE /* server account */);
+	if (password && strlen (password)) {
+		result = TRUE;
+	}
+	
+	g_free (password);
+	return result;
+}
+			 
+	
+gchar*
+modest_account_mgr_get_server_account_hostname (ModestAccountMgr *self, 
+						const gchar* account_name)
+{
+	return modest_account_mgr_get_string (self, 
+					      account_name, 
+					      MODEST_ACCOUNT_HOSTNAME, 
+					      TRUE /* server account */);
+}
+ 
+void
+modest_account_mgr_set_server_account_hostname (ModestAccountMgr *self, 
+						const gchar *server_account_name,
+						const gchar *hostname)
+{
+	modest_account_mgr_set_string (self, 
+				       server_account_name,
+				       MODEST_ACCOUNT_HOSTNAME, 
+				       hostname, 
+				       TRUE /* server account */);
+}
+
 
-static ModestProtocol
+static ModestAuthProtocol
 get_secure_auth_for_conf_string(const gchar* value)
 {
-	ModestProtocol result = MODEST_PROTOCOL_AUTH_NONE;
+	ModestAuthProtocol result = MODEST_PROTOCOL_AUTH_NONE;
 	if (value) {
 		if (strcmp(value, MODEST_ACCOUNT_AUTH_MECH_VALUE_NONE) == 0)
 			result = MODEST_PROTOCOL_AUTH_NONE;
@@ -238,11 +367,11 @@ get_secure_auth_for_conf_string(const gchar* value)
 	return result;
 }
 
-ModestProtocol
-modest_server_account_get_secure_auth (ModestAccountMgr *self, 
+ModestAuthProtocol
+modest_account_mgr_get_server_account_secure_auth (ModestAccountMgr *self, 
 	const gchar* account_name)
 {
-	ModestProtocol result = MODEST_PROTOCOL_AUTH_NONE;
+	ModestAuthProtocol result = MODEST_PROTOCOL_AUTH_NONE;
 	gchar* value = modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_AUTH_MECH, 
 		TRUE /* server account */);
 	if (value) {
@@ -256,8 +385,8 @@ modest_server_account_get_secure_auth (ModestAccountMgr *self,
 
 
 void
-modest_server_account_set_secure_auth (ModestAccountMgr *self, 
-	const gchar* account_name, ModestProtocol secure_auth)
+modest_account_mgr_set_server_account_secure_auth (ModestAccountMgr *self, 
+	const gchar* account_name, ModestAuthProtocol secure_auth)
 {
 	/* Get the conf string for the enum value: */
 	const gchar* str_value = NULL;
@@ -272,27 +401,28 @@ modest_server_account_set_secure_auth (ModestAccountMgr *self,
 	modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_AUTH_MECH, str_value, TRUE);
 }
 
-static ModestProtocol
+static ModestConnectionProtocol
 get_security_for_conf_string(const gchar* value)
 {
-	ModestProtocol result = MODEST_PROTOCOL_SECURITY_NONE;
+	ModestConnectionProtocol result = MODEST_PROTOCOL_CONNECTION_NORMAL;
 	if (value) {
 		if (strcmp(value, MODEST_ACCOUNT_SECURITY_VALUE_NONE) == 0)
-			result = MODEST_PROTOCOL_SECURITY_NONE;
-		else if (strcmp(value, MODEST_ACCOUNT_SECURITY_VALUE_NORMAL) == 0)
-			result = MODEST_PROTOCOL_SECURITY_TLS;
-		else if (strcmp(value, MODEST_ACCOUNT_SECURITY_VALUE_SSL) == 0)
-			result = MODEST_PROTOCOL_SECURITY_SSL;
+			result = MODEST_PROTOCOL_CONNECTION_NORMAL;
+		else if (strcmp(value, MODEST_ACCOUNT_SECURITY_VALUE_NORMAL) == 0) {
+			/* The UI has "Normal (TLS)": */
+			result = MODEST_PROTOCOL_CONNECTION_TLS;
+		} else if (strcmp(value, MODEST_ACCOUNT_SECURITY_VALUE_SSL) == 0)
+			result = MODEST_PROTOCOL_CONNECTION_SSL;
 	}
 	
 	return result;
 }
 
-ModestProtocol
-modest_server_account_get_security (ModestAccountMgr *self, 
+ModestConnectionProtocol
+modest_account_mgr_get_server_account_security (ModestAccountMgr *self, 
 	const gchar* account_name)
 {
-	ModestProtocol result = MODEST_PROTOCOL_SECURITY_NONE;
+	ModestConnectionProtocol result = MODEST_PROTOCOL_CONNECTION_NORMAL;
 	gchar* value = modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_SECURITY, 
 		TRUE /* server account */);
 	if (value) {
@@ -305,42 +435,24 @@ modest_server_account_get_security (ModestAccountMgr *self,
 }
 
 void
-modest_server_account_set_security (ModestAccountMgr *self, 
-	const gchar* account_name, ModestProtocol security)
+modest_account_mgr_set_server_account_security (ModestAccountMgr *self, 
+	const gchar* account_name, ModestConnectionProtocol security)
 {
 	/* Get the conf string for the enum value: */
 	const gchar* str_value = NULL;
-	if (security == MODEST_PROTOCOL_SECURITY_NONE)
+	if (security == MODEST_PROTOCOL_CONNECTION_NORMAL)
 		str_value = MODEST_ACCOUNT_SECURITY_VALUE_NONE;
-	else if (security == MODEST_PROTOCOL_SECURITY_TLS)
+	else if (security == MODEST_PROTOCOL_CONNECTION_TLS) {
+		/* The UI has "Normal (TLS)": */
 		str_value = MODEST_ACCOUNT_SECURITY_VALUE_NORMAL;
-	else if (security == MODEST_PROTOCOL_SECURITY_SSL)
+	} else if (security == MODEST_PROTOCOL_CONNECTION_SSL)
 		str_value = MODEST_ACCOUNT_SECURITY_VALUE_SSL;
 	
 	/* Set it in the configuration: */
 	modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_SECURITY, str_value, TRUE);
 }
-	             
-#if 0                     
-gchar*
-modest_account_mgr_get_server_account_option (ModestAccountMgr *self, 
-	const gchar* account_name, const gchar* option_name)
-{
-	GSList *option_list = modest_account_mgr_get_list (self, account_name, MODEST_ACCOUNT_OPTIONS,
-						     MODEST_CONF_VALUE_STRING, TRUE);
-	if (!option_list)
-		return NULL;
-		
-	gchar *result = modest_server_account_data_get_option_value (option_list, option_name);
-	
-	/* TODO: Should we free the items too, or just the list? */
-	g_slist_free (option_list);
-		
-	return result;
-}
-#endif
 
-static ModestServerAccountData*
+ModestServerAccountData*
 modest_account_mgr_get_server_account_data (ModestAccountMgr *self, const gchar* name)
 {
 	ModestServerAccountData *data;
@@ -353,7 +465,7 @@ modest_account_mgr_get_server_account_data (ModestAccountMgr *self, const gchar*
 	data->hostname     = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_HOSTNAME,TRUE);
 	data->username     = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_USERNAME,TRUE);	
 	proto              = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_PROTO, TRUE);
-	data->proto        = modest_protocol_info_get_protocol (proto);
+	data->proto        = modest_protocol_info_get_transport_store_protocol (proto);
 	g_free (proto);
 
 	data->port         = modest_account_mgr_get_int (self, name, MODEST_ACCOUNT_PORT, TRUE);
@@ -368,17 +480,13 @@ modest_account_mgr_get_server_account_data (ModestAccountMgr *self, const gchar*
 	
 	data->last_updated = modest_account_mgr_get_int    (self, name, MODEST_ACCOUNT_LAST_UPDATED,TRUE);
 	
-	data->password     = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_PASSWORD, TRUE);
-	data->uri          = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_URI,TRUE);
-	data->options = modest_account_mgr_get_list (self, name, MODEST_ACCOUNT_OPTIONS,
-						     MODEST_CONF_VALUE_STRING, TRUE);
-						   
+	data->password     = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_PASSWORD, TRUE);		   
 	
 	return data;
 }
 
 
-static void
+void
 modest_account_mgr_free_server_account_data (ModestAccountMgr *self,
 					     ModestServerAccountData* data)
 {
@@ -398,23 +506,15 @@ modest_account_mgr_free_server_account_data (ModestAccountMgr *self,
 
 	g_free (data->password);
 	data->password = NULL;
-	
-	if (data->options) {
-		GSList *tmp = data->options;
-		while (tmp) {
-			g_free (tmp->data);
-			tmp = g_slist_next (tmp);
-		}
-		g_slist_free (data->options);
-	}
 
 	g_slice_free (ModestServerAccountData, data);
 }
 
 /** You must use modest_account_mgr_free_account_data() on the result.
  */
-ModestAccountData*
-modest_account_mgr_get_account_data     (ModestAccountMgr *self, const gchar* name)
+ModestAccountData *
+modest_account_mgr_get_account_data (ModestAccountMgr *self, 
+				     const gchar* name)
 {
 	ModestAccountData *data;
 	gchar *server_account;
@@ -422,7 +522,13 @@ modest_account_mgr_get_account_data     (ModestAccountMgr *self, const gchar* na
 	
 	g_return_val_if_fail (self, NULL);
 	g_return_val_if_fail (name, NULL);
-	g_return_val_if_fail (modest_account_mgr_account_exists (self, name,FALSE), NULL);	
+	
+	if (!modest_account_mgr_account_exists (self, name, FALSE)) {
+		/* For instance, maybe you are mistakenly checking for a server account name? */
+		g_warning ("%s: Account %s does not exist.", __FUNCTION__, name);
+		return NULL;
+	}
+	
 	data = g_slice_new0 (ModestAccountData);
 	
 	data->account_name = g_strdup (name);
@@ -485,57 +591,63 @@ modest_account_mgr_free_account_data (ModestAccountMgr *self, ModestAccountData
 	g_slice_free (ModestAccountData, data);
 }
 
+gint 
+on_accounts_list_sort_by_title(gconstpointer a, gconstpointer b)
+{
+ 	return g_utf8_collate((const gchar*)a, (const gchar*)b);
+}
 
-gchar*
-modest_account_mgr_get_default_account  (ModestAccountMgr *self)
+/** Get the first one, alphabetically, by title. */
+gchar* 
+modest_account_mgr_get_first_account_name (ModestAccountMgr *self)
 {
-	gchar *account;	
-	ModestConf *conf;
-	GError *err = NULL;
-	
-	g_return_val_if_fail (self, NULL);
+	const gchar* account_name = NULL;
+	GSList *account_names = modest_account_mgr_account_names (self, TRUE /* only enabled */);
 
-	conf = MODEST_ACCOUNT_MGR_GET_PRIVATE (self)->modest_conf;
-	account = modest_conf_get_string (conf, MODEST_CONF_DEFAULT_ACCOUNT, &err);
-	
-	if (err) {
-		g_printerr ("modest: failed to get '%s': %s\n",
-			    MODEST_CONF_DEFAULT_ACCOUNT, err->message);
-		g_error_free (err);
-		g_free (account);
-		return  NULL;
-	}
-	
-	/* it's not really an error if there is no default account */
-	if (!account) 
+	/* Return TRUE if there is no account */
+	if (!account_names)
 		return NULL;
 
-	/* sanity check */
-	if (!modest_account_mgr_account_exists (self, account, FALSE)) {
-		g_printerr ("modest: default account does not exist\n");
-		g_free (account);
-		return NULL;
+	/* Get the first one, alphabetically, by title: */
+	/* gchar *old_default = modest_account_mgr_get_default_account (self); */
+	GSList* list_sorted = g_slist_sort (account_names, on_accounts_list_sort_by_title);
+
+	GSList* iter = list_sorted;
+	gboolean found = FALSE;
+	while (iter && !found) {
+		account_name = (const gchar*)list_sorted->data;
+
+		if (account_name)
+			found = TRUE;
+
+		if (!found)
+			iter = g_slist_next (iter);
 	}
 
-	return account;
-}
+	gchar* result = NULL;
+	if (account_name)
+		result = g_strdup (account_name);
+		
+	modest_account_mgr_free_account_names (account_names);
+	account_names = NULL;
 
+	return result;
+}
 
 gboolean
-modest_account_mgr_set_default_account  (ModestAccountMgr *self, const gchar* account)
+modest_account_mgr_set_first_account_as_default (ModestAccountMgr *self)
 {
-	ModestConf *conf;
-	
-	g_return_val_if_fail (self,    FALSE);
-	g_return_val_if_fail (account, FALSE);
-	g_return_val_if_fail (modest_account_mgr_account_exists (self, account, FALSE),
-			      FALSE);
+	gboolean result = FALSE;
 	
-	conf = MODEST_ACCOUNT_MGR_GET_PRIVATE (self)->modest_conf;
-		
-	return modest_conf_set_string (conf, MODEST_CONF_DEFAULT_ACCOUNT,
-				       account, NULL);
+	gchar* account_name = modest_account_mgr_get_first_account_name(self);
+	if (account_name) {
+		result = modest_account_mgr_set_default_account (self, account_name);
+		g_free (account_name);
+	}
+	else
+		result = TRUE; /* If there are no accounts then it's not a failure. */
 
+	return result;
 }
 
 gchar*
@@ -558,3 +670,240 @@ modest_account_mgr_get_from_string (ModestAccountMgr *self, const gchar* name)
 
 	return from;
 }
+
+/* Add a number to the end of the text, or increment a number that is already there.
+ */
+static gchar*
+util_increment_name (const gchar* text)
+{
+	/* Get the end character,
+	 * also doing a UTF-8 validation which is required for using g_utf8_prev_char().
+	 */
+	const gchar* end = NULL;
+	if (!g_utf8_validate (text, -1, &end))
+		return NULL;
+  
+  	if (!end)
+  		return NULL;
+  		
+  	--end; /* Go to before the null-termination. */
+  		
+  	/* Look at each UTF-8 characer, starting at the end: */
+  	const gchar* p = end;
+  	const gchar* alpha_end = NULL;
+  	while (p)
+  	{	
+  		/* Stop when we reach the first character that is not a numeric digit: */
+  		const gunichar ch = g_utf8_get_char (p);
+  		if (!g_unichar_isdigit (ch)) {
+  			alpha_end = p;
+  			break;
+  		}
+  		
+  		p = g_utf8_prev_char (p);	
+  	}
+  	
+  	if(!alpha_end) {
+  		/* The text must consist completely of numeric digits. */
+  		alpha_end = text;
+  	}
+  	else
+  		++alpha_end;
+  	
+  	/* Intepret and increment the number, if any: */
+  	gint num = atol (alpha_end);
+  	++num;
+  	
+	/* Get the name part: */
+  	gint name_len = alpha_end - text;
+  	gchar *name_without_number = g_malloc(name_len + 1);
+  	memcpy (name_without_number, text, name_len);
+  	name_without_number[name_len] = 0;\
+  	
+    /* Concatenate the text part and the new number: */	
+  	gchar *result = g_strdup_printf("%s%d", name_without_number, num);
+  	g_free (name_without_number);
+  	
+  	return result; 	
+}
+
+gchar*
+modest_account_mgr_get_unused_account_name (ModestAccountMgr *self, const gchar* starting_name,
+	gboolean server_account)
+{
+	gchar *account_name = g_strdup (starting_name);
+
+	while (modest_account_mgr_account_exists (self, 
+		account_name, server_account /*  server_account */)) {
+			
+		gchar * account_name2 = util_increment_name (account_name);
+		g_free (account_name);
+		account_name = account_name2;
+	}
+	
+	return account_name;
+}
+
+gchar*
+modest_account_mgr_get_unused_account_display_name (ModestAccountMgr *self, const gchar* starting_name)
+{
+	gchar *account_name = g_strdup (starting_name);
+
+	while (modest_account_mgr_account_with_display_name_exists (self, account_name)) {
+			
+		gchar * account_name2 = util_increment_name (account_name);
+		g_free (account_name);
+		account_name = account_name2;
+	}
+	
+	return account_name;
+}
+
+void 
+modest_account_mgr_set_leave_on_server (ModestAccountMgr *self, 
+					const gchar *account_name, 
+					gboolean leave_on_server)
+{
+	modest_account_mgr_set_bool (self, 
+				     account_name,
+				     MODEST_ACCOUNT_LEAVE_ON_SERVER, 
+				     leave_on_server, 
+				     FALSE);
+}
+
+gboolean 
+modest_account_mgr_get_leave_on_server (ModestAccountMgr *self, 
+					const gchar* account_name)
+{
+	return modest_account_mgr_get_bool (self, 
+					    account_name,
+					    MODEST_ACCOUNT_LEAVE_ON_SERVER, 
+					    FALSE);
+}
+
+gint 
+modest_account_mgr_get_last_updated (ModestAccountMgr *self, 
+				     const gchar* account_name)
+{
+	return modest_account_mgr_get_int (modest_runtime_get_account_mgr (), 
+					   account_name, 
+					   MODEST_ACCOUNT_LAST_UPDATED, 
+					   TRUE);
+}
+
+void 
+modest_account_mgr_set_last_updated (ModestAccountMgr *self, 
+				     const gchar* account_name,
+				     gint time)
+{
+	modest_account_mgr_set_int (self, 
+				    account_name, 
+				    MODEST_ACCOUNT_LAST_UPDATED, 
+				    time, 
+				    TRUE);
+
+	/* TODO: notify about changes */
+}
+
+gint  
+modest_account_mgr_get_retrieve_limit (ModestAccountMgr *self, 
+				       const gchar* account_name)
+{
+	return modest_account_mgr_get_int (self, 
+					   account_name,
+					   MODEST_ACCOUNT_LIMIT_RETRIEVE, 
+					   FALSE);
+}
+
+void  
+modest_account_mgr_set_retrieve_limit (ModestAccountMgr *self, 
+				       const gchar* account_name,
+				       gint limit_retrieve)
+{
+	modest_account_mgr_set_int (self, 
+				    account_name,
+				    MODEST_ACCOUNT_LIMIT_RETRIEVE, 
+				    limit_retrieve, 
+				    FALSE /* not server account */);
+}
+
+gint  
+modest_account_mgr_get_server_account_port (ModestAccountMgr *self, 
+					    const gchar* account_name)
+{
+	return modest_account_mgr_get_int (self, 
+					   account_name,
+					   MODEST_ACCOUNT_PORT, 
+					   TRUE);
+}
+
+void
+modest_account_mgr_set_server_account_port (ModestAccountMgr *self, 
+					    const gchar *account_name,
+					    gint port_num)
+{
+	modest_account_mgr_set_int (self, 
+				    account_name,
+				    MODEST_ACCOUNT_PORT, 
+				    port_num, TRUE /* server account */);
+}
+
+gchar* 
+modest_account_mgr_get_server_account_name (ModestAccountMgr *self, 
+					    const gchar *account_name,
+					    TnyAccountType account_type)
+{
+	return modest_account_mgr_get_string (self, 
+					      account_name,
+					      (account_type == TNY_ACCOUNT_TYPE_STORE) ?
+					      MODEST_ACCOUNT_STORE_ACCOUNT :
+					      MODEST_ACCOUNT_TRANSPORT_ACCOUNT, 
+					      FALSE);
+}
+
+gchar* 
+modest_account_mgr_get_retrieve_type (ModestAccountMgr *self, 
+				      const gchar *account_name)
+{
+	return modest_account_mgr_get_string (self, 
+					      account_name,
+					      MODEST_ACCOUNT_RETRIEVE, 
+					      FALSE /* not server account */);
+}
+
+void 
+modest_account_mgr_set_retrieve_type (ModestAccountMgr *self, 
+				      const gchar *account_name,
+				      const gchar *retrieve_type)
+{
+	modest_account_mgr_set_string (self, 
+				       account_name,
+				       MODEST_ACCOUNT_RETRIEVE, 
+				       retrieve_type, 
+				       FALSE /* not server account */);
+}
+
+
+void
+modest_account_mgr_set_user_fullname (ModestAccountMgr *self, 
+				      const gchar *account_name,
+				      const gchar *fullname)
+{
+	modest_account_mgr_set_string (self, 
+				       account_name,
+				       MODEST_ACCOUNT_FULLNAME, 
+				       fullname, 
+				       FALSE /* not server account */);
+}
+
+void
+modest_account_mgr_set_user_email (ModestAccountMgr *self, 
+				   const gchar *account_name,
+				   const gchar *email)
+{
+	modest_account_mgr_set_string (self, 
+				       account_name,
+				       MODEST_ACCOUNT_EMAIL, 
+				       email, 
+				       FALSE /* not server account */);
+}