X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;f=src%2Fmodest-account-mgr.c;h=4b097442e391638445df2148b0eec1dd62125ff8;hb=d9d3ab7c86ed86701f468ff8d1e1fac33b850431;hp=4532bd79940b194528744d3c3361be1c7b440d0a;hpb=fd28b26762263a91dc396eb76fc343b130587cfa;p=modest

diff --git a/src/modest-account-mgr.c b/src/modest-account-mgr.c
index 4532bd7..4b09744 100644
--- a/src/modest-account-mgr.c
+++ b/src/modest-account-mgr.c
@@ -3,127 +3,241 @@
 /* insert (c)/licensing information) */
 
 #include <string.h>
+#include "modest-marshal.h"
+#include "modest-account-keys.h"
 #include "modest-account-mgr.h"
 
 /* 'private'/'protected' functions */
-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_class_init (ModestAccountMgrClass * klass);
+static void modest_account_mgr_init (ModestAccountMgr * obj);
+static void modest_account_mgr_finalize (GObject * obj);
 
-static gchar*   get_account_keyname (const gchar *accname, const gchar *name);
-static gchar*   get_server_account_keyname (const gchar *accname, const gchar *name);
+static gchar *get_account_keyname (const gchar * accname, const gchar * name);
+static gchar *get_server_account_keyname (const gchar * accname,
+					  const gchar * name);
 
 /* list my signals */
 enum {
-	/* MY_SIGNAL_1, */
-	/* MY_SIGNAL_2, */
+	ACCOUNT_CHANGE_SIGNAL,
+	ACCOUNT_REMOVE_SIGNAL,
+	ACCOUNT_ADD_SIGNAL,
 	LAST_SIGNAL
 };
 
 typedef struct _ModestAccountMgrPrivate ModestAccountMgrPrivate;
 struct _ModestAccountMgrPrivate {
 	ModestConf *modest_conf;
+	GSList *current_accounts;
 };
+
 #define MODEST_ACCOUNT_MGR_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
                                                 MODEST_TYPE_ACCOUNT_MGR, \
                                                 ModestAccountMgrPrivate))
 /* globals */
 static GObjectClass *parent_class = NULL;
 
-/* uncomment the following if you have defined any signals */
-/* static guint signals[LAST_SIGNAL] = {0}; */
+static guint signals[LAST_SIGNAL] = {0};
+
+
+static GSList *
+delete_account_from_list (GSList *list, const gchar *name)
+{
+	GSList *iter, *result;
+
+	iter = list;
+	result = list;
+	while (iter) {
+		if (!strcmp (name, iter->data)) {
+			result = g_slist_delete_link (list, iter);
+			break;
+		}
+			
+		iter = g_slist_next (iter);
+	}
+	return result;
+}
+
+static GSList *
+find_account_in_list (GSList *list, const gchar *name)
+{
+	GSList *iter, *result;
+
+	iter = list;
+	result = list;
+	while (iter) {
+		if (!strcmp (name, iter->data)) {
+			return iter;
+			break;
+		}
+			
+		iter = g_slist_next (iter);
+	}
+	return NULL;
+}
+
+/* Map configuration changes to account changes.
+ * Doing this here makes sure all changes are available and external changes 
+ * are covered as well. */
+
+static void
+modest_account_mgr_check_change (ModestConf *conf, const gchar *key, 
+                                 const gchar *new_value, gpointer user_data)
+{
+	ModestAccountMgr *amgr = user_data;
+	ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (amgr);
+	
+	if ((strlen (key) > strlen (MODEST_SERVER_ACCOUNT_NAMESPACE "/") 
+	     && g_str_has_prefix (key, MODEST_SERVER_ACCOUNT_NAMESPACE))) {
+		gchar *subkey = key + strlen (MODEST_SERVER_ACCOUNT_NAMESPACE "/");
+		if (! strstr (subkey, "/")) {/* no more '/' means an account was modified */
+			if (new_value)	{
+				 /* covers only one case of two */
+				priv->current_accounts = 
+					g_slist_prepend (priv->current_accounts, g_strdup (subkey));
+				g_signal_emit (amgr, signals[ACCOUNT_ADD_SIGNAL], 0, subkey);
+			} else {
+				priv->current_accounts = 
+					delete_account_from_list (priv->current_accounts, subkey);
+					
+				g_signal_emit (amgr, signals[ACCOUNT_REMOVE_SIGNAL], 0, subkey);
+			}
+		} else {
+			gchar *param;
+			
+			param = strstr (subkey, "/");
+			param [0] = 0;
+			param++;
+			
+			/* that's the second case for a new account */
+			if (!find_account_in_list (priv->current_accounts, subkey)) {
+				priv->current_accounts = 
+					g_slist_prepend (priv->current_accounts, g_strdup (subkey));
+				g_signal_emit (amgr, signals[ACCOUNT_ADD_SIGNAL], 0, subkey);
+			}
+				
+			g_signal_emit (amgr, signals[ACCOUNT_CHANGE_SIGNAL], 0, subkey, param, new_value);
+		}
+	}	
+		
+	g_message ("value changed: %s %s\n", key, new_value);
+}
+
 
 GType
 modest_account_mgr_get_type (void)
 {
 	static GType my_type = 0;
+
 	if (!my_type) {
 		static const GTypeInfo my_info = {
-			sizeof(ModestAccountMgrClass),
-			NULL,		/* base init */
-			NULL,		/* base finalize */
+			sizeof (ModestAccountMgrClass),
+			NULL,	/* base init */
+			NULL,	/* base finalize */
 			(GClassInitFunc) modest_account_mgr_class_init,
-			NULL,		/* class finalize */
-			NULL,		/* class data */
-			sizeof(ModestAccountMgr),
-			1,		/* n_preallocs */
+			NULL,	/* class finalize */
+			NULL,	/* class data */
+			sizeof (ModestAccountMgr),
+			1,	/* n_preallocs */
 			(GInstanceInitFunc) modest_account_mgr_init,
 		};
 
 		my_type = g_type_register_static (G_TYPE_OBJECT,
-		                                  "ModestAccountMgr",
-		                                  &my_info, 0);
+						  "ModestAccountMgr",
+						  &my_info, 0);
 	}
 	return my_type;
 }
 
 static void
