X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmaemo%2Fmodest-account-settings-dialog.c;h=897b91e2da077f609366ad02add43da3b669ef8b;hp=c24a2d344039b6648cae9a18d30ebf7602b42295;hb=30ec701bc2d1c270022e3543994f0221f6fb8b8c;hpb=a2925c2f982d0b3ade08b13a700ce1b72342cdde

diff --git a/src/maemo/modest-account-settings-dialog.c b/src/maemo/modest-account-settings-dialog.c
index c24a2d3..897b91e 100644
--- a/src/maemo/modest-account-settings-dialog.c
+++ b/src/maemo/modest-account-settings-dialog.c
@@ -55,10 +55,7 @@
 #include "maemo/modest-signature-editor-dialog.h"
 #include "maemo/modest-maemo-utils.h"
 #include "widgets/modest-ui-constants.h"
-
-#include <tny-camel-transport-account.h>
-#include <tny-camel-imap-store-account.h>
-#include <tny-camel-pop-store-account.h>
+#include <tny-account.h>
 #include <tny-status.h>
 
 #include <gconf/gconf-client.h>
@@ -71,6 +68,9 @@
 
 #define EXAMPLE_EMAIL_ADDRESS "first.last@provider.com"
 
+#define PORT_MIN 1
+#define PORT_MAX 65535
+
 G_DEFINE_TYPE (ModestAccountSettingsDialog, modest_account_settings_dialog, GTK_TYPE_DIALOG);
 
 #define ACCOUNT_SETTINGS_DIALOG_GET_PRIVATE(o) \
@@ -139,12 +139,6 @@ modest_account_settings_dialog_finalize (GObject *object)
 }
 
 static void
-show_error (GtkWindow *parent_window, const gchar* text);
-
-static void
-show_ok (GtkWindow *parent_window, const gchar* text);
-
-static void
 on_combo_incoming_security_changed (GtkComboBox *widget, gpointer user_data);
 
 static void
@@ -171,21 +165,32 @@ on_modified_checkbox_toggled (GtkToggleButton *togglebutton, gpointer user_data)
 	self->modified = TRUE;
 }
 
+static void
+on_modified_number_editor_changed (HildonNumberEditor *number_editor, gint new_value, gpointer user_data)
+{
+	ModestAccountSettingsDialog *self = MODEST_ACCOUNT_SETTINGS_DIALOG (user_data);
+	self->modified = TRUE;
+}
+
 /* Set a modified boolean whenever the widget is changed, 
  * so we can check for it later.
  */
 static void
 connect_for_modified (ModestAccountSettingsDialog *self, GtkWidget *widget)
 {
-	if (GTK_IS_ENTRY (widget)) {
-	  g_signal_connect (G_OBJECT (widget), "changed",
-        	G_CALLBACK (on_modified_entry_changed), self);	
+	if (HILDON_IS_NUMBER_EDITOR (widget)) {
+		g_signal_connect (G_OBJECT (widget), "notify::value",
+			G_CALLBACK (on_modified_number_editor_changed), self);
+	}
+	else if (GTK_IS_ENTRY (widget)) {
+		g_signal_connect (G_OBJECT (widget), "changed",
+			G_CALLBACK (on_modified_entry_changed), self);
 	} else if (GTK_IS_COMBO_BOX (widget)) {
 		g_signal_connect (G_OBJECT (widget), "changed",
-        	G_CALLBACK (on_modified_combobox_changed), self);	
+        		G_CALLBACK (on_modified_combobox_changed), self);	
 	} else if (GTK_IS_TOGGLE_BUTTON (widget)) {
 		g_signal_connect (G_OBJECT (widget), "toggled",
-        	G_CALLBACK (on_modified_checkbox_toggled), self);
+			G_CALLBACK (on_modified_checkbox_toggled), self);
 	}
 }
 
@@ -246,26 +251,55 @@ static GtkWidget* create_caption_new_with_asterisk(ModestAccountSettingsDialog *
 	return caption;
 }
 
+static void
+on_entry_invalid_account_title_character (ModestValidatingEntry *self, const gchar* character, gpointer user_data)
+{
+	gchar *tmp, *msg;
+			
+	tmp = g_strndup (account_title_forbidden_chars, ACCOUNT_TITLE_FORBIDDEN_CHARS_LENGTH);
+	msg = g_strdup_printf (_CS("ckdg_ib_illegal_characters_entered"), tmp);
+
+	hildon_banner_show_information(GTK_WIDGET (self), NULL, msg);
+
+	g_free (msg);
+	g_free (tmp);
+}
+
+static void
+on_entry_invalid_fullname_character (ModestValidatingEntry *self, const gchar* character, gpointer user_data)
+{
+	gchar *tmp, *msg;
+			
+	tmp = g_strndup (user_name_forbidden_chars, USER_NAME_FORBIDDEN_CHARS_LENGTH);
+	msg = g_strdup_printf (_CS("ckdg_ib_illegal_characters_entered"), tmp);
+
+	hildon_banner_show_information(GTK_WIDGET (self), NULL, msg);
+
+	g_free (msg);
+	g_free (tmp);
+}
+
 
 static void
 on_entry_max (ModestValidatingEntry *self, gpointer user_data)
 {
-	ModestAccountSettingsDialog *dialog = MODEST_ACCOUNT_SETTINGS_DIALOG (user_data);
-	show_error (GTK_WINDOW (dialog), _("ckdg_ib_maximum_characters_reached"));
+	hildon_banner_show_information(GTK_WIDGET (self), NULL, 
+				       _CS("ckdg_ib_maximum_characters_reached"));
 }
 
 static GtkWidget*
 create_page_account_details (ModestAccountSettingsDialog *self)
 {
 	GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE);
-	GtkWidget *label = gtk_label_new(_("mcen_ia_accountdetails"));
-	gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, MODEST_MARGIN_HALF);
-	gtk_widget_show (label);
+	GtkAdjustment *focus_adjustment = NULL;
 	
 	/* Create a size group to be used by all captions.
 	 * Note that HildonCaption does not create a default size group if we do not specify one.
 	 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
 	GtkSizeGroup* sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
+	GtkWidget *scrollwin = gtk_scrolled_window_new (NULL, NULL);
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
+					GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
            
 	/* The description widgets: */	
 	self->entry_account_title = GTK_WIDGET (modest_validating_entry_new ());
@@ -287,8 +321,7 @@ create_page_account_details (ModestAccountSettingsDialog *self)
 	list_prevent = g_list_append (list_prevent, ":");
 	list_prevent = g_list_append (list_prevent, "*");
 	list_prevent = g_list_append (list_prevent, "?");
