Probably the very last new config dialog ever. (Ha ha). From Anna, based

	* mail-config.glade: Probably the very last new config dialog
	ever. (Ha ha). From Anna, based on a story by me.

	* mail-account-gui.c: New code for the new mail-config.glade. This
	abstracts out all of the common code between the account editor
	and the druid. It also handles the spiffy new provider-specific
	config stuff.

	FIXME: The code to check if a service is ok or not is no longer
	there... waiting until the online/offline stuff from the shell
	appears.

	* mail-account-editor.c, mail-config-druid.c: These are much
	smaller now, since most of the interesting bits moved to
	mail-account-gui.c

	* mail-accounts.c: Add an enabled/disabled column/button to
	replace the checkbox that used to be in the editor, because it
	really makes more sense to have it out here. This looks ugly.
	Probably ought to ETable it...
	(load_accounts): Fill in the enabled column.
	(mail_select, mail_unselect): toggle the sensitivity and name of
	the Enable/Disable button appropriately
	(mail_able): Handle the enable/disable button.

	* mail-config.c: Remove reply-to from MailConfigIdentity since it
	didn't belong there (and wasn't being saved anyway).
	(mail_config_check_service): Simplify this a bit. This really
	needs to pop up a dialog with a "connecting..." message and a
	cancel button.

svn path=/trunk/; revision=8971

1 files changed, 1086 insertions, 0 deletions