-modest_account_mgr_class_init (ModestAccountMgrClass *klass)
+modest_account_mgr_class_init (ModestAccountMgrClass * klass)
 {
 	GObjectClass *gobject_class;
-	gobject_class = (GObjectClass*) klass;
+	GType paramtypes[3] = {G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER};
+
+	gobject_class = (GObjectClass *) klass;
 
-	parent_class            = g_type_class_peek_parent (klass);
+	parent_class = g_type_class_peek_parent (klass);
 	gobject_class->finalize = modest_account_mgr_finalize;
 
-	g_type_class_add_private (gobject_class, sizeof(ModestAccountMgrPrivate));
+	g_type_class_add_private (gobject_class,
+				  sizeof (ModestAccountMgrPrivate));
 
-	/* signal definitions go here, e.g.: */
-/* 	signals[MY_SIGNAL_1] = */
-/* 		g_signal_new ("my_signal_1",....); */
-/* 	signals[MY_SIGNAL_2] = */
-/* 		g_signal_new ("my_signal_2",....); */
-/* 	etc. */
+	/* signal definitions */
+	signals[ACCOUNT_ADD_SIGNAL] = 
+ 		g_signal_newv ("account-add", 
+	                       G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+		               NULL, NULL, NULL,
+		               g_cclosure_marshal_VOID__POINTER,
+		               G_TYPE_NONE, 1, paramtypes);
+	
+	signals[ACCOUNT_REMOVE_SIGNAL] = 
+ 		g_signal_newv ("account-remove", 
+	                       G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+		               NULL, NULL, NULL,
+		               g_cclosure_marshal_VOID__POINTER,
+		               G_TYPE_NONE, 1, paramtypes);
+	signals[ACCOUNT_CHANGE_SIGNAL] = 
+ 		g_signal_newv ("account-change", 
+	                       G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+		               NULL, NULL, NULL,
+		               modest_marshal_VOID__POINTER_POINTER_POINTER,
+		               G_TYPE_NONE, 3, paramtypes);
 }
 
 
 static void
-modest_account_mgr_init (ModestAccountMgr *obj)
+modest_account_mgr_init (ModestAccountMgr * obj)
 {
- 	ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(obj);
- 	priv->modest_conf = NULL;
+	ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
+
+	priv->modest_conf = NULL;
 }
 
 static void