-	list_prevent = g_list_append (list_prevent, "\""); /* The UI spec mentions “, but maybe means ", maybe both. */
-	list_prevent = g_list_append (list_prevent, "“");
+	list_prevent = g_list_append (list_prevent, "\"");
 	list_prevent = g_list_append (list_prevent, "<"); 
 	list_prevent = g_list_append (list_prevent, ">"); 
 	list_prevent = g_list_append (list_prevent, "|");
@@ -296,6 +329,8 @@ create_page_account_details (ModestAccountSettingsDialog *self)
 	modest_validating_entry_set_unallowed_characters (
 	 	MODEST_VALIDATING_ENTRY (self->entry_account_title), list_prevent);
 	g_list_free (list_prevent);
+	modest_validating_entry_set_func(MODEST_VALIDATING_ENTRY(self->entry_account_title),
+					 on_entry_invalid_account_title_character, self);
 	
 	/* Set max length as in the UI spec:
 	 * The UI spec seems to want us to show a dialog if we hit the maximum. */
@@ -336,9 +371,40 @@ create_page_account_details (ModestAccountSettingsDialog *self)
 	
 	gtk_widget_show (GTK_WIDGET (box));
 	
-	return GTK_WIDGET (box);
+	gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrollwin), box);
+	gtk_widget_show (scrollwin);
+
+	focus_adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrollwin));
+	gtk_container_set_focus_vadjustment (GTK_CONTAINER (box), focus_adjustment); 
+	
+	return GTK_WIDGET (scrollwin);
+}
+
+static gchar*
+get_entered_account_title (ModestAccountSettingsDialog *dialog)
+{
+	const gchar* account_title = 
+		gtk_entry_get_text (GTK_ENTRY (dialog->entry_account_title));
+	if (!account_title || (strlen (account_title) == 0))
+		return NULL;
+	else {
+		/* Strip it of whitespace at the start and end: */
+		gchar *result = g_strdup (account_title);
+		result = g_strstrip (result);
+		
+		if (!result)
+			return NULL;
+			
+		if (strlen (result) == 0) {
+			g_free (result);
+			return NULL;	
+		}
+		
+		return result;
+	}
 }
 
+
 static void
 on_button_signature (GtkButton *button, gpointer user_data)
 {
@@ -351,10 +417,13 @@ on_button_signature (GtkButton *button, gpointer user_data)
 		gboolean use_signature = FALSE;
 		gchar *signature = modest_account_mgr_get_signature(self->account_manager, self->account_name, 
 			&use_signature);
-		const gchar* account_title = gtk_entry_get_text (GTK_ENTRY (self->entry_account_title));
+		gchar* account_title = get_entered_account_title (self);
 		modest_signature_editor_dialog_set_settings (
 			MODEST_SIGNATURE_EDITOR_DIALOG (self->signature_dialog), 
 			use_signature, signature, account_title);
+
+		g_free (account_title);
+		account_title = NULL;
 		g_free (signature);
 		signature = NULL;
 	}
@@ -379,14 +448,19 @@ static GtkWidget*
 create_page_user_details (ModestAccountSettingsDialog *self)
 {
 	GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE);
+	GtkAdjustment *focus_adjustment = NULL;
 	
 	/* Create a size group to be used by all captions.
 	 * Note that HildonCaption does not create a default size group if we do not specify one.
 	 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
 	GtkSizeGroup* sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
+	GtkWidget *scrollwin = gtk_scrolled_window_new (NULL, NULL);
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
+					GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 	 
 	/* The name widgets: */
 	self->entry_user_name = GTK_WIDGET (modest_validating_entry_new ());
+
 	/* Auto-capitalization is the default, so let's turn it off: */
 	hildon_gtk_entry_set_input_mode (GTK_ENTRY (self->entry_user_name), HILDON_GTK_INPUT_MODE_FULL);
 	/* Set max length as in the UI spec:
@@ -400,7 +474,8 @@ create_page_user_details (ModestAccountSettingsDialog *self)
 	connect_for_modified (self, self->entry_user_name);
 	gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF);
 	gtk_widget_show (caption);
-	
+
+
 	/* Prevent the use of some characters in the name, 
 	 * as required by our UI specification: */
 	GList *list_prevent = NULL;
@@ -409,6 +484,8 @@ create_page_user_details (ModestAccountSettingsDialog *self)
 	modest_validating_entry_set_unallowed_characters (
 	 	MODEST_VALIDATING_ENTRY (self->entry_user_name), list_prevent);
 	g_list_free (list_prevent);
+	modest_validating_entry_set_func(MODEST_VALIDATING_ENTRY(self->entry_user_name),
+					 on_entry_invalid_fullname_character, self);
 	
 	/* The username widgets: */	
 	self->entry_user_username = GTK_WIDGET (modest_validating_entry_new ());
@@ -478,8 +555,13 @@ create_page_user_details (ModestAccountSettingsDialog *self)
         	G_CALLBACK (on_button_signature), self);
         	
 	gtk_widget_show (GTK_WIDGET (box));
+	gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrollwin), box);
+	gtk_widget_show (scrollwin);
+
+	focus_adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrollwin));
+	gtk_container_set_focus_vadjustment (GTK_CONTAINER (box), focus_adjustment); 
 	
-	return GTK_WIDGET (box);
+	return GTK_WIDGET (scrollwin);
 }
 
 /** Change the caption title for the incoming server, 
@@ -562,9 +644,8 @@ static GtkWidget* create_page_incoming (ModestAccountSettingsDialog *self)
 	
 	
 	/* The port widgets: */
-	/* TODO: There are various rules about this in the UI spec. */
 	if (!self->entry_incoming_port)
-		self->entry_incoming_port = GTK_WIDGET (hildon_number_editor_new (0, 65535));
+		self->entry_incoming_port = GTK_WIDGET (hildon_number_editor_new (PORT_MIN, PORT_MAX));
 	caption = hildon_caption_new (sizegroup, _("mcen_fi_emailsetup_port"), 
 		self->entry_incoming_port, NULL, HILDON_CAPTION_OPTIONAL);
 	gtk_widget_show (self->entry_incoming_port);