diff --git a/mail/mail-account-gui.c b/mail/mail-account-gui.c
new file mode 100644
index 0000000000..0cf07a58fc
--- /dev/null
+++ b/mail/mail-account-gui.c
@@ -0,0 +1,1086 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ *  Authors:
+ *    Dan Winship <danw@ximian.com>
+ *    Jeffrey Stedfast <fejj@ximian.com>
+ *
+ *  Copyright 2001 Ximian, Inc. (www.ximian.com)
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <gal/widgets/e-unicode.h>
+
+#include "mail-account-gui.h"
+#include "mail-session.h"
+
+static void save_service (MailAccountGuiService *gsvc, GHashTable *extra_conf, MailConfigService *service);
+
+static gboolean
+is_email (const char *address)
+{
+	const char *at, *hname;
+
+	at = strchr (address, '@');
+	/* make sure we have an '@' and that it's not the first or last char */
+	if (!at || at == address || *(at + 1) == '\0')
+		return FALSE;
+
+	hname = at + 1;
+	/* make sure the first and last chars aren't '.' */
+	if (*hname == '.' || hname[strlen (hname) - 1] == '.')
+		return FALSE;
+
+	return strchr (hname, '.') != NULL;
+}
+
+gboolean
+mail_account_gui_identity_complete (MailAccountGui *gui)
+{
+	char *text;
+
+	text = gtk_entry_get_text (gui->full_name);
+	if (!text || !*text)
+		return FALSE;
+	text = gtk_entry_get_text (gui->email_address);
+	if (!text || !is_email (text))
+		return FALSE;
+
+	return TRUE;
+}
+
+static gboolean
+service_complete (MailAccountGuiService *service)
+{
+	const CamelProvider *prov = service->provider;
+	char *text;
+
+	if (!prov)
+		return TRUE;
+
+	if (CAMEL_PROVIDER_NEEDS (prov, CAMEL_URL_PART_HOST)) {
+		text = gtk_entry_get_text (service->hostname);
+		if (!text || !*text)
+			return FALSE;
+	}
+	if (CAMEL_PROVIDER_NEEDS (prov, CAMEL_URL_PART_USER)) {
+		text = gtk_entry_get_text (service->username);
+		if (!text || !*text)
+			return FALSE;
+	}
+	if (CAMEL_PROVIDER_NEEDS (prov, CAMEL_URL_PART_PATH)) {
+		text = gtk_entry_get_text (service->path);
+		if (!text || !*text)
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+gboolean
+mail_account_gui_source_complete (MailAccountGui *gui)
+{
+	return service_complete (&gui->source);
+}
+
+gboolean
+mail_account_gui_transport_complete (MailAccountGui *gui)
+{
+	if (!service_complete (&gui->transport))
+		return FALSE;
+
+	/* FIXME? */
+	if (gtk_toggle_button_get_active (gui->transport_needs_auth) &&
+	    CAMEL_PROVIDER_ALLOWS (gui->transport.provider, CAMEL_URL_PART_USER)) {
+		char *text = gtk_entry_get_text (gui->transport.username);
+
+		if (!text || !*text)
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+gboolean
+mail_account_gui_management_complete (MailAccountGui *gui)
+{
+	char *text;
+
+	text = gtk_entry_get_text (gui->account_name);
+	return text && *text;
+}
+
+
+
+
+static void
+service_authtype_changed (GtkWidget *widget, gpointer user_data)
+{
+	MailAccountGuiService *service = user_data;
+	CamelServiceAuthType *authtype;
+
+	service->authitem = widget;
+	authtype = gtk_object_get_data (GTK_OBJECT (widget), "authtype");
+
+	gtk_widget_set_sensitive (GTK_WIDGET (service->remember), authtype->need_password);
+}
+
+static void
+build_auth_menu (MailAccountGuiService *service, GList *authtypes)
+{
+	GtkWidget *menu, *item, *first = NULL;
+	CamelServiceAuthType *authtype;
+	GList *l;
+
+	menu = gtk_menu_new ();
+
+	for (l = authtypes; l; l = l->next) {
+		authtype = l->data;
+
+		item = gtk_menu_item_new_with_label (_(authtype->name));
+		gtk_object_set_data (GTK_OBJECT (item), "authtype", authtype);
+		gtk_signal_connect (GTK_OBJECT (item), "activate",
+				    service_authtype_changed, service);
+
+		gtk_menu_append (GTK_MENU (menu), item);
+
+		gtk_widget_show (item);
+
+		if (!first)
+			first = item;
+	}
+
+	gtk_option_menu_remove_menu (service->authtype);
+	gtk_option_menu_set_menu (service->authtype, menu);
+
+	if (first)
+		gtk_signal_emit_by_name (GTK_OBJECT (first), "activate", service);
+}
+
+static void
+source_type_changed (GtkWidget *widget, gpointer user_data)
+{
+	MailAccountGui *gui = user_data;
+	GtkWidget *label, *frame, *dwidget = NULL;
+	CamelProvider *provider;
+
+	provider = gtk_object_get_data (GTK_OBJECT (widget), "provider");
+
+	gui->source.provider = provider;
+
+	frame = glade_xml_get_widget (gui->xml, "source_frame");
+	if (provider) {
+		gtk_widget_show (frame);
+
+		/* hostname */
+		label = glade_xml_get_widget (gui->xml, "source_host_label");
+		if (CAMEL_PROVIDER_ALLOWS (provider, CAMEL_URL_PART_HOST)) {
+			dwidget = GTK_WIDGET (gui->source.hostname);
+			gtk_widget_show (GTK_WIDGET (gui->source.hostname));
+			gtk_widget_show (label);
+		} else {
+			gtk_widget_hide (GTK_WIDGET (gui->source.hostname));
+			gtk_widget_hide (label);
+		}
+
+		/* username */
+		label = glade_xml_get_widget (gui->xml, "source_user_label");
+		if (CAMEL_PROVIDER_ALLOWS (provider, CAMEL_URL_PART_USER)) {
+			if (!dwidget)
+				dwidget = GTK_WIDGET (gui->source.username);
+			gtk_widget_show (GTK_WIDGET (gui->source.username));
+			gtk_widget_show (label);
+		} else {
+			gtk_widget_hide (GTK_WIDGET (gui->source.username));
+			gtk_widget_hide (label);
+		}
+
+		/* path */
+		label = glade_xml_get_widget (gui->xml, "source_path_label");
+		if (CAMEL_PROVIDER_ALLOWS (provider, CAMEL_URL_PART_PATH)) {
+			if (!dwidget)
+				dwidget = GTK_WIDGET (gui->source.path);
+
+			if (!strcmp (provider->protocol, "mbox")) {
+				char *path;
+
+				if (getenv ("MAIL"))
+					path = g_strdup (getenv ("MAIL"));
+				else
+					path = g_strdup_printf (SYSTEM_MAIL_DIR "/%s", g_get_user_name ());
+				gtk_entry_set_text (gui->source.path, path);
+				g_free (path);
+			} else if (!strcmp (provider->protocol, "maildir") &&
+				   getenv ("MAILDIR")) {
+				gtk_entry_set_text (gui->source.path, getenv ("MAILDIR"));
+			} else {
+				gtk_entry_set_text (gui->source.path, "");
+			}
+
+			gtk_widget_show (GTK_WIDGET (gui->source.path));
+			gtk_widget_show (label);
+		} else {
+			gtk_entry_set_text (gui->source.path, "");
+			gtk_widget_hide (GTK_WIDGET (gui->source.path));
+			gtk_widget_hide (label);
+		}
+
+		/* ssl */
+#ifdef HAVE_NSS
+		if (provider && provider->flags & CAMEL_PROVIDER_SUPPORTS_SSL)
+			gtk_widget_show (GTK_WIDGET (gui->source.use_ssl));
+		else
+#endif
+			gtk_widget_hide (GTK_WIDGET (gui->source.use_ssl));
+
+		/* auth */
+		frame = glade_xml_get_widget (gui->xml, "source_auth_frame");
+		if (provider && CAMEL_PROVIDER_ALLOWS (provider, CAMEL_URL_PART_AUTH)) {
+			build_auth_menu (&gui->source, provider->authtypes);
+			gtk_widget_show (frame);
+		} else
+			gtk_widget_hide (frame);
+	} else {
+		gtk_widget_hide (frame);
+		frame = glade_xml_get_widget (gui->xml, "source_auth_frame");
+		gtk_widget_hide (frame);
+	}
+
+	gtk_signal_emit_by_name (GTK_OBJECT (gui->source.username), "changed");
+
+	if (dwidget)
+		gtk_widget_grab_focus (dwidget);
+}
+
+
+static void
+transport_needs_auth_toggled (GtkToggleButton *toggle, gpointer data)
+{
+	MailAccountGui *gui = data;
+	gboolean need = gtk_toggle_button_get_active (toggle);
+	GtkWidget *widget;
+
+	widget = glade_xml_get_widget (gui->xml, "transport_auth_frame");
+	gtk_widget_set_sensitive (widget, need);
+}
+
+static void
+transport_type_changed (GtkWidget *widget, gpointer user_data)
+{
+	MailAccountGui *gui = user_data;
+	CamelProvider *provider;
+	GtkWidget *label, *frame;
+
+	provider = gtk_object_get_data (GTK_OBJECT (widget), "provider");
+	gui->transport.provider = provider;
+
+	frame = glade_xml_get_widget (gui->xml, "transport_frame");
+	if (CAMEL_PROVIDER_ALLOWS (provider, CAMEL_URL_PART_HOST) ||
+	    (CAMEL_PROVIDER_ALLOWS (provider, CAMEL_URL_PART_AUTH) &&
+	     !CAMEL_PROVIDER_NEEDS (provider, CAMEL_URL_PART_AUTH))) {
+		gtk_widget_show (frame);
+
+		label = glade_xml_get_widget (gui->xml, "transport_host_label");
+		if (CAMEL_PROVIDER_ALLOWS (provider, CAMEL_URL_PART_HOST)) {
+			gtk_widget_grab_focus (GTK_WIDGET (gui->transport.hostname));
+			gtk_widget_show (GTK_WIDGET (gui->transport.hostname));
+			gtk_widget_show (label);
+		} else {
+			gtk_widget_hide (GTK_WIDGET (gui->transport.hostname));
+			gtk_widget_hide (label);
+		}
+
+		/* ssl */
+#ifdef HAVE_NSS
+		if (provider && provider->flags & CAMEL_PROVIDER_SUPPORTS_SSL)
+			gtk_widget_show (GTK_WIDGET (gui->transport.use_ssl));
+		else
+#endif
+			gtk_widget_hide (GTK_WIDGET (gui->transport.use_ssl));
+
+		/* auth */
+		if (CAMEL_PROVIDER_ALLOWS (provider, CAMEL_URL_PART_AUTH) &&
+		    !CAMEL_PROVIDER_NEEDS (provider, CAMEL_URL_PART_AUTH))
+			gtk_widget_show (GTK_WIDGET (gui->transport_needs_auth));
+		else
+			gtk_widget_hide (GTK_WIDGET (gui->transport_needs_auth));
+	} else
+		gtk_widget_hide (frame);
+
+	frame = glade_xml_get_widget (gui->xml, "transport_auth_frame");
+	if (CAMEL_PROVIDER_ALLOWS (provider, CAMEL_URL_PART_AUTH)) {
+		gtk_widget_show (frame);
+
+		label = glade_xml_get_widget (gui->xml, "transport_user_label");
+		if (CAMEL_PROVIDER_ALLOWS (provider, CAMEL_URL_PART_USER)) {
+			gtk_widget_show (GTK_WIDGET (gui->transport.username));
+			gtk_widget_show (label);
+		} else {
+			gtk_widget_hide (GTK_WIDGET (gui->transport.username));
+			gtk_widget_hide (label);
+		}
+
+		build_auth_menu (&gui->transport, provider->authtypes);
+		transport_needs_auth_toggled (gui->transport_needs_auth, gui);
+	} else
+		gtk_widget_hide (frame);
+
+	gtk_signal_emit_by_name (GTK_OBJECT (gui->transport.hostname), "changed");
+}
+
+static void
+service_changed (GtkEntry *entry, gpointer user_data)
+{
+	MailAccountGuiService *service = user_data;
+
+	gtk_widget_set_sensitive (GTK_WIDGET (service->check_supported),
+				  service_complete (service));
+}
+
+static void
+service_check_supported (GtkButton *button, gpointer user_data)
+{
+	MailAccountGuiService *gsvc = user_data;
+	MailConfigService *service;
+	GList *authtypes = NULL;
+
+	service = g_new0 (MailConfigService, 1);
+	save_service (gsvc, NULL, service);
+
+	if (mail_config_check_service (service->url, CAMEL_PROVIDER_STORE, &authtypes)) {
+		build_auth_menu (gsvc, authtypes);
+		g_list_free (authtypes);
+	}
+
+	service_destroy (service);
+}
+
+
+static void
+toggle_sensitivity (GtkToggleButton *toggle, GtkWidget *widget)
+{
+	gtk_widget_set_sensitive (widget, gtk_toggle_button_get_active (toggle));
+}
+
+static void
+setup_toggle (GtkWidget *widget, const char *depname, MailAccountGui *gui)
+{
+	GtkToggleButton *toggle;
+
+	if (!strcmp (depname, "UNIMPLEMENTED")) {
+		gtk_widget_set_sensitive (widget, FALSE);
+		return;
+	}
+
+	toggle = g_hash_table_lookup (gui->extra_config, depname);
+	gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
+			    GTK_SIGNAL_FUNC (toggle_sensitivity),
+			    widget);
+	toggle_sensitivity (toggle, widget);
+}
+
+void
+mail_account_gui_build_extra_conf (MailAccountGui *gui, const char *url_string)
+{
+	CamelURL *url;
+	GtkWidget *mailcheck_frame, *main_vbox, *cur_vbox;
+	CamelProviderConfEntry *entries;
+	GList *children, *child;
+	char *name;
+	int i;
+
+	if (url_string)
+		url = camel_url_new (url_string, NULL);
+	else
+		url = NULL;
+
+	main_vbox = glade_xml_get_widget (gui->xml, "extra_vbox");
+
+	mailcheck_frame = glade_xml_get_widget (gui->xml, "extra_mailcheck_frame");
+
+	/* Remove any additional mailcheck items. */
+	children = gtk_container_children (GTK_CONTAINER (mailcheck_frame));
+	if (children) {
+		cur_vbox = children->data;
+		g_list_free (children);
+		children = gtk_container_children (GTK_CONTAINER (cur_vbox));
+		for (child = children; child; child = child->next) {
+			if (child != children) {
+				gtk_container_remove (GTK_CONTAINER (cur_vbox),
+						      child->data);
+			}
+		}
+		g_list_free (children);
+	}
+
+	/* Remove the contents of the extra_vbox except for the
+	 * mailcheck_frame.
+	 */
+	children = gtk_container_children (GTK_CONTAINER (main_vbox));
+	for (child = children; child; child = child->next) {
+		if (child != children) {
+			gtk_container_remove (GTK_CONTAINER (main_vbox),
+					      child->data);
+		}
+	}
+	g_list_free (children);
+
+	if (!gui->source.provider) {
+		gtk_widget_set_sensitive (main_vbox, FALSE);
+		return;
+	} else
+		gtk_widget_set_sensitive (main_vbox, TRUE);
+
+	/* Set up our hash table. */
+	if (gui->extra_config)
+		g_hash_table_destroy (gui->extra_config);
+	gui->extra_config = g_hash_table_new (g_str_hash, g_str_equal);
+
+	entries = gui->source.provider->extra_conf;
+	if (!entries)
+		goto done;
+
+	cur_vbox = main_vbox;
+	for (i = 0; ; i++) {
+		switch (entries[i].type) {
+		case CAMEL_PROVIDER_CONF_SECTION_START:
+		{
+			GtkWidget *frame;
+
+			if (entries[i].name && !strcmp (entries[i].name, "mailcheck"))
+				cur_vbox = glade_xml_get_widget (gui->xml, "extra_mailcheck_vbox");
+			else {
+				frame = gtk_frame_new (_(entries[i].text));
+				gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
+				cur_vbox = gtk_vbox_new (FALSE, 4);
+				gtk_container_set_border_width (GTK_CONTAINER (cur_vbox), 4);
+				gtk_container_add (GTK_CONTAINER (frame), cur_vbox);
+			}
+			break;
+		}
+		case CAMEL_PROVIDER_CONF_SECTION_END:
+			cur_vbox = main_vbox;
+			break;
+
+		case CAMEL_PROVIDER_CONF_CHECKBOX:
+		{
+			GtkWidget *checkbox;
+			gboolean active;
+
+			checkbox = gtk_check_button_new_with_label (_(entries[i].text));
+			if (url)
+				active = camel_url_get_param (url, entries[i].name) != NULL;
+			else
+				active = atoi (entries[i].value);
+			gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), active);
+			gtk_box_pack_start (GTK_BOX (cur_vbox), checkbox, FALSE, FALSE, 0);
+			g_hash_table_insert (gui->extra_config, entries[i].name, checkbox);
+			if (entries[i].depname)
+				setup_toggle (checkbox, entries[i].depname, gui);
+			break;
+		}
+
+		case CAMEL_PROVIDER_CONF_ENTRY:
+		{
+			GtkWidget *hbox, *label, *entry;
+			const char *text;
+
+			hbox = gtk_hbox_new (FALSE, 8);
+			label = gtk_label_new (_(entries[i].text));
+			entry = gtk_entry_new ();
+			if (url)
+				text = camel_url_get_param (url, entries[i].name);
+			else
+				text = entries[i].value;
+			if (text)
+				gtk_entry_set_text (GTK_ENTRY (entry), text);
+
+			gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
+			gtk_box_pack_end (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
+
+			gtk_box_pack_start (GTK_BOX (cur_vbox), hbox, FALSE, FALSE, 0);
+			g_hash_table_insert (gui->extra_config, entries[i].name, entry);
+			if (entries[i].depname) {
+				setup_toggle (entry, entries[i].depname, gui);
+				setup_toggle (label, entries[i].depname, gui);
+			}
+			break;
+		}
+
+		case CAMEL_PROVIDER_CONF_CHECKSPIN:
+		{
+			GtkWidget *hbox, *checkbox, *spin, *label;
+			GtkObject *adj;
+			char *data, *pre, *post, *p;
+			double min, def, max;
+			gboolean enable;
+
+			data = _(entries[i].text);
+			p = strstr (data, "%s");
+			g_return_if_fail (p != NULL);
+
+			pre = g_strndup (data, p - data);
+			post = p + 2;
+
+			data = entries[i].value;
+			enable = *data++ == 'y';
+			g_return_if_fail (*data == ':');
+			min = strtod (++data, &data);
+			g_return_if_fail (*data == ':');
+			def = strtod (++data, &data);
+			g_return_if_fail (*data == ':');
+			max = strtod (++data, NULL);
+
+			if (url) {
+				const char *val;
+
+				val = camel_url_get_param (url, entries[i].name);
+				if (!val)
+					enable = FALSE;
+				else {
+					enable = TRUE;
+					def = atof (val);
+				}
+			}
+
+			hbox = gtk_hbox_new (FALSE, 0);
+			checkbox = gtk_check_button_new_with_label (pre);
+			g_free (pre);
+			gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), enable);
+			adj = gtk_adjustment_new (def, min, max, 1, 1, 1);
+			spin = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
+			label = gtk_label_new (post);
+
+			gtk_box_pack_start (GTK_BOX (hbox), checkbox, FALSE, TRUE, 0);
+			gtk_box_pack_start (GTK_BOX (hbox), spin, FALSE, FALSE, 0);
+			gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 4);
+
+			gtk_box_pack_start (GTK_BOX (cur_vbox), hbox, FALSE, FALSE, 0);
+			g_hash_table_insert (gui->extra_config, entries[i].name, checkbox);
+			name = g_strdup_printf ("%s_value", entries[i].name);
+			g_hash_table_insert (gui->extra_config, name, spin);
+			if (entries[i].depname) {
+				setup_toggle (checkbox, entries[i].depname, gui);
+				setup_toggle (spin, entries[i].depname, gui);
+				setup_toggle (label, entries[i].depname, gui);
+			}
+			break;
+		}
+
+		case CAMEL_PROVIDER_CONF_END:
+			goto done;
+		}
+	}
+
+ done:
+	gtk_widget_show_all (main_vbox);
+}
+
+static void
+extract_values (MailAccountGuiService *source, GHashTable *extra_config, CamelURL *url)
+{
+	CamelProviderConfEntry *entries;
+	GtkToggleButton *toggle;
+	GtkEntry *entry;
+	GtkSpinButton *spin;
+	char *name;
+	int i;
+
+	if (!source->provider || !source->provider->extra_conf)
+		return;
+	entries = source->provider->extra_conf;
+
+	for (i = 0; ; i++) {
+		if (entries[i].depname) {
+			toggle = g_hash_table_lookup (extra_config, entries[i].depname);
+			if (!toggle || !gtk_toggle_button_get_active (toggle))
+				continue;
+		}
+
+		switch (entries[i].type) {
+		case CAMEL_PROVIDER_CONF_CHECKBOX:
+			toggle = g_hash_table_lookup (extra_config, entries[i].name);
+			if (gtk_toggle_button_get_active (toggle))
+				camel_url_set_param (url, entries[i].name, "");
+			break;
+
+		case CAMEL_PROVIDER_CONF_ENTRY:
+			entry = g_hash_table_lookup (extra_config, entries[i].name);
+			camel_url_set_param (url, entries[i].name, gtk_entry_get_text (entry));
+			break;
+
+		case CAMEL_PROVIDER_CONF_CHECKSPIN:
+			toggle = g_hash_table_lookup (extra_config, entries[i].name);
+			if (!gtk_toggle_button_get_active (toggle))
+				break;
+			name = g_strdup_printf ("%s_value", entries[i].name);
+			spin = g_hash_table_lookup (extra_config, name);
+			g_free (name);
+			name = g_strdup_printf ("%d", gtk_spin_button_get_value_as_int (spin));
+			camel_url_set_param (url, entries[i].name, name);
+			g_free (name);
+			break;
+
+		case CAMEL_PROVIDER_CONF_END:
+			return;
+
+		default:
+			break;
+		}
+	}
+}
+
+
+static gboolean
+setup_service (MailAccountGuiService *gsvc, MailConfigService *service)
+{
+	CamelURL *url = camel_url_new (service->url, NULL);
+	gboolean has_auth = FALSE;
+
+	if (url->user && CAMEL_PROVIDER_ALLOWS (gsvc->provider, CAMEL_URL_PART_USER))
+		gtk_entry_set_text (gsvc->username, url->user);
+	if (url->host && CAMEL_PROVIDER_ALLOWS (gsvc->provider, CAMEL_URL_PART_HOST)) {
+		char *hostname;
+
+		if (url->port)
+			hostname = g_strdup_printf ("%s:%d", url->host, url->port);
+		else
+			hostname = g_strdup (url->host);
+
+		gtk_entry_set_text (gsvc->hostname, hostname);
+		g_free (hostname);
+	}
+	if (url->path && CAMEL_PROVIDER_ALLOWS (gsvc->provider, CAMEL_URL_PART_PATH))
+		gtk_entry_set_text (gsvc->path, url->path);
+	if (gsvc->provider->flags & CAMEL_PROVIDER_SUPPORTS_SSL) {
+		gboolean use_ssl = camel_url_get_param (url, "use_ssl") != NULL;
+		gtk_toggle_button_set_active (gsvc->use_ssl, use_ssl);
+	}
+	if (url->authmech && CAMEL_PROVIDER_ALLOWS (gsvc->provider, CAMEL_URL_PART_AUTH)) {
+		GList *children, *item;
+		CamelServiceAuthType *authtype;
+		int i;
+
+		children = gtk_container_children (GTK_CONTAINER (gtk_option_menu_get_menu (gsvc->authtype)));
+		for (item = children, i = 0; item; item = item->next, i++) {
+			authtype = gtk_object_get_data (item->data, "authtype");
+			if (!authtype)
+				continue;
+			if (!strcmp (authtype->authproto, url->authmech)) {
+				gtk_option_menu_set_history (gsvc->authtype, i);
+				gtk_signal_emit_by_name (item->data, "activate");
+				break;
+			}
+		}
+		g_list_free (children);
+
+		gtk_toggle_button_set_active (gsvc->remember, service->save_passwd);
+		has_auth = TRUE;
+	}
+
+	return has_auth;
+}
+
+static gint
+provider_compare (const CamelProvider *p1, const CamelProvider *p2)
+{
+	/* sort providers based on "location" (ie. local or remote) */
+	if (p1->flags & CAMEL_PROVIDER_IS_REMOTE) {
+		if (p2->flags & CAMEL_PROVIDER_IS_REMOTE)
+			return 0;
+		return -1;
+	} else {
+		if (p2->flags & CAMEL_PROVIDER_IS_REMOTE)
+			return 1;
+		return 0;
+	}
+}
+
+MailAccountGui *
+mail_account_gui_new (MailConfigAccount *account)
+{
+	MailAccountGui *gui;
+
+	gui = g_new0 (MailAccountGui, 1);
+	gui->account = account;
+	gui->xml = glade_xml_new (EVOLUTION_GLADEDIR "/mail-config.glade", NULL);
+
+	/* Management */
+	gui->account_name = GTK_ENTRY (glade_xml_get_widget (gui->xml, "management_name"));
+	gui->default_account = GTK_TOGGLE_BUTTON (glade_xml_get_widget (gui->xml, "management_default"));
+	if (account->name)
+		e_utf8_gtk_entry_set_text (gui->account_name, account->name);
+	gtk_toggle_button_set_active (gui->default_account, account->default_account);
+
+	/* Identity */
+	gui->full_name = GTK_ENTRY (glade_xml_get_widget (gui->xml, "identity_full_name"));
+	gui->email_address = GTK_ENTRY (glade_xml_get_widget (gui->xml, "identity_address"));
+	gui->organization = GTK_ENTRY (glade_xml_get_widget (gui->xml, "identity_organization"));
+	gui->signature = GNOME_FILE_ENTRY (glade_xml_get_widget (gui->xml, "identity_signature"));
+	gnome_file_entry_set_default_path (gui->signature, g_get_home_dir ());
+	if (account->id) {
+		if (account->id->name)
+			e_utf8_gtk_entry_set_text (gui->full_name, account->id->name);
+		if (account->id->address)
+			gtk_entry_set_text (gui->email_address, account->id->address);
+	}
+
+	/* Source */
+	gui->source.type = GTK_OPTION_MENU (glade_xml_get_widget (gui->xml, "source_type_omenu"));
+	gui->source.hostname = GTK_ENTRY (glade_xml_get_widget (gui->xml, "source_host"));
+	gtk_signal_connect (GTK_OBJECT (gui->source.hostname), "changed",
+			    GTK_SIGNAL_FUNC (service_changed), &gui->source);
+	gui->source.username = GTK_ENTRY (glade_xml_get_widget (gui->xml, "source_user"));
+	gtk_signal_connect (GTK_OBJECT (gui->source.username), "changed",
+			    GTK_SIGNAL_FUNC (service_changed), &gui->source);
+	gui->source.path = GTK_ENTRY (glade_xml_get_widget (gui->xml, "source_path"));
+	gtk_signal_connect (GTK_OBJECT (gui->source.path), "changed",
+			    GTK_SIGNAL_FUNC (service_changed), &gui->source);
+	gui->source.use_ssl = GTK_TOGGLE_BUTTON (glade_xml_get_widget (gui->xml, "source_use_ssl"));
+	gui->source.authtype = GTK_OPTION_MENU (glade_xml_get_widget (gui->xml, "source_auth_omenu"));
+	gui->source.remember = GTK_TOGGLE_BUTTON (glade_xml_get_widget (gui->xml, "source_remember_password"));
+	gui->source.check_supported = GTK_BUTTON (glade_xml_get_widget (gui->xml, "source_check_supported"));
+	gtk_signal_connect (GTK_OBJECT (gui->source.check_supported), "clicked", GTK_SIGNAL_FUNC (service_check_supported), &gui->source);
+	gui->source_auto_check = GTK_TOGGLE_BUTTON (glade_xml_get_widget (gui->xml, "extra_auto_check"));
+	gui->source_auto_check_min = GTK_SPIN_BUTTON (glade_xml_get_widget (gui->xml, "extra_auto_check_min"));
+
+	/* Transport */
+	gui->transport.type = GTK_OPTION_MENU (glade_xml_get_widget (gui->xml, "transport_type_omenu"));
+	gui->transport.hostname = GTK_ENTRY (glade_xml_get_widget (gui->xml, "transport_host"));
+	gtk_signal_connect (GTK_OBJECT (gui->transport.hostname), "changed",
+			    GTK_SIGNAL_FUNC (service_changed), &gui->source);
+	gui->transport.username = GTK_ENTRY (glade_xml_get_widget (gui->xml, "transport_user"));
+	gtk_signal_connect (GTK_OBJECT (gui->transport.username), "changed",
+			    GTK_SIGNAL_FUNC (service_changed), &gui->source);
+	gui->transport.use_ssl = GTK_TOGGLE_BUTTON (glade_xml_get_widget (gui->xml, "transport_use_ssl"));
+	gui->transport_needs_auth = GTK_TOGGLE_BUTTON (glade_xml_get_widget (gui->xml, "transport_needs_auth"));
+	gtk_signal_connect (GTK_OBJECT (gui->transport_needs_auth), "toggled", transport_needs_auth_toggled, gui);
+	gui->transport.authtype = GTK_OPTION_MENU (glade_xml_get_widget (gui->xml, "transport_auth_omenu"));
+	gui->transport.remember = GTK_TOGGLE_BUTTON (glade_xml_get_widget (gui->xml, "transport_remember_password"));
+	gui->transport.check_supported = GTK_BUTTON (glade_xml_get_widget (gui->xml, "transport_check_supported"));
+	gtk_signal_connect (GTK_OBJECT (gui->transport.check_supported), "clicked", GTK_SIGNAL_FUNC (service_check_supported), &gui->transport);
+
+	return gui;
+}
+
+void
+mail_account_gui_setup (MailAccountGui *gui, GtkWidget *top)
+{
+	GtkWidget *stores, *transports, *item;
+	GtkWidget *fstore = NULL, *ftransport = NULL;
+	int si = 0, hstore = 0, ti = 0, htransport = 0;
+	int max_width = 0;
+	char *max_authname = NULL;
+	char *source_proto, *transport_proto;
+	GList *providers, *l;
+
+	if (gui->account->source && gui->account->source->url) {
+		source_proto = gui->account->source->url;
+		source_proto = g_strndup (source_proto, strcspn (source_proto, ":"));
+	} else
+		source_proto = NULL;
+	if (gui->account->transport && gui->account->transport->url) {
+		transport_proto = gui->account->transport->url;
+		transport_proto = g_strndup (transport_proto, strcspn (transport_proto, ":"));
+	} else
+		transport_proto = NULL;
+
+	/* Construct source/transport option menus */
+	stores = gtk_menu_new ();
+	transports = gtk_menu_new ();
+	providers = camel_session_list_providers (session, TRUE);
+
+	/* sort the providers, remote first */
+	providers = g_list_sort (providers, (GCompareFunc) provider_compare);
+
+	for (l = providers; l; l = l->next) {
+		CamelProvider *provider = l->data;
+
+		if (strcmp (provider->domain, "mail"))
+			continue;
+
+		item = NULL;
+		if (provider->object_types[CAMEL_PROVIDER_STORE] && provider->flags & CAMEL_PROVIDER_IS_SOURCE) {
+			item = gtk_menu_item_new_with_label (_(provider->name));
+			gtk_object_set_data (GTK_OBJECT (item), "provider", provider);
+			gtk_signal_connect (GTK_OBJECT (item), "activate",
+					    GTK_SIGNAL_FUNC (source_type_changed),
+					    gui);
+
+			gtk_menu_append (GTK_MENU (stores), item);
+
+			gtk_widget_show (item);
+
+			if (!fstore) {
+				fstore = item;
+				hstore = si;
+			}
+
+			if (source_proto && !g_strcasecmp (provider->protocol, source_proto)) {
+				fstore = item;
+				hstore = si;
+			}
+
+			si++;
+		}
+
+		if (provider->object_types[CAMEL_PROVIDER_TRANSPORT]) {
+			item = gtk_menu_item_new_with_label (_(provider->name));
+			gtk_object_set_data (GTK_OBJECT (item), "provider", provider);
+			gtk_signal_connect (GTK_OBJECT (item), "activate",
+					    GTK_SIGNAL_FUNC (transport_type_changed),
+					    gui);
+
+			gtk_menu_append (GTK_MENU (transports), item);
+
+			gtk_widget_show (item);
+
+			if (!ftransport) {
+				ftransport = item;
+				htransport = ti;
+			}
+
+			if (transport_proto && !g_strcasecmp (provider->protocol, transport_proto)) {
+				ftransport = item;
+				htransport = ti;
+			}
+
+			ti++;
+		}
+
+		if (item && provider->authtypes) {
+			GdkFont *font = GTK_WIDGET (item)->style->font;
+			CamelServiceAuthType *at;
+			int width;
+			GList *a;
+
+			for (a = provider->authtypes; a; a = a->next) {
+				at = a->data;
+
+				width = gdk_string_width (font, _(at->name));
+				if (width > max_width) {
+					max_authname = _(at->name);
+					max_width = width;
+				}
+			}
+		}
+	}
+	g_list_free (providers);
+
+	/* add a "None" option to the stores menu */
+	item = gtk_menu_item_new_with_label (_("None"));
+	gtk_object_set_data (GTK_OBJECT (item), "provider", NULL);
+	gtk_signal_connect (GTK_OBJECT (item), "activate",
+			    GTK_SIGNAL_FUNC (source_type_changed),
+			    gui);
+
+	gtk_menu_append (GTK_MENU (stores), item);
+
+	gtk_widget_show (item);
+
+	if (!fstore) {
+		fstore = item;
+		hstore = si;
+	}
+
+	/* set the menus on the optionmenus */
+	gtk_option_menu_remove_menu (gui->source.type);
+	gtk_option_menu_set_menu (gui->source.type, stores);
+	gtk_option_menu_set_history (gui->source.type, hstore);
+
+	gtk_option_menu_remove_menu (gui->transport.type);
+	gtk_option_menu_set_menu (gui->transport.type, transports);
+	gtk_option_menu_set_history (gui->transport.type, htransport);
+
+	/* Force the authmenus to the width of the widest element */
+	if (max_authname) {
+		GtkWidget *menu;
+		GtkRequisition size_req;
+
+		menu = gtk_menu_new ();
+		item = gtk_menu_item_new_with_label (max_authname);
+		gtk_menu_append (GTK_MENU (menu), item);
+		gtk_widget_show_all (menu);
+		gtk_option_menu_set_menu (gui->source.authtype, menu);
+		gtk_widget_show (GTK_WIDGET (gui->source.authtype));
+		gtk_widget_size_request (GTK_WIDGET (gui->source.authtype),
+					 &size_req);
+
+		gtk_widget_set_usize (GTK_WIDGET (gui->source.authtype),
+				      size_req.width, -1);
+		gtk_widget_set_usize (GTK_WIDGET (gui->transport.authtype),
+				      size_req.width, -1);
+	}
+
+	gtk_widget_show_all (top);
+
+	/* Force some other elements to keep their current sizes even if
+	 * widgets are hidden
+	 */
+	item = glade_xml_get_widget (gui->xml, "source_frame");
+	gtk_widget_set_usize (item, -1, item->allocation.height);
+	item = glade_xml_get_widget (gui->xml, "source_auth_frame");
+	gtk_widget_set_usize (item, -1, item->allocation.height);
+	item = glade_xml_get_widget (gui->xml, "source_vbox");
+	gtk_widget_set_usize (item, -1, item->allocation.height);
+	item = glade_xml_get_widget (gui->xml, "transport_frame");
+	gtk_widget_set_usize (item, -1, item->allocation.height);
+	item = glade_xml_get_widget (gui->xml, "transport_auth_frame");
+	gtk_widget_set_usize (item, -1, item->allocation.height);
+	item = glade_xml_get_widget (gui->xml, "transport_vbox");
+	gtk_widget_set_usize (item, -1, item->allocation.height);
+
+	if (fstore)
+		gtk_signal_emit_by_name (GTK_OBJECT (fstore), "activate", gui);
+
+	if (ftransport)
+		gtk_signal_emit_by_name (GTK_OBJECT (ftransport), "activate", gui);
+
+	if (source_proto) {
+		setup_service (&gui->source, gui->account->source);
+		g_free (source_proto);
+		if (gui->account->source->auto_check) {
+			gtk_toggle_button_set_active (gui->source_auto_check, TRUE);
+			gtk_spin_button_set_value (gui->source_auto_check_min,
+						   gui->account->source->auto_check_time);
+		}
+	}
+	if (transport_proto) {
+		if (setup_service (&gui->transport, gui->account->transport))
+			gtk_toggle_button_set_active (gui->transport_needs_auth, TRUE);
+		g_free (transport_proto);
+	}
+}
+
+static void
+save_service (MailAccountGuiService *gsvc, GHashTable *extra_config,
+	      MailConfigService *service)
+{
+	CamelURL *url;
+	char *str;
+
+	if (!gsvc->provider) {
+		g_free (service->url);
+		service->url = NULL;
+		return;
+	}
+
+	url = g_new0 (CamelURL, 1);
+	url->protocol = g_strdup (gsvc->provider->protocol);
+
+	if (CAMEL_PROVIDER_ALLOWS (gsvc->provider, CAMEL_URL_PART_USER)) {
+		str = gtk_entry_get_text (gsvc->username);
+		if (str && *str)
+			url->user = g_strdup (str);
+	}
+
+	if (CAMEL_PROVIDER_ALLOWS (gsvc->provider, CAMEL_URL_PART_AUTH)) {
+		CamelServiceAuthType *authtype;
+
+		authtype = gtk_object_get_data (GTK_OBJECT (gsvc->authitem), "authtype");
+		if (authtype->authproto && *authtype->authproto)
+			url->authmech = g_strdup (authtype->authproto);
+
+		service->save_passwd = gtk_toggle_button_get_active (gsvc->remember);
+	}
+
+	if (CAMEL_PROVIDER_ALLOWS (gsvc->provider, CAMEL_URL_PART_HOST)) {
+		char *pport;
+
+		str = gtk_entry_get_text (gsvc->hostname);
+		if (str && *str) {
+			pport = strchr (str, ':');
+			if (pport) {
+				url->host = g_strndup (str, pport - str);
+				url->port = atoi (pport + 1);
+			} else
+				url->host = g_strdup (str);
+		}
+	}
+
+	if (CAMEL_PROVIDER_ALLOWS (gsvc->provider, CAMEL_URL_PART_PATH)) {
+		str = gtk_entry_get_text (gsvc->path);
+		if (str && *str)
+			url->path = g_strdup (str);
+	}
+
+	if (gsvc->provider->flags & CAMEL_PROVIDER_SUPPORTS_SSL) {
+		if (gtk_toggle_button_get_active (gsvc->use_ssl))
+			camel_url_set_param (url, "use_ssl", "");
+	}
+
+	if (extra_config)
+		extract_values (gsvc, extra_config, url);
+
+	g_free (service->url);
+	service->url = camel_url_to_string (url, FALSE);
+
+	/* Temporary until keep_on_server moves into the POP provider */
+	if (camel_url_get_param (url, "keep_on_server"))
+		service->keep_on_server = TRUE;
+
+	camel_url_free (url);
+}
+
+gboolean
+mail_account_gui_save (MailAccountGui *gui)
+{
+	MailConfigAccount *account = gui->account;
+
+	if (!mail_account_gui_identity_complete (gui) ||
+	    !mail_account_gui_source_complete (gui) ||
+	    !mail_account_gui_transport_complete (gui) ||
+	    !mail_account_gui_management_complete (gui))
+		return FALSE;
+
+	g_free (account->name);
+	account->name = e_utf8_gtk_entry_get_text (gui->account_name);
+	account->default_account = gtk_toggle_button_get_active (gui->default_account);
+
+	/* construct the identity */
+	identity_destroy (account->id);
+	account->id = g_new0 (MailConfigIdentity, 1);
+	account->id->name = e_utf8_gtk_entry_get_text (gui->full_name);
+	account->id->address = e_utf8_gtk_entry_get_text (gui->email_address);
+	account->id->organization = e_utf8_gtk_entry_get_text (gui->organization);
+	account->id->signature = gnome_file_entry_get_full_path (gui->signature, TRUE);
+
+	service_destroy (account->source);
+	account->source = g_new0 (MailConfigService, 1);
+	save_service (&gui->source, gui->extra_config, account->source);
+	account->source->auto_check = gtk_toggle_button_get_active (gui->source_auto_check);
+	if (account->source->auto_check)
+		account->source->auto_check_time = gtk_spin_button_get_value_as_int (gui->source_auto_check_min);
+
+	service_destroy (account->transport);
+	account->transport = g_new0 (MailConfigService, 1);
+	save_service (&gui->transport, NULL, account->transport);
+
+	return TRUE;
+}
+
+void
+mail_account_gui_destroy (MailAccountGui *gui)
+{
+	gtk_object_unref (GTK_OBJECT (gui->xml));
+	if (gui->extra_config)
+		g_hash_table_destroy (gui->extra_config);
+}
+