-modest_account_mgr_finalize (GObject *obj)
+modest_account_mgr_finalize (GObject * obj)
 {
-	ModestAccountMgr *self = MODEST_ACCOUNT_MGR(obj);
-	ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
+	ModestAccountMgr *self = MODEST_ACCOUNT_MGR (obj);
+	ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 
-	g_object_unref (G_OBJECT(priv->modest_conf));
-	priv->modest_conf = NULL;
+	if (priv->modest_conf) {
+		g_object_unref (G_OBJECT(priv->modest_conf));
+		priv->modest_conf = NULL;
+	}
 }
 
-GObject*
-modest_account_mgr_new (ModestConf *conf)
+GObject *
+modest_account_mgr_new (ModestConf * conf)
 {
 	GObject *obj;
 	ModestAccountMgrPrivate *priv;
 
 	g_return_val_if_fail (conf, NULL);
 
-	obj  = G_OBJECT(g_object_new(MODEST_TYPE_ACCOUNT_MGR, NULL));
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(obj);
+	obj = G_OBJECT (g_object_new (MODEST_TYPE_ACCOUNT_MGR, NULL));
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
 
 	/*
 	 * increase the ref count on the modest_conf. Normally, the
 	 * ModestConf should outlive the ModestAccountMgr though
 	 */
-	g_object_ref(G_OBJECT(priv->modest_conf = conf));
+	g_object_ref (G_OBJECT (priv->modest_conf = conf));
+	
+	priv->current_accounts = modest_account_mgr_account_names (MODEST_ACCOUNT_MGR(obj), NULL);
+	
+	g_signal_connect (G_OBJECT (conf), "key-changed", 
+	                  G_CALLBACK (modest_account_mgr_check_change), obj);
 	return obj;
 }
 
 
-
 gboolean
-modest_account_mgr_add_account (ModestAccountMgr *self, const gchar* name,
-				const gchar *store_account,
-				const gchar *transport_account,
-				GError **err)
+modest_account_mgr_add_account (ModestAccountMgr * self, const gchar * name,
+				const gchar * store_account,
+				const gchar * transport_account,
+				GError ** err)
 {
 	ModestAccountMgrPrivate *priv;
 	gchar *key;
-	gboolean retval;
 
 	g_return_val_if_fail (self, FALSE);
 	g_return_val_if_fail (name, FALSE);
@@ -136,31 +250,35 @@ modest_account_mgr_add_account (ModestAccountMgr *self, const gchar* name,
 	 * we create the account by adding an account 'dir', with the name <name>,
 	 * and in that the 'display_name' string key
 	 */
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 
 	key = get_account_keyname (name, MODEST_ACCOUNT_DISPLAY_NAME);
 	modest_conf_set_string (priv->modest_conf, key, name, err);
 	g_free (key);
 
 	if (store_account) {
-		key = get_account_keyname (name, MODEST_ACCOUNT_STORE_ACCOUNT);
-		modest_conf_set_string (priv->modest_conf, key, store_account, err);
+		key = get_account_keyname (name,
+					   MODEST_ACCOUNT_STORE_ACCOUNT);
+		modest_conf_set_string (priv->modest_conf, key, store_account,
+					err);
 		g_free (key);
 	}
 
 	if (transport_account) {
-		key = get_account_keyname (name, MODEST_ACCOUNT_TRANSPORT_ACCOUNT);
-		modest_conf_set_string (priv->modest_conf, key, transport_account, err);
+		key = get_account_keyname (name,
+					   MODEST_ACCOUNT_TRANSPORT_ACCOUNT);
+		modest_conf_set_string (priv->modest_conf, key,
+					transport_account, err);
 		g_free (key);
 	}
 
-	return TRUE; /* TODO: error handling */
+	return TRUE;		/* TODO: error handling */
 }
 
 
 gboolean
-modest_account_mgr_remove_account (ModestAccountMgr *self, const gchar* name,
-			   GError **err)
+modest_account_mgr_remove_account (ModestAccountMgr * self,
+				   const gchar * name, GError ** err)
 {
 	ModestAccountMgrPrivate *priv;
 	gchar *key;
@@ -174,7 +292,7 @@ modest_account_mgr_remove_account (ModestAccountMgr *self, const gchar* name,
 		return FALSE;
 	}
 
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 	key = get_account_keyname (name, NULL);
 
 	retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
@@ -184,20 +302,20 @@ modest_account_mgr_remove_account (ModestAccountMgr *self, const gchar* name,
 }
 
 
-static const gchar*
-null_means_empty(const gchar* str)
+static const gchar *
+null_means_empty (const gchar * str)
 {
 	return str ? str : "";
 }
 
 
 gboolean
-modest_account_mgr_add_server_account    (ModestAccountMgr *self,
-					  const gchar *name,
-					  const gchar *hostname,
-					  const gchar *username,
-					  const gchar *password,
-					  const gchar *proto)
+modest_account_mgr_add_server_account (ModestAccountMgr * self,
+				       const gchar * name,
+				       const gchar * hostname,
+				       const gchar * username,
+				       const gchar * password,
+				       const gchar * proto)
 {
 	ModestAccountMgrPrivate *priv;
 	gchar *acckey, *key;
@@ -207,62 +325,64 @@ modest_account_mgr_add_server_account    (ModestAccountMgr *self,
 
 	/* TODO: check already exists */
 
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 	acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 			      name, NULL);
 
-	if (modest_conf_key_exists(priv->modest_conf, acckey, NULL)) {
+	if (modest_conf_key_exists (priv->modest_conf, acckey, NULL)) {
 		g_warning ("server account %s already exists", name);
-		g_free (acckey);
-		return FALSE;
+		//g_free (acckey);
+		//return FALSE;
 	}
 
 	/* hostname */
 	key = g_strconcat (acckey, "/", MODEST_ACCOUNT_HOSTNAME, NULL);
 	modest_conf_set_string (priv->modest_conf, key,
-				null_means_empty(hostname), NULL);
+				null_means_empty (hostname), NULL);
 	g_free (key);
 
 	/* username */
 	key = g_strconcat (acckey, "/", MODEST_ACCOUNT_USERNAME, NULL);
 	modest_conf_set_string (priv->modest_conf, key,
-				null_means_empty(username), NULL);
+				null_means_empty (username), NULL);
 	g_free (key);
 
 	/* password */
-	key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PASSWORD, NULL);
-	modest_conf_set_string (priv->modest_conf, key,
-				null_means_empty(password), NULL);
-	g_free (key);
+	if (password) {
+		key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PASSWORD,
+				   NULL);
+		modest_conf_set_string (priv->modest_conf, key,
+					null_means_empty (password), NULL);
+		g_free (key);
+	}
 
 	/* proto */
 	key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PROTO, NULL);
 	modest_conf_set_string (priv->modest_conf, key,
-				null_means_empty(proto),
-				NULL);
+				null_means_empty (proto), NULL);
 	g_free (key);