@@ -618,14 +699,13 @@ on_button_outgoing_smtp_servers (GtkButton *button, gpointer user_data)
 	if (!(self->specific_window)) {
 		self->specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
 		modest_connection_specific_smtp_window_fill_with_connections (
-			MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (self->specific_window), self->account_manager, 
-			self->account_name);
+			MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (self->specific_window), self->account_manager);
 	}
 
 	/* Show the window: */	
 	gtk_window_set_transient_for (GTK_WINDOW (self->specific_window), GTK_WINDOW (self));
 	gtk_window_set_modal (GTK_WINDOW (self->specific_window), TRUE);
-    gtk_widget_show (self->specific_window);
+	gtk_widget_show (self->specific_window);
 }
 
 static void
@@ -676,6 +756,13 @@ on_combo_incoming_security_changed (GtkComboBox *widget, gpointer user_data)
 static GtkWidget* create_page_outgoing (ModestAccountSettingsDialog *self)
 {
 	GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE);
+	GtkAdjustment *focus_adjustment = NULL;
+	
+	/* Put it all in a scrolled window, so that all widgets can be 
+	 * accessed even when the on-screen keyboard is visible: */
+	GtkWidget *scrollwin = gtk_scrolled_window_new(NULL, NULL);
+	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), 
+		GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 	
 	/* Create a size group to be used by all captions.
 	 * Note that HildonCaption does not create a default size group if we do not specify one.
@@ -762,7 +849,7 @@ static GtkWidget* create_page_outgoing (ModestAccountSettingsDialog *self)
 	
 	/* The port widgets: */
 	if (!self->entry_outgoing_port)
-		self->entry_outgoing_port = GTK_WIDGET (hildon_number_editor_new (0, 65535));
+		self->entry_outgoing_port = GTK_WIDGET (hildon_number_editor_new (PORT_MIN, PORT_MAX));
 	caption = hildon_caption_new (sizegroup, _("mcen_fi_emailsetup_port"), 
 		self->entry_outgoing_port, NULL, HILDON_CAPTION_OPTIONAL);
 	gtk_widget_show (self->entry_outgoing_port);
@@ -805,16 +892,54 @@ static GtkWidget* create_page_outgoing (ModestAccountSettingsDialog *self)
         	G_CALLBACK (on_button_outgoing_smtp_servers), self);
 		
 	gtk_widget_show (GTK_WIDGET (box));
+	gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrollwin), box);
+	gtk_widget_show(scrollwin);
+
+	focus_adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrollwin));
+	gtk_container_set_focus_vadjustment (GTK_CONTAINER (box), focus_adjustment);
 	
-	return GTK_WIDGET (box);
+	return GTK_WIDGET (scrollwin);
+}
+
+
+/** TODO: This doesn't work because hildon_number_editor_get_value() does not work until 
+ * focus has been lost:
+ * See https://bugs.maemo.org/show_bug.cgi?id=1806.
+ */
+static gboolean
+check_hildon_number_editor_and_warn_value_not_in_range (HildonNumberEditor *widget, gint min, gint max)
+{
+	g_return_val_if_fail (widget, FALSE);
+	
+	const gint port = hildon_number_editor_get_value (widget);
+	/* printf ("DEBUG: %s, port=%d\n", __FUNCTION__, port); */
+	if (port < PORT_MIN || 
+		port > PORT_MAX) {
+			
+		/* Warn the user via a dialog: */
+		gchar *message = g_strdup_printf (_CS("ckct_ib_set_a_value_within_range"), 
+				       min, 
+				       max);
+		hildon_banner_show_information (GTK_WIDGET (widget), NULL, message);
+		g_free (message);
+		message = NULL;
+
+		/* Return focus to the email address entry: */
+		gtk_widget_grab_focus (GTK_WIDGET (widget));
+		
+		return FALSE;
+	}
+	
+	return TRUE;
 }
 
+	
 static gboolean
 check_data (ModestAccountSettingsDialog *self)
 {
 	/* Check that the title is not already in use: */
-	const gchar* account_title = gtk_entry_get_text (GTK_ENTRY (self->entry_account_title));
-	if ((!account_title) || (strlen(account_title) == 0))
+	gchar* account_title = get_entered_account_title (self);
+	if (!account_title)
 		return FALSE; /* Should be prevented already anyway. */
 		
 	if (strcmp(account_title, self->original_account_title) != 0) {
@@ -824,20 +949,24 @@ check_data (ModestAccountSettingsDialog *self)
 	
 		if (name_in_use) {
 			/* Warn the user via a dialog: */
-			show_error (GTK_WINDOW (self), _("mail_ib_account_name_already_existing"));
+			hildon_banner_show_information(NULL, NULL, _("mail_ib_account_name_already_existing"));
 	        
+	        g_free (account_title);
 			return FALSE;
 		}
 	}
+	
+	g_free (account_title);
+	account_title  = NULL;
 
-	/* Check that the email address is valud: */
+	/* Check that the email address is valid: */
 	const gchar* email_address = gtk_entry_get_text (GTK_ENTRY (self->entry_user_email));
-	if ((!email_address) || (strlen(email_address) == 0))
+	if ((!email_address) || (strlen(email_address) == 0)) {
 		return FALSE;
+	}
 			
-	if (!modest_text_utils_validate_email_address (email_address)) {
+	if (!modest_text_utils_validate_email_address (email_address, NULL)) {
 		/* Warn the user via a dialog: */
-		/*show_error (GTK_WINDOW (self), _("mcen_ib_invalid_email"));*/
 		hildon_banner_show_information (NULL, NULL, _("mcen_ib_invalid_email"));
                                          
 	        /* Return focus to the email address entry: */
@@ -845,11 +974,109 @@ check_data (ModestAccountSettingsDialog *self)
 		gtk_editable_select_region (GTK_EDITABLE (self->entry_user_email), 0, -1);
 		return FALSE;
 	}
+
+	/* make sure the domain name for the incoming server is valid */
+	const gchar* hostname = gtk_entry_get_text (GTK_ENTRY (self->entry_incomingserver));
+	if ((!hostname) || (strlen(hostname) == 0)) {
+		return FALSE;
+	}
+	
+	if (!modest_text_utils_validate_domain_name (hostname)) {
+		/* Warn the user via a dialog: */
+		hildon_banner_show_information (NULL, NULL, _("mcen_ib_invalid_servername"));
+                                         
+		/* Return focus to the email address entry: */
+        gtk_widget_grab_focus (self->entry_incomingserver);
+		gtk_editable_select_region (GTK_EDITABLE (self->entry_incomingserver), 0, -1);
+		return FALSE;
+	}
+
+	/* make sure the domain name for the outgoing server is valid */
+	const gchar* hostname2 = gtk_entry_get_text (GTK_ENTRY (self->entry_outgoingserver));
+	if ((!hostname2) || (strlen(hostname2) == 0)) {
+		return FALSE;
+	}
+	
+	if (!modest_text_utils_validate_domain_name (hostname2)) {
+		/* Warn the user via a dialog: */
+		hildon_banner_show_information (self->entry_outgoingserver, NULL, _("mcen_ib_invalid_servername"));
+
+		/* Return focus to the email address entry: */
+		gtk_widget_grab_focus (self->entry_outgoingserver);
+		gtk_editable_select_region (GTK_EDITABLE (self->entry_outgoingserver), 0, -1);
+		return FALSE;
+	}
+	
+	/* Check that the port numbers are acceptable: */
+	if (!check_hildon_number_editor_and_warn_value_not_in_range ( 
+		HILDON_NUMBER_EDITOR (self->entry_incoming_port), PORT_MIN, PORT_MAX)) {
+		return FALSE;
+	}
+		
+	if (!check_hildon_number_editor_and_warn_value_not_in_range ( 
+		HILDON_NUMBER_EDITOR (self->entry_outgoing_port), PORT_MIN, PORT_MAX)) {
+		return FALSE;
+	}
+
+		
+	/* Find a suitable authentication method when secure authentication is desired */
+
+	const gint port_num = hildon_number_editor_get_value (
+			HILDON_NUMBER_EDITOR (self->entry_incoming_port));
+	const gchar* username = gtk_entry_get_text (GTK_ENTRY (self->entry_user_username));
+
+	/*
+	const ModestConnectionProtocol protocol_security_incoming = modest_serversecurity_combo_box_get_active_serversecurity (
+		MODEST_SERVERSECURITY_COMBO_BOX (self->combo_incoming_security));
+	*/
+	/* If we use an encrypted protocol then there is no need to encrypt the password */
+	/* I don't think this is a good assumption. It overrides the user's request. murrayc: 
+	 *  if (!modest_protocol_info_is_secure(protocol_security_incoming)) */
+	if (TRUE)
+	{
+		if (gtk_toggle_button_get_active (
+				GTK_TOGGLE_BUTTON (self->checkbox_incoming_auth))) {
+			GError *error = NULL;
+
+			GList *list_auth_methods = 
+				modest_maemo_utils_get_supported_secure_authentication_methods (self->incoming_protocol, 
+					hostname, port_num, username, GTK_WINDOW (self), &error);
+			if (list_auth_methods) {
+				/* Use the first supported method.
+				 * TODO: Should we prioritize them, to prefer a particular one? */
+				GList* method;
+				for (method = list_auth_methods; method != NULL; method = g_list_next(method))
+				{
+					ModestAuthProtocol proto = (ModestAuthProtocol)(GPOINTER_TO_INT(method->data));
+					// Allow secure methods, e.g MD5 only
+					if (modest_protocol_info_auth_is_secure(proto))
+					{
+						self->protocol_authentication_incoming = proto;
+						break;
+					}
+				}
+				g_list_free (list_auth_methods);
+			}
+
+			if (list_auth_methods == NULL || 
+					!modest_protocol_info_auth_is_secure(self->protocol_authentication_incoming))
+			{
+		  		if(error == NULL || error->domain != modest_maemo_utils_get_supported_secure_authentication_error_quark() ||
+						error->code != MODEST_MAEMO_UTILS_GET_SUPPORTED_SECURE_AUTHENTICATION_ERROR_CANCELED)
+					hildon_banner_show_information(GTK_WIDGET (self), NULL, 
+								       _("Could not discover supported secure authentication methods."));
+
+				if(error != NULL)
+					g_error_free(error);
+					
+				/* This is a nasty hack. jschmid. */
+				/* Don't let the dialog close */
+				/*g_signal_stop_emission_by_name (dialog, "response");*/
+				return FALSE;
+			}
+		}
+	}
 	
-	/* TODO: The UI Spec wants us to check that the servernames are valid, 
-	 * but does not specify how.
-	 */
-	 
 	return TRUE;
 }
 /*
@@ -863,7 +1090,7 @@ on_response (GtkDialog *wizard_dialog,
 	enable_buttons (self);
 	
 	gboolean prevent_response = FALSE;
-	
+
 	/* Warn about unsaved changes: */
 	if (response_id == GTK_RESPONSE_CANCEL && self->modified) {
 		GtkDialog *dialog = GTK_DIALOG (hildon_note_new_confirmation (GTK_WINDOW (self), 
@@ -894,17 +1121,39 @@ on_response (GtkDialog *wizard_dialog,
 		{
 			const gboolean saved = save_configuration (self);
 			if (saved) {
-			/* Do not show the account-saved dialog if we are just saving this 
-			 * temporarily, because from the user's point of view it will not 
-			 * really be saved (saved + enabled) until later.
-			 */
-			const gboolean enabled = 
-				modest_account_mgr_get_enabled (self->account_manager, self->account_name);
-			if (enabled)
-				show_ok (GTK_WINDOW (self), _("mcen_ib_advsetup_settings_saved"));
+				/* Do not show the account-saved dialog if we are just saving this 
+				 * temporarily, because from the user's point of view it will not 
+				 * really be saved (saved + enabled) until later
+				 */
+				if (modest_account_mgr_get_enabled (self->account_manager, 
+								    self->account_name)) {
+					gchar *incoming_account_name = NULL, *outgoing_account_name = NULL;
+
+					incoming_account_name = 
+						modest_account_mgr_get_server_account_name (self->account_manager, 
+											    self->account_name,
+											    TNY_ACCOUNT_TYPE_STORE);
+					outgoing_account_name = 
+						modest_account_mgr_get_server_account_name (self->account_manager, 
+											    self->account_name,
+											    TNY_ACCOUNT_TYPE_TRANSPORT);
+
+					if (incoming_account_name) {
+						modest_account_mgr_notify_account_update (self->account_manager, 
+											  incoming_account_name);
+						g_free (incoming_account_name);
+					}
+					if (outgoing_account_name) {
+						modest_account_mgr_notify_account_update (self->account_manager, 
+											  outgoing_account_name);
+						g_free (outgoing_account_name);
+					}
+					
+					hildon_banner_show_information(NULL, NULL, _("mcen_ib_advsetup_settings_saved"));
+				}
+			} else {
+				hildon_banner_show_information (NULL, NULL, _("mail_ib_setting_failed"));
 			}
-			else
-				show_error (GTK_WINDOW (self), _("mail_ib_setting_failed"));
 		}
 	}
 }
@@ -914,7 +1163,7 @@ modest_account_settings_dialog_init (ModestAccountSettingsDialog *self)
 {
 	/* Create the notebook to be used by the GtkDialog base class:
 	 * Each page of the notebook will be a page of the wizard: */
-	GtkNotebook *notebook = GTK_NOTEBOOK (gtk_notebook_new());
+	self->notebook = GTK_NOTEBOOK (gtk_notebook_new());
 
 	/* Get the account manager object, 
 	 * so we can check for existing accounts,
@@ -923,6 +1172,8 @@ modest_account_settings_dialog_init (ModestAccountSettingsDialog *self)
 	g_assert (self->account_manager);
 	g_object_ref (self->account_manager);
 	
+	self->protocol_authentication_incoming = MODEST_PROTOCOL_AUTH_PASSWORD;
+
     /* Create the common pages, 
      */
 	self->page_account_details = create_page_account_details (self);
@@ -931,23 +1182,23 @@ modest_account_settings_dialog_init (ModestAccountSettingsDialog *self)
 	self->page_outgoing = create_page_outgoing (self);
 	
 	/* Add the notebook pages: */
-	gtk_notebook_append_page (notebook, self->page_account_details, 
+	gtk_notebook_append_page (self->notebook, self->page_account_details, 
 		gtk_label_new (_("mcen_ti_account_settings_account")));
-	gtk_notebook_append_page (notebook, self->page_user_details, 
+	gtk_notebook_append_page (self->notebook, self->page_user_details, 
 		gtk_label_new (_("mcen_ti_account_settings_userinfo")));
-	gtk_notebook_append_page (notebook, self->page_incoming,
+	gtk_notebook_append_page (self->notebook, self->page_incoming,
 		gtk_label_new (_("mcen_ti_advsetup_retrieval")));
-	gtk_notebook_append_page (notebook, self->page_outgoing,
+	gtk_notebook_append_page (self->notebook, self->page_outgoing,
 		gtk_label_new (_("mcen_ti_advsetup_sending")));
 		
 	GtkDialog *dialog = GTK_DIALOG (self);
-	gtk_container_add (GTK_CONTAINER (dialog->vbox), GTK_WIDGET (notebook));
+	gtk_container_add (GTK_CONTAINER (dialog->vbox), GTK_WIDGET (self->notebook));
 	gtk_container_set_border_width (GTK_CONTAINER (dialog->vbox), MODEST_MARGIN_HALF);
-	gtk_widget_show (GTK_WIDGET (notebook));
+	gtk_widget_show (GTK_WIDGET (self->notebook));
         
     /* Add the buttons: */
-    gtk_dialog_add_button (GTK_DIALOG(self), GTK_STOCK_OK, GTK_RESPONSE_OK);
-    gtk_dialog_add_button (GTK_DIALOG(self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
+    gtk_dialog_add_button (GTK_DIALOG(self), _("mcen_bd_dialog_ok"), GTK_RESPONSE_OK);
+    gtk_dialog_add_button (GTK_DIALOG(self), _("mcen_bd_dialog_cancel"), GTK_RESPONSE_CANCEL);
     
     /* Connect to the dialog's response signal: */
     /* We use connect-before 
@@ -958,11 +1209,14 @@ modest_account_settings_dialog_init (ModestAccountSettingsDialog *self)
             G_CALLBACK (on_response), self); 
             
     self->modified = FALSE;
-    
+
     /* When this window is shown, hibernation should not be possible, 
 	 * because there is no sensible way to save the state: */
     modest_window_mgr_prevent_hibernation_while_window_is_shown (
     	modest_runtime_get_window_mgr (), GTK_WINDOW (self)); 
+
+    hildon_help_dialog_help_enable (GTK_DIALOG(self), "applications_email_accountsettings",
+				    modest_maemo_utils_get_osso_context());
 }
 
 ModestAccountSettingsDialog*
@@ -1020,8 +1274,9 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo
 		
 	if (incoming_account)
 		modest_retrieve_combo_box_fill (MODEST_RETRIEVE_COMBO_BOX (dialog->combo_retrieve), incoming_account->proto);
-	gchar *retrieve = modest_account_mgr_get_string (dialog->account_manager, account_name,
-		MODEST_ACCOUNT_RETRIEVE, FALSE /* not server account */);
+
+
+	gchar *retrieve = modest_account_mgr_get_retrieve_type (dialog->account_manager, account_name);
 	if (!retrieve) {
 		/* Default to something, though no default is specified in the UI spec: */
 		retrieve = g_strdup (MODEST_ACCOUNT_RETRIEVE_VALUE_HEADERS_ONLY);
@@ -1029,13 +1284,11 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo
 	modest_retrieve_combo_box_set_active_retrieve_conf (MODEST_RETRIEVE_COMBO_BOX (dialog->combo_retrieve), retrieve);
 	g_free (retrieve);
 	
-	const gint limit_retrieve = modest_account_mgr_get_int (dialog->account_manager, account_name,
-		MODEST_ACCOUNT_LIMIT_RETRIEVE, FALSE /* not server account */);
+	const gint limit_retrieve = modest_account_mgr_get_retrieve_limit (dialog->account_manager, account_name);
 	modest_limit_retrieve_combo_box_set_active_limit_retrieve (MODEST_LIMIT_RETRIEVE_COMBO_BOX (dialog->combo_limit_retrieve), limit_retrieve);
 	
 	
-	const gboolean leave_on_server = modest_account_mgr_get_bool (dialog->account_manager, account_name,
-		MODEST_ACCOUNT_LEAVE_ON_SERVER, FALSE /* not server account */);
+	const gboolean leave_on_server = modest_account_mgr_get_leave_on_server (dialog->account_manager, account_name);
 	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->checkbox_leave_messages), leave_on_server);	
 	
 	/* Only show the leave-on-server checkbox for POP, 
@@ -1064,7 +1317,7 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo
     	 * If secure authentication is checked, require one of the secure methods during connection: SSL, TLS, CRAM-MD5 etc. 
 	  	 * TODO: Do we need to discover which of these (SSL, TLS, CRAM-MD5) is supported?
          */														 
-		const ModestConnectionProtocol security = modest_server_account_get_security (
+		const ModestConnectionProtocol security = modest_account_mgr_get_server_account_security (
 			dialog->account_manager, incoming_account->account_name);
 		modest_serversecurity_combo_box_set_active_serversecurity (
 			MODEST_SERVERSECURITY_COMBO_BOX (dialog->combo_incoming_security), security);
@@ -1074,25 +1327,24 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo
 		 OR
 		 - use encrypted passwords
 		*/
-		const ModestAuthProtocol secure_auth = modest_server_account_get_secure_auth(
+		const ModestAuthProtocol secure_auth = modest_account_mgr_get_server_account_secure_auth(
 			dialog->account_manager, incoming_account->account_name);
-		if (modest_protocol_info_is_secure(security) || 
-				modest_protocol_info_auth_is_secure(secure_auth))
+		dialog->protocol_authentication_incoming = secure_auth;
+		if (modest_protocol_info_auth_is_secure(secure_auth))
 		{
 			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dialog->checkbox_incoming_auth), 
-																	 TRUE);
+						     TRUE);
 		}
 		else
 		{
 			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dialog->checkbox_incoming_auth), 
-																	 FALSE);
+						     FALSE);
 		};
 					
 		update_incoming_server_title (dialog, incoming_account->proto);
 		
-		const gint port_num = modest_account_mgr_get_int (dialog->account_manager, incoming_account->account_name,
-			MODEST_ACCOUNT_PORT, TRUE /* server account */);
-			
+		const gint port_num = modest_account_mgr_get_server_account_port (dialog->account_manager, 
+										  incoming_account->account_name);
 		if (port_num == 0) {
 			/* Show the appropriate port number: */
 			on_combo_incoming_security_changed (
@@ -1119,7 +1371,7 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo
 			outgoing_account->password ? outgoing_account->password : "");
 		
 		/* Get the secure-auth setting: */
-		const ModestAuthProtocol secure_auth = modest_server_account_get_secure_auth(
+		const ModestAuthProtocol secure_auth = modest_account_mgr_get_server_account_secure_auth(
 			dialog->account_manager, outgoing_account->account_name);
 		modest_secureauth_combo_box_set_active_secureauth (
 			MODEST_SECUREAUTH_COMBO_BOX (dialog->combo_outgoing_auth), secure_auth);
@@ -1129,13 +1381,13 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo
 			MODEST_SERVERSECURITY_COMBO_BOX (dialog->combo_outgoing_security), outgoing_account->proto);
 		
 		/* Get the security setting: */
-		const ModestConnectionProtocol security = modest_server_account_get_security (
+		const ModestConnectionProtocol security = modest_account_mgr_get_server_account_security (
 			dialog->account_manager, outgoing_account->account_name);
 		modest_serversecurity_combo_box_set_active_serversecurity (
 			MODEST_SERVERSECURITY_COMBO_BOX (dialog->combo_outgoing_security), security);
 		
-		const gint port_num = modest_account_mgr_get_int (dialog->account_manager, outgoing_account->account_name,
-			MODEST_ACCOUNT_PORT, TRUE /* server account */);
+		const gint port_num = modest_account_mgr_get_server_account_port (dialog->account_manager, 
+										  outgoing_account->account_name);
 		if (port_num == 0) {
 			/* Show the appropriate port number: */
 			on_combo_outgoing_security_changed (
@@ -1149,9 +1401,8 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo
 		}
 		
 		const gboolean has_specific = 
-			modest_account_mgr_get_has_connection_specific_smtp (
-				dialog->account_manager, 
-				account_name);
+			modest_account_mgr_get_use_connection_specific_smtp (
+				dialog->account_manager, account_name);
 		gtk_toggle_button_set_active (
 			GTK_TOGGLE_BUTTON (dialog->checkbox_outgoing_smtp_specific), 
 			has_specific);
@@ -1182,6 +1433,24 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo
 	dialog->modified = FALSE;
 }
 
+/** Show the User Info tab.
+ */
+void modest_account_settings_dialog_switch_to_user_info (ModestAccountSettingsDialog *dialog)
+{
+	const gint page_num = gtk_notebook_page_num (dialog->notebook, dialog->page_user_details);
+	if (page_num == -1) {
+		g_warning ("%s: notebook page not found.\n", __FUNCTION__);	
+	}
+		
+	/* Ensure that the widget is visible so that gtk_notebook_set_current_page() works: */
+	/* TODO: even this hack (recommened by the GTK+ documentation) doesn't seem to work. */
+	
+	gtk_widget_show (dialog->page_user_details);
+	gtk_widget_show (GTK_WIDGET (dialog->notebook));
+	gtk_widget_show (GTK_WIDGET (dialog));
+	gtk_notebook_set_current_page (dialog->notebook, page_num);
+}
+
 static gboolean
 save_configuration (ModestAccountSettingsDialog *dialog)
 {
@@ -1190,69 +1459,60 @@ save_configuration (ModestAccountSettingsDialog *dialog)
 	const gchar* account_name = dialog->account_name;
 		
 	/* Set the account data from the widgets: */
-	const gchar* user_name = gtk_entry_get_text (GTK_ENTRY (dialog->entry_user_name));
-	gboolean test = modest_account_mgr_set_string (dialog->account_manager, account_name,
-		MODEST_ACCOUNT_FULLNAME, user_name, FALSE /* not server account */);
-	if (!test)
-		return FALSE;
-		
+	const gchar* user_fullname = gtk_entry_get_text (GTK_ENTRY (dialog->entry_user_name));
+	modest_account_mgr_set_user_fullname (dialog->account_manager, 
+					      account_name,
+					      user_fullname);
+	
 	const gchar* emailaddress = gtk_entry_get_text (GTK_ENTRY (dialog->entry_user_email));
-	test = modest_account_mgr_set_string (dialog->account_manager, account_name,
-		MODEST_ACCOUNT_EMAIL, emailaddress, FALSE /* not server account */);
-	if (!test)
-		return FALSE;
+	modest_account_mgr_set_user_email (dialog->account_manager, account_name,
+					   emailaddress);
 		
 	/* Signature: */
 	if (dialog->signature_dialog) {
 		gboolean use_signature = FALSE;
-    	gchar *signature = modest_signature_editor_dialog_get_settings (
-    		MODEST_SIGNATURE_EDITOR_DIALOG (dialog->signature_dialog),
-    		&use_signature);
+		gchar *signature = 
+			modest_signature_editor_dialog_get_settings (MODEST_SIGNATURE_EDITOR_DIALOG (dialog->signature_dialog),
+								     &use_signature);
     	
-    	modest_account_mgr_set_signature(dialog->account_manager, account_name, 
-    		signature, use_signature);
-    	g_free (signature);
-    }
+		modest_account_mgr_set_signature(dialog->account_manager, account_name, 
+						 signature, use_signature);		
+		g_free (signature);
+	}
 	
 	gchar *retrieve = modest_retrieve_combo_box_get_active_retrieve_conf (
 		MODEST_RETRIEVE_COMBO_BOX (dialog->combo_retrieve));
-	modest_account_mgr_set_string (dialog->account_manager, account_name,
-		MODEST_ACCOUNT_RETRIEVE, retrieve, FALSE /* not server account */);
+	modest_account_mgr_set_retrieve_type (dialog->account_manager, account_name, (const gchar*) retrieve);
 	g_free (retrieve);
 	
 	const gint limit_retrieve = modest_limit_retrieve_combo_box_get_active_limit_retrieve (
 		MODEST_LIMIT_RETRIEVE_COMBO_BOX (dialog->combo_limit_retrieve));
-	modest_account_mgr_set_int (dialog->account_manager, account_name,
-		MODEST_ACCOUNT_LIMIT_RETRIEVE, limit_retrieve, FALSE /* not server account */);
+	modest_account_mgr_set_retrieve_limit (dialog->account_manager, account_name, limit_retrieve);
 	
 	const gboolean leave_on_server = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->checkbox_leave_messages));
-	test = modest_account_mgr_set_bool (dialog->account_manager, account_name,
-		MODEST_ACCOUNT_LEAVE_ON_SERVER, leave_on_server, FALSE /* not server account */);
-	if (!test)
-		return FALSE;
+	modest_account_mgr_set_leave_on_server (dialog->account_manager, account_name, leave_on_server); 
 			
 	/* Incoming: */
-	gchar* incoming_account_name = modest_account_mgr_get_string (dialog->account_manager, account_name,
-		MODEST_ACCOUNT_STORE_ACCOUNT, FALSE /* not server account */);
+	gchar* incoming_account_name = 
+		modest_account_mgr_get_server_account_name (dialog->account_manager, 
+							    account_name, 
+							    TNY_ACCOUNT_TYPE_STORE);
 	g_assert (incoming_account_name);
 	
 	const gchar* hostname = gtk_entry_get_text (GTK_ENTRY (dialog->entry_incomingserver));
-	test = modest_account_mgr_set_string (dialog->account_manager, incoming_account_name,
-		MODEST_ACCOUNT_HOSTNAME, hostname, TRUE /* server account */);
-	if (!test)
-		return FALSE;
+	modest_account_mgr_set_server_account_hostname (dialog->account_manager, incoming_account_name, hostname);
 				
 	const gchar* username = gtk_entry_get_text (GTK_ENTRY (dialog->entry_user_username));
-	modest_server_account_set_username (dialog->account_manager, incoming_account_name, username);
+	modest_account_mgr_set_server_account_username (dialog->account_manager, incoming_account_name, username);
 	
 	const gchar* password = gtk_entry_get_text (GTK_ENTRY (dialog->entry_user_password));
-	modest_server_account_set_password (dialog->account_manager, incoming_account_name, password);
+	modest_account_mgr_set_server_account_password (dialog->account_manager, incoming_account_name,
+					    password);
 			
 	/* port: */
 	gint port_num = hildon_number_editor_get_value (
 			HILDON_NUMBER_EDITOR (dialog->entry_incoming_port));
-	modest_account_mgr_set_int (dialog->account_manager, incoming_account_name,
-			MODEST_ACCOUNT_PORT, port_num, TRUE /* server account */);
+	modest_account_mgr_set_server_account_port (dialog->account_manager, incoming_account_name, port_num);
 			
 	/* The UI spec says:
 	 * If secure authentication is unchecked, allow sending username and password also as plain text.
@@ -1261,113 +1521,68 @@ save_configuration (ModestAccountSettingsDialog *dialog)
 	
 	const ModestConnectionProtocol protocol_security_incoming = modest_serversecurity_combo_box_get_active_serversecurity (
 		MODEST_SERVERSECURITY_COMBO_BOX (dialog->combo_incoming_security));
-	modest_server_account_set_security (dialog->account_manager, incoming_account_name, protocol_security_incoming);
+	modest_account_mgr_set_server_account_security (dialog->account_manager, incoming_account_name, protocol_security_incoming);
 	
-	ModestAuthProtocol protocol_authentication_incoming = 
-			MODEST_PROTOCOL_AUTH_PASSWORD;
-	/* If we use an encrypted protocol then there is no need to encrypt the password */
-	if (!modest_protocol_info_is_secure(protocol_security_incoming))
-	{
-		if (gtk_toggle_button_get_active (
-				GTK_TOGGLE_BUTTON (dialog->checkbox_incoming_auth))) {
-			GError *error = NULL;
-			GList *list_auth_methods = 
-				modest_maemo_utils_get_supported_secure_authentication_methods (dialog->incoming_protocol, 
-					hostname, port_num, username, GTK_WINDOW (dialog), &error);
-			if (list_auth_methods) {
-				/* Use the first supported method.
-				 * TODO: Should we prioritize them, to prefer a particular one? */
-				GList* method;
-				for (method = list_auth_methods; method != NULL; method = g_list_next(method))
-				{
-					ModestAuthProtocol proto = (ModestAuthProtocol)(GPOINTER_TO_INT(list_auth_methods->data));
-					// Allow secure methods, e.g MD5 only
-					if (modest_protocol_info_auth_is_secure(proto))
-					{
-						protocol_authentication_incoming = proto;
-						break;
-					}
-				}
-				g_list_free (list_auth_methods);
-			}
-			if (list_auth_methods == NULL || 
-					!modest_protocol_info_auth_is_secure(protocol_authentication_incoming))
-		  {
-	      GtkWidget* error_dialog = gtk_message_dialog_new(GTK_WINDOW(dialog),
-	                                                       GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
-	                                                       GTK_BUTTONS_OK, (error != NULL) ? error->message : _("Server does not support secure authentication!"));
-	      if(error != NULL) g_error_free(error);
-	      gtk_dialog_run(GTK_DIALOG(error_dialog));
-	      gtk_widget_destroy(error_dialog);
-				/* This is a nasty hack. jschmid. */
-				/* Don't let the dialog close */
-	    	g_signal_stop_emission_by_name (dialog, "response");
-	      return FALSE;
-	    }
-		}
-	}
-	
-	modest_server_account_set_secure_auth (dialog->account_manager, incoming_account_name, protocol_authentication_incoming);
+	modest_account_mgr_set_server_account_secure_auth (dialog->account_manager, incoming_account_name, dialog->protocol_authentication_incoming);
 	
 		
 	g_free (incoming_account_name);
 	
 	/* Outgoing: */
-	gchar* outgoing_account_name = modest_account_mgr_get_string (dialog->account_manager, account_name,
-		MODEST_ACCOUNT_TRANSPORT_ACCOUNT, FALSE /* not server account */);
+	gchar* outgoing_account_name = 
+		modest_account_mgr_get_server_account_name (dialog->account_manager, 
+							    account_name,
+							    TNY_ACCOUNT_TYPE_TRANSPORT);
 	g_assert (outgoing_account_name);
 	
 	hostname = gtk_entry_get_text (GTK_ENTRY (dialog->entry_outgoingserver));
-	test = modest_account_mgr_set_string (dialog->account_manager, outgoing_account_name,
-		MODEST_ACCOUNT_HOSTNAME, hostname, TRUE /* server account */);
-	if (!test)
-		return FALSE;
+	modest_account_mgr_set_server_account_hostname (dialog->account_manager, outgoing_account_name, hostname);
 		
 	username = gtk_entry_get_text (GTK_ENTRY (dialog->entry_outgoing_username));
-	modest_server_account_set_username (dialog->account_manager, outgoing_account_name,
+	modest_account_mgr_set_server_account_username (dialog->account_manager, outgoing_account_name,
 		username);
 		
 	password = gtk_entry_get_text (GTK_ENTRY (dialog->entry_outgoing_password));
-	modest_server_account_set_password (dialog->account_manager, outgoing_account_name,
-		password);
+	modest_account_mgr_set_server_account_password (dialog->account_manager, outgoing_account_name,
+					    password);
 	
 	const ModestConnectionProtocol protocol_security_outgoing = modest_serversecurity_combo_box_get_active_serversecurity (
 		MODEST_SERVERSECURITY_COMBO_BOX (dialog->combo_outgoing_security));
-	modest_server_account_set_security (dialog->account_manager, outgoing_account_name, protocol_security_outgoing);
+	modest_account_mgr_set_server_account_security (dialog->account_manager, outgoing_account_name, protocol_security_outgoing);
 	
 	const ModestAuthProtocol protocol_authentication_outgoing = modest_secureauth_combo_box_get_active_secureauth (
 		MODEST_SECUREAUTH_COMBO_BOX (dialog->combo_outgoing_auth));
-	modest_server_account_set_secure_auth (dialog->account_manager, outgoing_account_name, protocol_authentication_outgoing);	
+	modest_account_mgr_set_server_account_secure_auth (dialog->account_manager, outgoing_account_name, protocol_authentication_outgoing);	
 	
 	/* port: */
 	port_num = hildon_number_editor_get_value (
 			HILDON_NUMBER_EDITOR (dialog->entry_outgoing_port));
-	modest_account_mgr_set_int (dialog->account_manager, outgoing_account_name,
-			MODEST_ACCOUNT_PORT, port_num, TRUE /* server account */);
-			
+	modest_account_mgr_set_server_account_port (dialog->account_manager, 
+						    outgoing_account_name,
+						    port_num);			
 	g_free (outgoing_account_name);
 	
 	
 	/* Set the changed account title last, to simplify the previous code: */
-	const gchar* account_title = gtk_entry_get_text (GTK_ENTRY (dialog->entry_account_title));
-	if ((!account_title) || (strlen(account_title) == 0))
+	gchar* account_title = get_entered_account_title (dialog);
+	if (!account_title)
 		return FALSE; /* Should be prevented already anyway. */
 		
-	if (strcmp(account_title, account_name) != 0) {
-		/* Change the title: */
-		gboolean test = modest_account_mgr_set_string (dialog->account_manager, account_name,
-		MODEST_ACCOUNT_DISPLAY_NAME, account_title, FALSE /* not server account */);
-		if (!test)
-			return FALSE;
-	}
+/* 	if (strcmp (account_title, account_name) != 0) { */
+		modest_account_mgr_set_display_name (dialog->account_manager, account_name, account_title);
+/* 	} */
+	g_free (account_title);
+	account_title = NULL;
 	
 	/* Save connection-specific SMTP server accounts: */
+	modest_account_mgr_set_use_connection_specific_smtp(dialog->account_manager, account_name,
+		gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->checkbox_outgoing_smtp_specific)));
 	if (dialog->specific_window) {
 		return modest_connection_specific_smtp_window_save_server_accounts (
-			MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (dialog->specific_window), account_name);
-	}
-	else
+			MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (dialog->specific_window));
+	} else {
 		return TRUE;
+	}
 }
 
 static gboolean entry_is_empty (GtkWidget *entry)