+	g_free (acckey);
 
-	return TRUE; /* FIXME: better error checking */
+	return TRUE;		/* FIXME: better error checking */
 }
 
 gboolean
-modest_account_mgr_remove_server_account    (ModestAccountMgr *self,
-					     const gchar *name,
-					     GError **err)
+modest_account_mgr_remove_server_account (ModestAccountMgr * self,
+					  const gchar * name, GError ** err)
 {
 	ModestAccountMgrPrivate *priv;
-	gchar *acckey, *key;
+	gchar *acckey;
 	gboolean retval;
 
 	g_return_val_if_fail (self, FALSE);
 	g_return_val_if_fail (name, FALSE);
 
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 
 	acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 			      name, NULL);
 
-	if (!modest_conf_key_exists(priv->modest_conf, acckey, NULL)) {
+	if (!modest_conf_key_exists (priv->modest_conf, acckey, NULL)) {
 		g_warning ("server account %s does not exist exist", name);
 		g_free (acckey);
 		return FALSE;
@@ -275,47 +395,71 @@ modest_account_mgr_remove_server_account    (ModestAccountMgr *self,
 }
 
 
+/* strip the first /n/ character from each element */
+/* caller must make sure all elements are strings with
+ * length >= n, and also that data can be freed.
+ */
+static GSList *
+strip_prefix_from_elements (GSList * lst, guint n)
+{
+	GSList *cursor = lst;
 
+	while (cursor) {
+		gchar *str = (gchar *) cursor->data;
+
+		cursor->data = g_strdup (str + n);
+		g_free (str);
+		cursor = cursor->next;
+	}
+	return lst;
+}
 
-GSList*
-modest_account_mgr_server_account_names   (ModestAccountMgr *self,
-					   const gchar*    account_name,
-					   ModestProtoType type,
-					   const gchar*    proto,
-					   gboolean only_enabled)
+
+GSList *
+modest_account_mgr_server_account_names (ModestAccountMgr * self,
+					 const gchar * account_name,
+					 ModestProtoType type,
+					 const gchar * proto,
+					 gboolean only_enabled)
 {
 	GSList *accounts;
 	GSList *cursor;
 	ModestAccountMgrPrivate *priv;
+	const size_t prefix_len =
+		strlen (MODEST_SERVER_ACCOUNT_NAMESPACE "/");
 
 	g_return_val_if_fail (self, NULL);
 
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 	accounts = modest_conf_list_subkeys (priv->modest_conf,
 					     MODEST_SERVER_ACCOUNT_NAMESPACE,
 					     NULL);
 
 	/* no restrictions, return everything */
 	if (type == MODEST_PROTO_TYPE_ANY && !proto)
-		return accounts;
+		return strip_prefix_from_elements (accounts, prefix_len);
 
 	/* otherwise, filter out the none-matching ones */
 	cursor = accounts;
 	while (cursor) {
 		gchar *keyspace, *proto_key, *acc_proto;
 
-		keyspace  = (gchar*) cursor->data;
-		proto_key = g_strconcat (keyspace, "/", MODEST_ACCOUNT_PROTO, NULL);
-		acc_proto = modest_conf_get_string (priv->modest_conf, proto_key,
-						    NULL);
+		keyspace = (gchar *) cursor->data;
+		proto_key =
+			g_strconcat (keyspace, "/", MODEST_ACCOUNT_PROTO,
+				     NULL);
+		acc_proto =
+			modest_conf_get_string (priv->modest_conf, proto_key,
+						NULL);
 		g_free (proto_key);
 
-		if ((!acc_proto) ||                              /* proto not defined? */
-		    (type != MODEST_PROTO_TYPE_ANY &&            /* proto type ...     */
-		     modest_proto_type (acc_proto) != type) ||   /* ... matches?       */
-		    (proto && strcmp(proto,acc_proto) != 0)) {   /* proto matches?     */
+		if ((!acc_proto) ||	/* proto not defined? */
+		    (type != MODEST_PROTO_TYPE_ANY &&	/* proto type ...     */
+		     modest_proto_type (acc_proto) != type) ||	/* ... matches?       */
+		    (proto && strcmp (proto, acc_proto) != 0)) {	/* proto matches?     */
 			/* no match: remove from the list */
 			GSList *nxt = cursor->next;
+
 			g_free (acc_proto);
 			accounts = g_slist_delete_link (accounts, cursor);
 			cursor = nxt;
@@ -323,38 +467,37 @@ modest_account_mgr_server_account_names   (ModestAccountMgr *self,
 			cursor = cursor->next;
 	}
 
-	return accounts;
+	return strip_prefix_from_elements (accounts, prefix_len);
 }
 
 
-
-GSList*
-modest_account_mgr_account_names  (ModestAccountMgr *self, GError **err)
+GSList *
+modest_account_mgr_account_names (ModestAccountMgr * self, GError ** err)
 {
-	GSList *accounts, *cursor;
+	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);
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 
-	return  modest_conf_list_subkeys (priv->modest_conf,
-					  MODEST_ACCOUNT_NAMESPACE,
-					  err);
+	accounts = modest_conf_list_subkeys (priv->modest_conf,
+                                             MODEST_ACCOUNT_NAMESPACE, err);
+	return strip_prefix_from_elements (accounts, prefix_len);
 }
 
 
-
-static gchar*
-get_account_string (ModestAccountMgr *self, const gchar *name,
-		    const gchar *key, gboolean server_account,
-		    GError **err)
+static gchar *
+get_account_string (ModestAccountMgr * self, const gchar * name,
+		    const gchar * key, gboolean server_account, GError ** err)
 {
 	ModestAccountMgrPrivate *priv;
-	
+
 	gchar *keyname;
-	gchar * retval;
-	
+	gchar *retval;
+
 	g_return_val_if_fail (self, NULL);
 	g_return_val_if_fail (name, NULL);
 	g_return_val_if_fail (key, NULL);
@@ -364,37 +507,39 @@ get_account_string (ModestAccountMgr *self, const gchar *name,
 	else
 		keyname = get_account_keyname (name, key);
 
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
-	retval = modest_conf_get_string (priv->modest_conf,keyname,err);
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+	retval = modest_conf_get_string (priv->modest_conf, keyname, err);
 	g_free (keyname);
-	
+
 	return retval;
 }
 
 
-gchar*
-modest_account_mgr_get_server_account_string (ModestAccountMgr *self, const gchar *name,
-					   const gchar *key, GError **err)
+gchar *
+modest_account_mgr_get_server_account_string (ModestAccountMgr * self,
+					      const gchar * name,
+					      const gchar * key,
+					      GError ** err)
 {
 	return get_account_string (self, name, key, TRUE, err);
 }
 
-gchar*
-modest_account_mgr_get_account_string (ModestAccountMgr *self, const gchar *name,
-				    const gchar *key, GError **err)
+
+gchar *
+modest_account_mgr_get_account_string (ModestAccountMgr * self,
+				       const gchar * name, const gchar * key,
+				       GError ** err)
 {
 	return get_account_string (self, name, key, FALSE, err);
 }
 
 
-
 static gint
-get_account_int (ModestAccountMgr *self, const gchar *name,
-		 const gchar *key, gboolean server_account,
-		 GError **err)
+get_account_int (ModestAccountMgr * self, const gchar * name,
+		 const gchar * key, gboolean server_account, GError ** err)
 {
 	ModestAccountMgrPrivate *priv;
-	
+
 	gchar *keyname;
 	gint retval;
 
@@ -407,83 +552,83 @@ get_account_int (ModestAccountMgr *self, const gchar *name,
 	else
 		keyname = get_account_keyname (name, key);
 
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
-	retval = modest_conf_get_int (priv->modest_conf,keyname,err);
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+	retval = modest_conf_get_int (priv->modest_conf, keyname, err);
 	g_free (keyname);
-	
+
 	return retval;
 }
 
 
 gint
-modest_account_mgr_get_server_account_int (ModestAccountMgr *self, const gchar *name,
-					   const gchar *key, GError **err)
+modest_account_mgr_get_server_account_int (ModestAccountMgr * self,
+					   const gchar * name,
+					   const gchar * key, GError ** err)
 {
 	return get_account_int (self, name, key, TRUE, err);
 }
 
+
 gint
-modest_account_mgr_get_account_int (ModestAccountMgr *self, const gchar *name,
-				    const gchar *key, GError **err)
+modest_account_mgr_get_account_int (ModestAccountMgr * self,
+				    const gchar * name, const gchar * key,
+				    GError ** err)
 {
 	return get_account_int (self, name, key, FALSE, err);
 }
 
 
-
 static gboolean
-get_account_bool (ModestAccountMgr *self, const gchar *name,
-		  const gchar *key, gboolean server_account,
-		  GError **err)
+get_account_bool (ModestAccountMgr * self, const gchar * name,
+		  const gchar * key, gboolean server_account, GError ** err)
 {
 	ModestAccountMgrPrivate *priv;
-	
+
 	gchar *keyname;
 	gboolean retval;
 
 	g_return_val_if_fail (self, -1);
 	g_return_val_if_fail (name, -1);
 	g_return_val_if_fail (key, -1);
-	
+
 	if (server_account)
 		keyname = get_server_account_keyname (name, key);
 	else
 		keyname = get_account_keyname (name, key);
 
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
-	retval = modest_conf_get_int (priv->modest_conf,keyname,err);
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+	retval = modest_conf_get_int (priv->modest_conf, keyname, err);
 	g_free (keyname);
-	
+
 	return retval;
 }
 
 
-
 gint
-modest_account_mgr_get_server_account_bool (ModestAccountMgr *self, const gchar *name,
-					   const gchar *key, GError **err)
+modest_account_mgr_get_server_account_bool (ModestAccountMgr * self,
+					    const gchar * name,
+					    const gchar * key, GError ** err)
 {
 	return get_account_bool (self, name, key, TRUE, err);
 }
 
+
 gint
-modest_account_mgr_get_account_bool (ModestAccountMgr *self, const gchar *name,
-				    const gchar *key, GError **err)
+modest_account_mgr_get_account_bool (ModestAccountMgr * self,
+				     const gchar * name, const gchar * key,
+				     GError ** err)
 {
 	return get_account_bool (self, name, key, FALSE, err);
 }
 
 
-
-
-
 static gboolean
-set_account_string  (ModestAccountMgr *self, const gchar *name,
-		     const gchar *key, const gchar* val, gboolean server_account,
-		     GError **err)
+set_account_string (ModestAccountMgr * self, const gchar * name,
+		    const gchar * key, const gchar * val,
+		    gboolean server_account, GError ** err)
 {
 	ModestAccountMgrPrivate *priv;
-	
+
 	gchar *keyname;
 	gboolean retval;
 
@@ -496,47 +641,46 @@ set_account_string  (ModestAccountMgr *self, const gchar *name,
 	else
 		keyname = get_account_keyname (name, key);
 
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 
-	retval = modest_conf_set_string (priv->modest_conf,keyname,val,err);
+	retval = modest_conf_set_string (priv->modest_conf, keyname, val,
+					 err);
 
 	g_free (keyname);
 	return retval;
 }
 
 
-
-
-
 gboolean
-modest_account_mgr_set_server_account_string  (ModestAccountMgr *self, const gchar *name,
-					       const gchar *key, const gchar* val,
-					       GError **err)
+modest_account_mgr_set_server_account_string (ModestAccountMgr * self,
+					      const gchar * name,
+					      const gchar * key,
+					      const gchar * val,
+					      GError ** err)
 {
 	return set_account_string (self, name, key, val, TRUE, err);
 }
 
 
-
 gboolean
-modest_account_mgr_set_account_string  (ModestAccountMgr *self, const gchar *name,
-					const gchar *key, const gchar* val,
-					GError **err)
+modest_account_mgr_set_account_string (ModestAccountMgr * self,
+				       const gchar * name, const gchar * key,
+				       const gchar * val, GError ** err)
 {
 	return set_account_string (self, name, key, val, FALSE, err);
 }
 
 
 static gboolean
-set_account_int  (ModestAccountMgr *self, const gchar *name,
-		  const gchar *key, gboolean server_account, int val,
-		  GError **err)
+set_account_int (ModestAccountMgr * self, const gchar * name,
+		 const gchar * key, gboolean server_account, int val,
+		 GError ** err)
 {
 	ModestAccountMgrPrivate *priv;
-	
+
 	gchar *keyname;
 	gboolean retval;
-	
+
 	g_return_val_if_fail (self, FALSE);
 	g_return_val_if_fail (name, FALSE);
 	g_return_val_if_fail (key, FALSE);
@@ -546,58 +690,56 @@ set_account_int  (ModestAccountMgr *self, const gchar *name,
 	else
 		keyname = get_account_keyname (name, key);
 
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
-	
-	retval = modest_conf_set_int (priv->modest_conf,keyname,val,err);
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+
+	retval = modest_conf_set_int (priv->modest_conf, keyname, val, err);
 
 	g_free (keyname);
 	return retval;
 }
 
 
-
 gboolean
-modest_account_mgr_set_server_account_int (ModestAccountMgr *self, const gchar *name,
-					   const gchar *key, int val,
-					   GError **err)
+modest_account_mgr_set_server_account_int (ModestAccountMgr * self,
+					   const gchar * name,
+					   const gchar * key, int val,
+					   GError ** err)
 {
 	return set_account_int (self, name, key, val, TRUE, err);
 }
 
 
 gboolean
-modest_account_mgr_set_account_int  (ModestAccountMgr *self, const gchar *name,
-				     const gchar *key, int val,
-				     GError **err)
+modest_account_mgr_set_account_int (ModestAccountMgr * self,
+				    const gchar * name, const gchar * key,
+				    int val, GError ** err)
 {
 	return set_account_int (self, name, key, val, FALSE, err);
 }
 
 
-
-
 static gboolean
-set_account_bool  (ModestAccountMgr *self, const gchar *name,
-		   const gchar *key, gboolean server_account, gboolean val,
-		   GError **err)
+set_account_bool (ModestAccountMgr * self, const gchar * name,
+		  const gchar * key, gboolean server_account, gboolean val,
+		  GError ** err)
 {
 	ModestAccountMgrPrivate *priv;
-	
+
 	gchar *keyname;
 	gboolean retval;
-	
+
 	g_return_val_if_fail (self, FALSE);
 	g_return_val_if_fail (name, FALSE);
 	g_return_val_if_fail (key, FALSE);
-	
+
 	if (server_account)
 		keyname = get_server_account_keyname (name, key);
 	else
 		keyname = get_account_keyname (name, key);
-	
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
-	
-	retval = modest_conf_set_bool (priv->modest_conf,keyname,val,err);
+
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+
+	retval = modest_conf_set_bool (priv->modest_conf, keyname, val, err);
 
 	g_free (keyname);
 	return retval;
@@ -605,30 +747,27 @@ set_account_bool  (ModestAccountMgr *self, const gchar *name,
 
 
 gboolean
-modest_account_mgr_set_server_account_bool  (ModestAccountMgr *self, const gchar *name,
-					     const gchar *key, gboolean val,
-					     GError **err)
+modest_account_mgr_set_server_account_bool (ModestAccountMgr * self,
+					    const gchar * name,
+					    const gchar * key, gboolean val,
+					    GError ** err)
 {
 	return set_account_bool (self, name, key, val, TRUE, err);
 }
 
 
-
 gboolean
-modest_account_mgr_set_account_bool  (ModestAccountMgr *self, const gchar *name,
-					const gchar *key, gboolean val,
-					GError **err)
+modest_account_mgr_set_account_bool (ModestAccountMgr * self,
+				     const gchar * name, const gchar * key,
+				     gboolean val, GError ** err)
 {
 	return set_account_bool (self, name, key, val, FALSE, err);
 }
 
 
-
-
-
 gboolean
-account_exists (ModestAccountMgr *self, const gchar *name, gboolean server_account,
-		GError **err)
+account_exists (ModestAccountMgr * self, const gchar * name,
+		gboolean server_account, GError ** err)
 {
 	ModestAccountMgrPrivate *priv;
 
@@ -636,59 +775,59 @@ account_exists (ModestAccountMgr *self, const gchar *name, gboolean server_accou
 	gboolean retval;
 
 	g_return_val_if_fail (self, FALSE);
-	g_return_val_if_fail (name, FALSE);
+        g_return_val_if_fail (name, FALSE);
 
-	if (server_account) 
-		keyname = get_account_keyname (name, NULL);
-	else
+	if (server_account)
 		keyname = get_server_account_keyname (name, NULL);
+	else
+		keyname = get_account_keyname (name, NULL);
+
+	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+	retval = modest_conf_key_exists (priv->modest_conf, keyname, err);
 
-	priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
-	retval = modest_conf_key_exists (priv->modest_conf,keyname,err);
-	
 	g_free (keyname);
 	return retval;
 }
 
 
 gboolean
-modest_account_mgr_server_account_exists (ModestAccountMgr *self, const gchar *name,
-				   GError **err)
+modest_account_mgr_server_account_exists (ModestAccountMgr * self,
+					  const gchar * name, GError ** err)
 {
 	return account_exists (self, name, TRUE, err);
 }
 
 
-
 gboolean
-modest_account_mgr_account_exists (ModestAccountMgr *self, const gchar *name,
-				   GError **err)
+modest_account_mgr_account_exists (ModestAccountMgr * self,
+				   const gchar * name, GError ** err)
 {
 	return account_exists (self, name, FALSE, err);
 }
 
 
-
 /* must be freed by caller */
-static gchar*
-get_account_keyname (const gchar *accname, const gchar *name)
+static gchar *
+get_account_keyname (const gchar * accname, const gchar * name)
 {
 	if (name)
 		return g_strconcat
-			(accname, "/", name, NULL);
+			(MODEST_ACCOUNT_NAMESPACE, "/",
+			 accname, "/", name, NULL);
 	else
-		return g_strdup (accname);
+		return g_strconcat
+			(MODEST_ACCOUNT_NAMESPACE, "/", accname, NULL);
 }
 
 
 /* must be freed by caller */
-static gchar*
-get_server_account_keyname (const gchar *accname, const gchar *name)
+static gchar *
+get_server_account_keyname (const gchar * accname, const gchar * name)
 {
-	g_printf("get_server_account_keyname('%s', '%s')\n", accname, name);
 	if (name)
 		return g_strconcat
-			(MODEST_SERVER_ACCOUNT_NAMESPACE, "/", accname, "/", name, NULL);
+			(MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
+			 accname, "/", name, NULL);
 	else
 		return g_strconcat
 			(MODEST_SERVER_ACCOUNT_NAMESPACE, "/", accname, NULL);