@@ -1378,8 +1593,19 @@ static gboolean entry_is_empty (GtkWidget *entry)
 	const gchar* text = gtk_entry_get_text (GTK_ENTRY (entry));
 	if ((!text) || (strlen(text) == 0))
 		return TRUE;
-	else
-		return FALSE;
+	else {
+		/* Strip it of whitespace at the start and end: */
+		gchar *stripped = g_strdup (text);
+		stripped = g_strstrip (stripped);
+		
+		if (!stripped)
+			return TRUE;
+			
+		const gboolean result = (strlen (stripped) == 0);
+		
+		g_free (stripped);
+		return result;
+	}
 }
 
 static void
@@ -1424,31 +1650,3 @@ modest_account_settings_dialog_class_init (ModestAccountSettingsDialogClass *kla
 	object_class->dispose = modest_account_settings_dialog_dispose;
 	object_class->finalize = modest_account_settings_dialog_finalize;
 }
- 
-static void
-show_error (GtkWindow *parent_window, const gchar* text)
-{
-	GtkDialog *dialog = GTK_DIALOG (hildon_note_new_information (parent_window, text));
-	/*
-	GtkDialog *dialog = GTK_DIALOG (gtk_message_dialog_new (parent_window,
-		(GtkDialogFlags)0,
-		 GTK_MESSAGE_ERROR,
-		 GTK_BUTTONS_OK,
-		 text ));
-	*/	 
-	
-	gtk_dialog_run (dialog);
-	gtk_widget_destroy (GTK_WIDGET (dialog));
-}
-
-static void
-show_ok (GtkWindow *parent_window, const gchar* text)
-{
-	/* Don't show a dialog but Banner (NB #59248) */
-	hildon_banner_show_information(GTK_WIDGET(
-																						gtk_widget_get_parent_window(GTK_WIDGET(parent_window))), NULL, text);
-}
-
-
-
-