X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fhildon2%2Fmodest-easysetup-wizard-dialog.c;h=c092e6da9f3766aced4cde25769612fc19e1ee4c;hp=8ddc97220a08a14d178a2aba6f702d2a7f2ee8cd;hb=9cd941f1ee840ecf27fe97029a9090447b3dcbd5;hpb=8e88511ff8e810825a3c79f3f3a3cd0add92e520 diff --git a/src/hildon2/modest-easysetup-wizard-dialog.c b/src/hildon2/modest-easysetup-wizard-dialog.c index 8ddc972..c092e6d 100644 --- a/src/hildon2/modest-easysetup-wizard-dialog.c +++ b/src/hildon2/modest-easysetup-wizard-dialog.c @@ -34,15 +34,14 @@ #include #include #include -#include #include #include #include #include #include #include "modest-country-picker.h" -#include "modest-easysetup-provider-combo-box.h" -#include "modest-easysetup-servertype-combo-box.h" +#include "modest-provider-picker.h" +#include "modest-servertype-picker.h" #include "widgets/modest-validating-entry.h" #include "modest-text-utils.h" #include "modest-conf.h" @@ -59,7 +58,7 @@ #include "modest-utils.h" #include "modest-hildon-includes.h" #include "modest-maemo-security-options-view.h" -#include +#include "modest-account-protocol.h" /* Include config.h so that _() works: */ #ifdef HAVE_CONFIG_H @@ -72,6 +71,9 @@ G_DEFINE_TYPE (ModestEasysetupWizardDialog, modest_easysetup_wizard_dialog, MODE MODEST_TYPE_EASYSETUP_WIZARD_DIALOG, \ ModestEasysetupWizardDialogPrivate)) +#define LABELS_WIDTH 480 +#define DIALOG_WIDTH LABELS_WIDTH + MODEST_MARGIN_DOUBLE + typedef struct _ModestEasysetupWizardDialogPrivate ModestEasysetupWizardDialogPrivate; @@ -101,10 +103,16 @@ struct _ModestEasysetupWizardDialogPrivate /* notebook pages: */ GtkWidget *page_welcome; + GtkWidget *check_support_progress; + gboolean check_support_done; + guint check_support_show_progress_id; + guint check_support_progress_pulse_id; + gint pending_check_support; + gboolean destroyed; GtkWidget *page_account_details; GtkWidget *account_country_picker; - GtkWidget *combo_account_serviceprovider; + GtkWidget *account_serviceprovider_picker; GtkWidget *entry_account_title; GtkWidget *page_user_details; @@ -116,7 +124,7 @@ struct _ModestEasysetupWizardDialogPrivate GtkWidget *page_complete_easysetup; GtkWidget *page_custom_incoming; - GtkWidget *combo_incoming_servertype; + GtkWidget *incoming_servertype_picker; GtkWidget *caption_incoming; GtkWidget *entry_incomingserver; @@ -126,8 +134,6 @@ struct _ModestEasysetupWizardDialogPrivate GtkWidget *page_custom_outgoing; GtkWidget *entry_outgoingserver; - GtkWidget *combo_outgoing_security; - GtkWidget *combo_outgoing_auth; GtkWidget *checkbox_outgoing_smtp_specific; GtkWidget *button_outgoing_smtp_servers; @@ -139,6 +145,16 @@ struct _ModestEasysetupWizardDialogPrivate static void save_to_settings (ModestEasysetupWizardDialog *self); static void real_enable_buttons (ModestWizardDialog *dialog, gboolean enable_next); +static void on_update_model (ModestWizardDialog *dialog); +static gboolean on_save (ModestWizardDialog *dialog); +static GList* check_for_supported_auth_methods (ModestEasysetupWizardDialog* self); +static gboolean check_has_supported_auth_methods(ModestEasysetupWizardDialog* self); +static void check_support_callback (ModestAccountProtocol *protocol, + gboolean supported, + gpointer userdata); +static void check_support_of_protocols (ModestEasysetupWizardDialog *self); +static gboolean check_support_show_progress (gpointer userdata); +static gboolean check_support_progress_pulse (gpointer userdata); static gboolean on_delete_event (GtkWidget *widget, @@ -160,6 +176,19 @@ on_easysetup_changed(GtkWidget* widget, ModestEasysetupWizardDialog* wizard) static void modest_easysetup_wizard_dialog_dispose (GObject *object) { + ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (object); + priv->destroyed = TRUE; + + if (priv->check_support_show_progress_id > 0) { + g_source_remove (priv->check_support_show_progress_id); + priv->check_support_show_progress_id = 0; + } + + if (priv->check_support_progress_pulse_id > 0) { + g_source_remove (priv->check_support_progress_pulse_id); + priv->check_support_progress_pulse_id = 0; + } + if (G_OBJECT_CLASS (modest_easysetup_wizard_dialog_parent_class)->dispose) G_OBJECT_CLASS (modest_easysetup_wizard_dialog_parent_class)->dispose (object); } @@ -169,10 +198,10 @@ modest_easysetup_wizard_dialog_finalize (GObject *object) { ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (object); ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); - + if (priv->account_manager) g_object_unref (G_OBJECT (priv->account_manager)); - + if (priv->presets) modest_presets_destroy (priv->presets); @@ -183,7 +212,7 @@ modest_easysetup_wizard_dialog_finalize (GObject *object) modest_signal_mgr_disconnect_all_and_destroy (priv->missing_data_signals); priv->missing_data_signals = NULL; } - + G_OBJECT_CLASS (modest_easysetup_wizard_dialog_parent_class)->finalize (object); } @@ -193,7 +222,7 @@ create_subsequent_easysetup_pages (ModestEasysetupWizardDialog *self); static void set_default_custom_servernames(ModestEasysetupWizardDialog *dialog); -static void on_combo_servertype_changed(GtkComboBox *combobox, gpointer user_data); +static void on_servertype_selector_changed(HildonTouchSelector *selector, gint column, gpointer user_data); static gint get_port_from_protocol (ModestProtocolType server_type, @@ -214,105 +243,20 @@ get_port_from_protocol (ModestProtocolType server_type, return server_port; } -/* static GList* */ -/* check_for_supported_auth_methods (ModestEasysetupWizardDialog* self) */ -/* { */ -/* GError *error = NULL; */ -/* ModestProtocolType protocol_type; */ -/* const gchar* hostname; */ -/* const gchar* username; */ -/* ModestProtocolType security_protocol_incoming_type; */ -/* ModestProtocolRegistry *registry; */ -/* int port_num; */ -/* GList *list_auth_methods; */ -/* ModestEasysetupWizardDialogPrivate *priv; */ - -/* priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); */ -/* registry = modest_runtime_get_protocol_registry (); */ -/* protocol_type = easysetup_servertype_combo_box_get_active_servertype ( */ -/* EASYSETUP_SERVERTYPE_COMBO_BOX (priv->combo_incoming_servertype)); */ -/* hostname = gtk_entry_get_text(GTK_ENTRY(priv->entry_incomingserver)); */ -/* username = gtk_entry_get_text(GTK_ENTRY(priv->entry_user_username)); */ -/* security_protocol_incoming_type = modest_serversecurity_combo_box_get_active_serversecurity */ -/* (MODEST_SERVERSECURITY_COMBO_BOX (priv->combo_incoming_security)); */ -/* port_num = get_port_from_protocol(protocol_type, FALSE); */ -/* list_auth_methods = modest_utils_get_supported_secure_authentication_methods (protocol_type, hostname, port_num, */ -/* username, GTK_WINDOW (self), &error); */ - -/* if (list_auth_methods) { */ -/* /\* TODO: Select the correct method *\/ */ -/* GList* list = NULL; */ -/* GList* method; */ -/* for (method = list_auth_methods; method != NULL; method = g_list_next(method)) { */ -/* ModestProtocolType auth_protocol_type = (ModestProtocolType) (GPOINTER_TO_INT(method->data)); */ -/* if (modest_protocol_registry_protocol_type_has_tag (registry, auth_protocol_type, */ -/* MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS)) { */ -/* list = g_list_append(list, GINT_TO_POINTER(auth_protocol_type)); */ -/* } */ -/* } */ - -/* g_list_free(list_auth_methods); */ - -/* if (list) */ -/* return list; */ -/* } */ - -/* if(error == NULL || error->domain != modest_utils_get_supported_secure_authentication_error_quark() || */ -/* error->code != MODEST_UTILS_GET_SUPPORTED_SECURE_AUTHENTICATION_ERROR_CANCELED) */ -/* { */ -/* modest_platform_information_banner (GTK_WIDGET(self), NULL, */ -/* _("mcen_ib_unableto_discover_auth_methods")); */ -/* } */ - -/* if(error != NULL) */ -/* g_error_free(error); */ - -/* return NULL; */ -/* } */ - -/* static gboolean check_has_supported_auth_methods(ModestEasysetupWizardDialog* self) */ -/* { */ -/* GList* methods = check_for_supported_auth_methods(self); */ -/* if (!methods) */ -/* { */ -/* return FALSE; */ -/* } */ - -/* g_list_free(methods); */ -/* return TRUE; */ -/* } */ - -/* static ModestProtocolType check_first_supported_auth_method(ModestEasysetupWizardDialog* self) */ -/* { */ -/* ModestProtocolType result; */ - -/* result = MODEST_PROTOCOLS_AUTH_PASSWORD; */ - -/* GList* methods = check_for_supported_auth_methods(self); */ -/* if (methods) */ -/* { */ -/* /\* Use the first one: *\/ */ -/* result = (ModestProtocolType) (GPOINTER_TO_INT(methods->data)); */ -/* g_list_free(methods); */ -/* } */ - -/* return result; */ -/* } */ - static void invoke_enable_buttons_vfunc (ModestEasysetupWizardDialog *wizard_dialog) { ModestWizardDialogClass *klass = MODEST_WIZARD_DIALOG_GET_CLASS (wizard_dialog); - + /* Call the vfunc, which may be overridden by derived classes: */ if (klass->enable_buttons) { GtkNotebook *notebook = NULL; g_object_get (wizard_dialog, "wizard-notebook", ¬ebook, NULL); - + const gint current_page_num = gtk_notebook_get_current_page (notebook); if (current_page_num == -1) return; - + GtkWidget* current_page_widget = gtk_notebook_get_nth_page (notebook, current_page_num); (*(klass->enable_buttons))(MODEST_WIZARD_DIALOG (wizard_dialog), current_page_widget); } @@ -321,9 +265,28 @@ invoke_enable_buttons_vfunc (ModestEasysetupWizardDialog *wizard_dialog) static void on_caption_entry_changed (GtkEditable *editable, gpointer user_data) { - ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); - g_assert(self); + ModestEasysetupWizardDialog *self; + gboolean mandatory, empty; + ModestEasysetupWizardDialogPrivate *priv; + + g_return_if_fail (user_data); + + self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); + priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + invoke_enable_buttons_vfunc(self); + + empty = !g_utf8_collate (gtk_entry_get_text (GTK_ENTRY (editable)), ""); + mandatory = ((GtkWidget *) editable == priv->entry_account_title) || + ((GtkWidget *) editable == priv->entry_user_username) || + ((GtkWidget *) editable == priv->entry_user_email); + + /* Show a banner & get focus */ + if (empty && mandatory) { + modest_platform_information_banner ((GtkWidget *) editable, NULL, + _CS("ckct_ib_enter_some_text")); + gtk_widget_grab_focus (GTK_WIDGET (editable)); + } } static void @@ -342,31 +305,56 @@ on_picker_button_value_changed (HildonPickerButton *widget, gpointer user_data) invoke_enable_buttons_vfunc(self); } +static void +on_serviceprovider_picker_button_value_changed (HildonPickerButton *widget, gpointer user_data) +{ + gchar* default_account_name_start; + gchar* default_account_name; + ModestEasysetupWizardDialog *self; + ModestEasysetupWizardDialogPrivate *priv; + ModestProviderPickerIdType provider_id_type; + + self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); + priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + + on_picker_button_value_changed (widget, user_data); + + provider_id_type = modest_provider_picker_get_active_id_type ( + MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker)); + if (provider_id_type == MODEST_PROVIDER_PICKER_ID_OTHER) { + default_account_name_start = g_strdup (_("mcen_ia_emailsetup_defaultname")); + } else { + GtkWidget *selector; + + selector = GTK_WIDGET (hildon_picker_button_get_selector (HILDON_PICKER_BUTTON (widget))); + default_account_name_start = + g_strdup (hildon_touch_selector_get_current_text (HILDON_TOUCH_SELECTOR (selector))); + + } + default_account_name = modest_account_mgr_get_unused_account_display_name ( + priv->account_manager, default_account_name_start); + g_free (default_account_name_start); + default_account_name_start = NULL; + + hildon_entry_set_text (HILDON_ENTRY (priv->entry_account_title), default_account_name); + g_free (default_account_name); +} + /** This is a convenience function to create a caption containing a mandatory widget. * When the widget is edited, the enable_buttons() vfunc will be called. */ static GtkWidget* -create_caption_new_with_asterisk (ModestEasysetupWizardDialog *self, - GtkSizeGroup *group, - const gchar *value, - GtkWidget *control, - GtkWidget *icon, - HildonCaptionStatus flag) -{ - GtkWidget *caption = NULL; - - /* Note: Previously, the translated strings already contained the "*", - * Comment out this code if they do again. - */ - /* Add a * character to indicate mandatory fields, - * as specified in our "Email UI Specification": */ - if (flag == HILDON_CAPTION_MANDATORY) { - gchar* title = g_strdup_printf("%s*", value); - caption = hildon_caption_new (group, title, control, icon, flag); - g_free(title); - } - else - caption = hildon_caption_new (group, value, control, icon, flag); +create_captioned (ModestEasysetupWizardDialog *self, + GtkSizeGroup *title_size_group, + GtkSizeGroup *value_size_group, + const gchar *value, + gboolean use_markup, + GtkWidget *control) +{ + + GtkWidget *result; + result = modest_maemo_utils_create_captioned (title_size_group, value_size_group, + value, use_markup, control); /* Connect to the appropriate changed signal for the widget, * so we can ask for the prev/next buttons to be enabled/disabled appropriately: @@ -381,18 +369,26 @@ create_caption_new_with_asterisk (ModestEasysetupWizardDialog *self, G_CALLBACK (on_caption_combobox_changed), self); } - return caption; + return result; } static GtkWidget* create_page_welcome (ModestEasysetupWizardDialog *self) { - GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); - GtkWidget *label = gtk_label_new(_("mcen_ia_emailsetup_intro")); + GtkWidget *box; + GtkWidget *label; + ModestEasysetupWizardDialogPrivate *priv; + + priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); + label = gtk_label_new(_("mcen_ia_emailsetup_intro")); + priv->check_support_progress = gtk_progress_bar_new (); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); /* So that it is not truncated: */ - gtk_widget_set_size_request (label, 600, -1); + gtk_widget_set_size_request (label, LABELS_WIDTH, -1); + gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); + gtk_box_pack_end (GTK_BOX (box), priv->check_support_progress, FALSE, FALSE, 0); gtk_widget_show (label); gtk_widget_show (GTK_WIDGET (box)); return GTK_WIDGET (box); @@ -407,41 +403,55 @@ on_account_country_selector_changed (HildonTouchSelector *widget, gint column, g priv->dirty = TRUE; - /* Fill the providers combo, based on the selected country: */ + /* Fill the providers picker, based on the selected country: */ if (priv->presets != NULL) { gint mcc = modest_country_picker_get_active_country_mcc ( MODEST_COUNTRY_PICKER (priv->account_country_picker)); - easysetup_provider_combo_box_fill ( - EASYSETUP_PROVIDER_COMBO_BOX (priv->combo_account_serviceprovider), priv->presets, mcc); + modest_provider_picker_fill ( + MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker), priv->presets, mcc); + } +} + +static void +update_user_email_from_provider (ModestEasysetupWizardDialog *self) +{ + ModestEasysetupWizardDialogPrivate *priv; + gchar* provider_id = NULL, *with_at = NULL; + + g_assert(self); + priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + + /* Fill the providers combo, based on the selected country: */ + provider_id = modest_provider_picker_get_active_provider_id ( + MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker)); + + if (provider_id) { + gchar *domain_name = modest_presets_get_domain (priv->presets, provider_id); + with_at = g_strdup_printf ("%c%s", '@', domain_name); + g_free (domain_name); } + + /* The sample address already contains the '@' */ + if (!with_at) + with_at = g_strdup (MODEST_EXAMPLE_EMAIL_ADDRESS); + + if (priv->entry_user_email) + hildon_entry_set_text (HILDON_ENTRY (priv->entry_user_email), with_at); + + g_free (with_at); + g_free (provider_id); } static void -on_combo_account_serviceprovider (GtkComboBox *widget, gpointer user_data) +on_account_serviceprovider_selector_changed (HildonTouchSelector *widget, gint column, gpointer user_data) { ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); g_assert(self); ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); priv->dirty = TRUE; - - /* Fill the providers combo, based on the selected country: */ - gchar* provider_id = easysetup_provider_combo_box_get_active_provider_id ( - EASYSETUP_PROVIDER_COMBO_BOX (priv->combo_account_serviceprovider)); - - gchar* domain_name = NULL; - if(provider_id) - domain_name = modest_presets_get_domain (priv->presets, provider_id); - - if(!domain_name) - domain_name = g_strdup (MODEST_EXAMPLE_EMAIL_ADDRESS); - - if (priv->entry_user_email) - gtk_entry_set_text (GTK_ENTRY (priv->entry_user_email), domain_name); - - g_free (domain_name); - - g_free (provider_id); + + update_user_email_from_provider (self); } static void @@ -460,46 +470,40 @@ create_page_account_details (ModestEasysetupWizardDialog *self) ModestEasysetupWizardDialogPrivate* priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); - gtk_widget_set_size_request (label, 600, -1); + gtk_widget_set_size_request (label, LABELS_WIDTH, -1); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, MODEST_MARGIN_HALF); gtk_widget_show (label); /* 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); + GtkSizeGroup* title_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); + GtkSizeGroup* value_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); /* The country widgets: */ - priv->account_country_picker = GTK_WIDGET (modest_country_picker_new ()); - hildon_button_set_title (HILDON_BUTTON (priv->account_country_picker), _("mcen_fi_country")); + priv->account_country_picker = GTK_WIDGET (modest_country_picker_new (MODEST_EDITABLE_SIZE, + HILDON_BUTTON_ARRANGEMENT_HORIZONTAL)); + modest_maemo_utils_set_hbutton_layout (title_sizegroup, value_sizegroup, + _("mcen_fi_country"), priv->account_country_picker); g_signal_connect (G_OBJECT (priv->account_country_picker), "value-changed", G_CALLBACK (on_picker_button_value_changed), self); gtk_box_pack_start (GTK_BOX (box), priv->account_country_picker, FALSE, FALSE, MODEST_MARGIN_HALF); gtk_widget_show (priv->account_country_picker); - /* connect to country combo's changed signal, so we can fill the provider combo: */ - g_signal_connect (G_OBJECT (hildon_picker_button_get_selector - (HILDON_PICKER_BUTTON (priv->account_country_picker))), - "changed", - G_CALLBACK (on_account_country_selector_changed), self); - GtkWidget *separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box), separator, FALSE, FALSE, MODEST_MARGIN_HALF); gtk_widget_show (separator); /* The service provider widgets: */ - priv->combo_account_serviceprovider = GTK_WIDGET (easysetup_provider_combo_box_new ()); - gtk_widget_set_size_request (priv->combo_account_serviceprovider, 320, -1); - - caption = create_caption_new_with_asterisk (self, sizegroup, _("mcen_fi_serviceprovider"), - priv->combo_account_serviceprovider, NULL, HILDON_CAPTION_OPTIONAL); - gtk_widget_show (priv->combo_account_serviceprovider); - gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF); - gtk_widget_show (caption); - - /* connect to providers combo's changed signal, so we can fill the email address: */ - g_signal_connect (G_OBJECT (priv->combo_account_serviceprovider), "changed", - G_CALLBACK (on_combo_account_serviceprovider), self); + priv->account_serviceprovider_picker = GTK_WIDGET (modest_provider_picker_new (MODEST_EDITABLE_SIZE, + HILDON_BUTTON_ARRANGEMENT_HORIZONTAL)); + modest_maemo_utils_set_hbutton_layout (title_sizegroup, value_sizegroup, + _("mcen_fi_serviceprovider"), + priv->account_serviceprovider_picker); + g_signal_connect (G_OBJECT (priv->account_serviceprovider_picker), "value-changed", + G_CALLBACK (on_serviceprovider_picker_button_value_changed), self); + gtk_box_pack_start (GTK_BOX (box), priv->account_serviceprovider_picker, FALSE, FALSE, MODEST_MARGIN_HALF); + gtk_widget_show (priv->account_serviceprovider_picker); /* The description widgets: */ priv->entry_account_title = GTK_WIDGET (modest_validating_entry_new ()); @@ -517,12 +521,12 @@ create_page_account_details (ModestEasysetupWizardDialog *self) g_free (default_account_name_start); default_account_name_start = NULL; - gtk_entry_set_text( GTK_ENTRY (priv->entry_account_title), default_account_name); + hildon_entry_set_text (HILDON_ENTRY (priv->entry_account_title), default_account_name); g_free (default_account_name); default_account_name = NULL; - caption = create_caption_new_with_asterisk (self, sizegroup, _("mcen_fi_account_title"), - priv->entry_account_title, NULL, HILDON_CAPTION_MANDATORY); + caption = create_captioned (self, title_sizegroup, value_sizegroup, _("mcen_fi_account_title"), FALSE, + priv->entry_account_title); gtk_widget_show (priv->entry_account_title); gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF); gtk_widget_show (caption); @@ -555,6 +559,9 @@ create_page_account_details (ModestEasysetupWizardDialog *self) on_entry_max, self); gtk_widget_show (GTK_WIDGET (box)); + + g_object_unref (title_sizegroup); + g_object_unref (value_sizegroup); return GTK_WIDGET (box); } @@ -562,7 +569,8 @@ create_page_account_details (ModestEasysetupWizardDialog *self) static GtkWidget* create_page_user_details (ModestEasysetupWizardDialog *self) { - GtkSizeGroup* sizegroup; + GtkSizeGroup* title_sizegroup; + GtkSizeGroup* value_sizegroup; GtkWidget *box; ModestEasysetupWizardDialogPrivate *priv; @@ -572,7 +580,8 @@ create_page_user_details (ModestEasysetupWizardDialog *self) * 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. */ box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); - sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); + title_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); + value_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); /* The name widgets: (use auto cap) */ priv->entry_user_name = GTK_WIDGET (modest_validating_entry_new ()); @@ -584,8 +593,8 @@ create_page_user_details (ModestEasysetupWizardDialog *self) gtk_entry_set_max_length (GTK_ENTRY (priv->entry_user_name), 64); modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (priv->entry_user_name), on_entry_max, self); - GtkWidget *caption = create_caption_new_with_asterisk (self, sizegroup, - _("mcen_li_emailsetup_name"), priv->entry_user_name, NULL, HILDON_CAPTION_OPTIONAL); + GtkWidget *caption = create_captioned (self, title_sizegroup, value_sizegroup, + _("mcen_li_emailsetup_name"), FALSE, priv->entry_user_name); g_signal_connect(G_OBJECT(priv->entry_user_name), "changed", G_CALLBACK(on_easysetup_changed), self); gtk_widget_show (priv->entry_user_name); @@ -608,9 +617,8 @@ create_page_user_details (ModestEasysetupWizardDialog *self) /* Auto-capitalization is the default, so let's turn it off: */ hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_user_username), HILDON_GTK_INPUT_MODE_FULL); - caption = create_caption_new_with_asterisk (self, sizegroup, _("mail_fi_username"), - priv->entry_user_username, - NULL, HILDON_CAPTION_MANDATORY); + caption = create_captioned (self, title_sizegroup, value_sizegroup, _("mail_fi_username"), FALSE, + priv->entry_user_username); gtk_widget_show (priv->entry_user_username); gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF); g_signal_connect(G_OBJECT(priv->entry_user_username), "changed", @@ -619,8 +627,6 @@ create_page_user_details (ModestEasysetupWizardDialog *self) /* Prevent the use of some characters in the username, * as required by our UI specification: */ - modest_validating_entry_set_unallowed_characters_whitespace ( - MODEST_VALIDATING_ENTRY (priv->entry_user_username)); modest_validating_entry_set_func(MODEST_VALIDATING_ENTRY(priv->entry_user_username), modest_utils_on_entry_invalid_character, self); @@ -631,14 +637,14 @@ create_page_user_details (ModestEasysetupWizardDialog *self) on_entry_max, self); /* The password widgets: */ - priv->entry_user_password = gtk_entry_new (); + priv->entry_user_password = hildon_entry_new (MODEST_EDITABLE_SIZE); /* Auto-capitalization is the default, so let's turn it off: */ hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_user_password), HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE); gtk_entry_set_visibility (GTK_ENTRY (priv->entry_user_password), FALSE); /* gtk_entry_set_invisible_char (GTK_ENTRY (priv->entry_user_password), '*'); */ - caption = create_caption_new_with_asterisk (self, sizegroup, - _("mail_fi_password"), priv->entry_user_password, NULL, HILDON_CAPTION_OPTIONAL); + caption = create_captioned (self, title_sizegroup, value_sizegroup, + _("mail_fi_password"), FALSE, priv->entry_user_password); g_signal_connect(G_OBJECT(priv->entry_user_password), "changed", G_CALLBACK(on_easysetup_changed), self); gtk_widget_show (priv->entry_user_password); @@ -649,9 +655,9 @@ create_page_user_details (ModestEasysetupWizardDialog *self) priv->entry_user_email = 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 (priv->entry_user_email), HILDON_GTK_INPUT_MODE_FULL); - caption = create_caption_new_with_asterisk (self, sizegroup, - _("mcen_li_emailsetup_email_address"), priv->entry_user_email, NULL, HILDON_CAPTION_MANDATORY); - gtk_entry_set_text (GTK_ENTRY (priv->entry_user_email), MODEST_EXAMPLE_EMAIL_ADDRESS); /* Default text. */ + caption = create_captioned (self, title_sizegroup, value_sizegroup, + _("mcen_li_emailsetup_email_address"), FALSE, priv->entry_user_email); + update_user_email_from_provider (self); gtk_widget_show (priv->entry_user_email); gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF); g_signal_connect(G_OBJECT(priv->entry_user_email), "changed", @@ -666,33 +672,33 @@ create_page_user_details (ModestEasysetupWizardDialog *self) gtk_widget_show (GTK_WIDGET (box)); - + g_object_unref (title_sizegroup); + g_object_unref (value_sizegroup); + return GTK_WIDGET (box); } -static GtkWidget* +static GtkWidget* create_page_complete_easysetup (ModestEasysetupWizardDialog *self) { GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); - + GtkWidget *label = gtk_label_new(_("mcen_ia_emailsetup_setup_complete")); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); - gtk_widget_set_size_request (label, 600, -1); + gtk_widget_set_size_request (label, LABELS_WIDTH, -1); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); - /* The documentation for gtk_label_set_line_wrap() says that we must - * call gtk_widget_set_size_request() with a hard-coded width, - * though I wonder why gtk_label_set_max_width_chars() isn't enough. */ + gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_widget_show (label); - + label = gtk_label_new (_("mcen_ia_easysetup_complete")); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); - gtk_widget_set_size_request (label, 600, -1); - + gtk_widget_set_size_request (label, LABELS_WIDTH, -1); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_widget_show (label); - + gtk_widget_show (GTK_WIDGET (box)); return GTK_WIDGET (box); } @@ -709,19 +715,25 @@ update_incoming_server_title (ModestEasysetupWizardDialog *self) priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); protocol_registry = modest_runtime_get_protocol_registry (); - - protocol_type = easysetup_servertype_combo_box_get_active_servertype ( - EASYSETUP_SERVERTYPE_COMBO_BOX (priv->combo_incoming_servertype)); + + protocol_type = modest_servertype_picker_get_active_servertype ( + MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker)); /* This could happen when the combo box has still no active iter */ if (protocol_type != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) { gchar* incomingserver_title; - const gchar *protocol_display_name; + const gchar *protocol_display_name; + ModestProtocol *protocol; + + protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, + protocol_type); + protocol_display_name = modest_protocol_get_display_name (protocol); + + incomingserver_title = g_strconcat (_("mcen_li_emailsetup_servertype"), "\n(", + protocol_display_name, ")", NULL); + + modest_maemo_utils_captioned_set_label (priv->caption_incoming, incomingserver_title, TRUE); - protocol_display_name = modest_protocol_get_display_name (modest_protocol_registry_get_protocol_by_type (protocol_registry, protocol_type)); - - incomingserver_title = g_strdup_printf(_("mcen_li_emailsetup_servertype"), protocol_display_name); - g_object_set (G_OBJECT (priv->caption_incoming), "label", incomingserver_title, NULL); g_free(incomingserver_title); } } @@ -733,14 +745,14 @@ static void update_incoming_server_security_choices (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); - EasysetupServertypeComboBox *server_type_combo; + ModestServertypePicker *server_type_picker; ModestProtocolType protocol_type; ModestSecurityOptionsView *view; - server_type_combo = - EASYSETUP_SERVERTYPE_COMBO_BOX (priv->combo_incoming_servertype); + server_type_picker = + MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker); protocol_type = - easysetup_servertype_combo_box_get_active_servertype (server_type_combo); + modest_servertype_picker_get_active_servertype (server_type_picker); /* Fill the combo with appropriately titled choices for all those protocols */ @@ -749,11 +761,11 @@ update_incoming_server_security_choices (ModestEasysetupWizardDialog *self) } static void -on_combo_servertype_changed(GtkComboBox *combobox, gpointer user_data) +on_servertype_selector_changed(HildonTouchSelector *selector, gint column, gpointer user_data) { ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); - EasysetupServertypeComboBox *combo; + ModestServertypePicker *picker; ModestProtocolType protocol_type; priv->dirty = TRUE; @@ -762,8 +774,8 @@ on_combo_servertype_changed(GtkComboBox *combobox, gpointer user_data) update_incoming_server_title (self); /* Update security options if needed */ - combo = EASYSETUP_SERVERTYPE_COMBO_BOX (combobox); - protocol_type = easysetup_servertype_combo_box_get_active_servertype (combo); + picker = MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker); + protocol_type = modest_servertype_picker_get_active_servertype (picker); update_incoming_server_security_choices (self); gtk_widget_show (priv->incoming_security); @@ -785,42 +797,41 @@ create_page_custom_incoming (ModestEasysetupWizardDialog *self) ModestProtocolRegistry *protocol_registry; ModestEasysetupWizardDialogPrivate* priv; GtkWidget *box; - GtkWidget *scrolled_window; + GtkWidget *pannable; GtkWidget *label; - GtkSizeGroup *sizegroup; - GtkWidget *caption; + GtkSizeGroup *title_sizegroup; + GtkSizeGroup *value_sizegroup; priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); protocol_registry = modest_runtime_get_protocol_registry (); box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); - scrolled_window = gtk_scrolled_window_new (NULL, NULL); - - gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), - GTK_POLICY_NEVER, - GTK_POLICY_AUTOMATIC); + pannable = hildon_pannable_area_new (); /* Show note that account type cannot be changed in future: */ label = gtk_label_new (_("mcen_ia_emailsetup_account_type")); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); - gtk_widget_set_size_request (label, 600, -1); + gtk_widget_set_size_request (label, LABELS_WIDTH, -1); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_widget_show (label); /* 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. */ - sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); + title_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); + value_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); /* The incoming server widgets: */ - priv->combo_incoming_servertype = GTK_WIDGET (easysetup_servertype_combo_box_new (TRUE)); - caption = create_caption_new_with_asterisk (self, sizegroup, - _("mcen_li_emailsetup_type"), priv->combo_incoming_servertype, NULL, HILDON_CAPTION_MANDATORY); - gtk_widget_show (priv->combo_incoming_servertype); - gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF); - gtk_widget_show (caption); + priv->incoming_servertype_picker = GTK_WIDGET (modest_servertype_picker_new (MODEST_EDITABLE_SIZE, + HILDON_BUTTON_ARRANGEMENT_HORIZONTAL, + TRUE)); + hildon_button_set_title (HILDON_BUTTON (priv->incoming_servertype_picker), _("mcen_li_emailsetup_type")); + g_signal_connect (G_OBJECT (priv->incoming_servertype_picker), "value-changed", + G_CALLBACK (on_picker_button_value_changed), self); + gtk_box_pack_start (GTK_BOX (box), priv->incoming_servertype_picker, FALSE, FALSE, MODEST_MARGIN_HALF); + gtk_widget_show (priv->incoming_servertype_picker); - priv->entry_incomingserver = gtk_entry_new (); + priv->entry_incomingserver = hildon_entry_new (MODEST_EDITABLE_SIZE); g_signal_connect(G_OBJECT(priv->entry_incomingserver), "changed", G_CALLBACK(on_easysetup_changed), self); /* Auto-capitalization is the default, so let's turn it off: */ hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_incomingserver), HILDON_GTK_INPUT_MODE_FULL); @@ -828,11 +839,9 @@ create_page_custom_incoming (ModestEasysetupWizardDialog *self) /* The caption title will be updated in update_incoming_server_title(). * so this default text will never be seen: */ - /* (Note: Changing the title seems pointless. murrayc) */ - priv->caption_incoming = create_caption_new_with_asterisk (self, sizegroup, - "Incoming Server", - priv->entry_incomingserver, - NULL, HILDON_CAPTION_MANDATORY); + priv->caption_incoming = create_captioned (self, title_sizegroup, value_sizegroup, + "This will be removed", + FALSE, priv->entry_incomingserver); update_incoming_server_title (self); gtk_widget_show (priv->entry_incomingserver); gtk_box_pack_start (GTK_BOX (box), priv->caption_incoming, FALSE, FALSE, MODEST_MARGIN_HALF); @@ -840,8 +849,9 @@ create_page_custom_incoming (ModestEasysetupWizardDialog *self) /* Change the caption title when the servertype changes, * as in the UI spec: */ - g_signal_connect (G_OBJECT (priv->combo_incoming_servertype), "changed", - G_CALLBACK (on_combo_servertype_changed), self); + g_signal_connect (G_OBJECT (hildon_picker_button_get_selector (HILDON_PICKER_BUTTON (priv->incoming_servertype_picker))), + "changed", + G_CALLBACK (on_servertype_selector_changed), self); /* Remember when the servername was changed manually: */ g_signal_connect (G_OBJECT (priv->entry_incomingserver), "changed", @@ -851,44 +861,48 @@ create_page_custom_incoming (ModestEasysetupWizardDialog *self) protocols with security */ priv->incoming_security = modest_maemo_security_options_view_new (MODEST_SECURITY_OPTIONS_INCOMING, - FALSE, sizegroup); + FALSE, title_sizegroup, value_sizegroup); gtk_box_pack_start (GTK_BOX (box), priv->incoming_security, FALSE, FALSE, MODEST_MARGIN_HALF); + gtk_widget_show_all (priv->incoming_security); /* Set default selection */ - easysetup_servertype_combo_box_set_active_servertype ( - EASYSETUP_SERVERTYPE_COMBO_BOX (priv->combo_incoming_servertype), + modest_servertype_picker_set_active_servertype ( + MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker), MODEST_PROTOCOLS_STORE_POP); - gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box); + hildon_pannable_area_add_with_viewport (HILDON_PANNABLE_AREA (pannable), box); gtk_container_set_focus_vadjustment (GTK_CONTAINER (box), - gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window))); + hildon_pannable_area_get_vadjustment (HILDON_PANNABLE_AREA (pannable))); gtk_widget_show (GTK_WIDGET (box)); - gtk_widget_show (scrolled_window); + gtk_widget_show (pannable); + + g_object_unref (title_sizegroup); + g_object_unref (value_sizegroup); - return GTK_WIDGET (scrolled_window); + return GTK_WIDGET (pannable); } static void -on_toggle_button_changed (GtkToggleButton *togglebutton, gpointer user_data) +on_check_button_changed (HildonCheckButton *button, gpointer user_data) { GtkWidget *widget = GTK_WIDGET (user_data); - /* Enable the widget only if the toggle button is active: */ - const gboolean enable = gtk_toggle_button_get_active (togglebutton); + /* Enable the widget only if the check button is active: */ + const gboolean enable = hildon_check_button_get_active (button); gtk_widget_set_sensitive (widget, enable); } -/* Make the sensitivity of a widget depend on a toggle button. +/* Make the sensitivity of a widget depend on a check button. */ static void -enable_widget_for_togglebutton (GtkWidget *widget, GtkToggleButton* button) +enable_widget_for_checkbutton (GtkWidget *widget, HildonCheckButton* button) { g_signal_connect (G_OBJECT (button), "toggled", - G_CALLBACK (on_toggle_button_changed), widget); + G_CALLBACK (on_check_button_changed), widget); /* Set the starting sensitivity: */ - on_toggle_button_changed (button, widget); + on_check_button_changed (button, widget); } static void @@ -907,7 +921,7 @@ on_button_outgoing_smtp_servers (GtkButton *button, gpointer user_data) modest_connection_specific_smtp_window_fill_with_connections (MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window), priv->account_manager); /* Show the window */ - modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (specific_window)); + modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (specific_window), GTK_WINDOW (self)); gtk_widget_show (specific_window); } @@ -923,22 +937,29 @@ static GtkWidget* create_page_custom_outgoing (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv; + gchar *smtp_caption_label; + GtkWidget *pannable; GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); + + pannable = hildon_pannable_area_new (); /* 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); + GtkSizeGroup *title_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); + GtkSizeGroup *value_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); /* The outgoing server widgets: */ priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); - priv->entry_outgoingserver = gtk_entry_new (); + priv->entry_outgoingserver = hildon_entry_new (MODEST_EDITABLE_SIZE); g_signal_connect (G_OBJECT (priv->entry_outgoingserver), "changed", G_CALLBACK (on_easysetup_changed), self); /* Auto-capitalization is the default, so let's turn it off: */ hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_outgoingserver), HILDON_GTK_INPUT_MODE_FULL); - GtkWidget *caption = create_caption_new_with_asterisk (self, sizegroup, - _("mcen_li_emailsetup_smtp"), priv->entry_outgoingserver, NULL, HILDON_CAPTION_OPTIONAL); + smtp_caption_label = g_strconcat (_("mcen_li_emailsetup_smtp"), "\n(SMTP)", NULL); + GtkWidget *caption = create_captioned (self, title_sizegroup, value_sizegroup, + smtp_caption_label, TRUE, priv->entry_outgoingserver); + g_free (smtp_caption_label); gtk_widget_show (priv->entry_outgoingserver); gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF); gtk_widget_show (caption); @@ -948,51 +969,59 @@ create_page_custom_outgoing (ModestEasysetupWizardDialog *self) protocols with security */ priv->outgoing_security = modest_maemo_security_options_view_new (MODEST_SECURITY_OPTIONS_OUTGOING, - FALSE, sizegroup); + FALSE, title_sizegroup, value_sizegroup); gtk_box_pack_start (GTK_BOX (box), priv->outgoing_security, FALSE, FALSE, MODEST_MARGIN_HALF); gtk_widget_show (priv->outgoing_security); - + GtkWidget *separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box), separator, FALSE, FALSE, MODEST_MARGIN_HALF); gtk_widget_show (separator); - + /* connection-specific checkbox: */ - priv->checkbox_outgoing_smtp_specific = gtk_check_button_new (); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->checkbox_outgoing_smtp_specific), - FALSE); + priv->checkbox_outgoing_smtp_specific = hildon_check_button_new (HILDON_SIZE_FINGER_HEIGHT); + hildon_check_button_set_active (HILDON_CHECK_BUTTON (priv->checkbox_outgoing_smtp_specific), + FALSE); + gtk_button_set_label (GTK_BUTTON (priv->checkbox_outgoing_smtp_specific), + _("mcen_fi_advsetup_connection_smtp")); + gtk_button_set_alignment (GTK_BUTTON (priv->checkbox_outgoing_smtp_specific), + 0.0, 0.5); g_signal_connect (G_OBJECT (priv->checkbox_outgoing_smtp_specific), "toggled", G_CALLBACK (on_easysetup_changed), self); - caption = hildon_caption_new (sizegroup, _("mcen_fi_advsetup_connection_smtp"), - priv->checkbox_outgoing_smtp_specific, NULL, HILDON_CAPTION_OPTIONAL); gtk_widget_show (priv->checkbox_outgoing_smtp_specific); - gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF); - gtk_widget_show (caption); - + gtk_box_pack_start (GTK_BOX (box), priv->checkbox_outgoing_smtp_specific, + FALSE, FALSE, MODEST_MARGIN_HALF); + /* Connection-specific SMTP-Severs Edit button: */ - priv->button_outgoing_smtp_servers = gtk_button_new_with_label (_("mcen_bd_edit")); - caption = hildon_caption_new (sizegroup, _("mcen_fi_advsetup_optional_smtp"), - priv->button_outgoing_smtp_servers, NULL, HILDON_CAPTION_OPTIONAL); - hildon_caption_set_child_expand (HILDON_CAPTION (caption), FALSE); + priv->button_outgoing_smtp_servers = gtk_button_new_with_label (_("mcen_bd_advsetup_optional_smtp")); + hildon_gtk_widget_set_theme_size (priv->button_outgoing_smtp_servers, + HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH); gtk_widget_show (priv->button_outgoing_smtp_servers); - gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF); - gtk_widget_show (caption); - + gtk_box_pack_start (GTK_BOX (box), priv->button_outgoing_smtp_servers, + FALSE, FALSE, MODEST_MARGIN_HALF); + /* Only enable the button when the checkbox is checked: */ - enable_widget_for_togglebutton (priv->button_outgoing_smtp_servers, - GTK_TOGGLE_BUTTON (priv->checkbox_outgoing_smtp_specific)); - + enable_widget_for_checkbutton (priv->button_outgoing_smtp_servers, + HILDON_CHECK_BUTTON (priv->checkbox_outgoing_smtp_specific)); + g_signal_connect (G_OBJECT (priv->button_outgoing_smtp_servers), "clicked", G_CALLBACK (on_button_outgoing_smtp_servers), self); g_signal_connect (G_OBJECT (priv->entry_outgoingserver), "changed", G_CALLBACK (on_entry_outgoing_servername_changed), self); - - + + + hildon_pannable_area_add_with_viewport (HILDON_PANNABLE_AREA (pannable), box); + gtk_container_set_focus_vadjustment (GTK_CONTAINER (box), + hildon_pannable_area_get_vadjustment (HILDON_PANNABLE_AREA (pannable))); gtk_widget_show (GTK_WIDGET (box)); + gtk_widget_show (pannable); + + g_object_unref (title_sizegroup); + g_object_unref (value_sizegroup); - return GTK_WIDGET (box); + return GTK_WIDGET (pannable); } static gboolean @@ -1010,7 +1039,7 @@ show_advanced_edit(gpointer user_data) } modest_account_settings_dialog_load_settings (dialog, priv->settings); - modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog)); + modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog), GTK_WINDOW (self)); response = gtk_dialog_run (GTK_DIALOG (dialog)); @@ -1030,32 +1059,29 @@ on_button_edit_advanced_settings (GtkButton *button, gpointer user_data) static GtkWidget* create_page_complete_custom (ModestEasysetupWizardDialog *self) { - GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); + GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_DEFAULT); GtkWidget *label = gtk_label_new(_("mcen_ia_emailsetup_setup_complete")); - GtkWidget *button_edit = gtk_button_new_with_label (_("mcen_bd_edit")); + GtkWidget *button_edit = gtk_button_new_with_label (_("mcen_fi_advanced_settings")); + hildon_gtk_widget_set_theme_size (button_edit, HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); - gtk_widget_set_size_request (label, 600, -1); + gtk_widget_set_size_request (label, LABELS_WIDTH, -1); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_widget_show (label); - + label = gtk_label_new (_("mcen_ia_customsetup_complete")); - gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); - gtk_widget_set_size_request (label, 600, -1); + gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); + gtk_widget_set_size_request (label, LABELS_WIDTH, -1); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); - gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0); gtk_widget_show (label); - - GtkWidget *caption = hildon_caption_new (NULL, _("mcen_fi_advanced_settings"), - button_edit, NULL, HILDON_CAPTION_OPTIONAL); - hildon_caption_set_child_expand (HILDON_CAPTION (caption), FALSE); + gtk_widget_show (button_edit); - gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF); - gtk_widget_show (caption); - + gtk_box_pack_start (GTK_BOX (box), button_edit, FALSE, FALSE, MODEST_MARGIN_HALF); + g_signal_connect (G_OBJECT (button_edit), "clicked", G_CALLBACK (on_button_edit_advanced_settings), self); - + gtk_widget_show (GTK_WIDGET (box)); return GTK_WIDGET (box); } @@ -1100,6 +1126,43 @@ on_response_before (ModestWizardDialog *wizard_dialog, } } +static void +fill_providers (ModestEasysetupWizardDialog *self) +{ + ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + + if (MODEST_IS_COUNTRY_PICKER (priv->account_country_picker)) { +/* gint mcc = get_default_country_code(); */ + gint mcc; + /* Fill the combo in an idle call, as it takes a lot of time */ + modest_country_picker_load_data( + MODEST_COUNTRY_PICKER (priv->account_country_picker)); + /* connect to country picker's changed signal, so we can fill the provider picker: */ + g_signal_connect (G_OBJECT (hildon_picker_button_get_selector + (HILDON_PICKER_BUTTON (priv->account_country_picker))), + "changed", + G_CALLBACK (on_account_country_selector_changed), self); + + modest_country_picker_set_active_country_locale ( + MODEST_COUNTRY_PICKER (priv->account_country_picker)); + mcc = modest_country_picker_get_active_country_mcc ( + MODEST_COUNTRY_PICKER (priv->account_country_picker)); + modest_provider_picker_fill ( + MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker), + priv->presets, mcc); + /* connect to providers picker's changed signal, so we can fill the email address: */ + g_signal_connect (G_OBJECT (hildon_picker_button_get_selector + (HILDON_PICKER_BUTTON (priv->account_serviceprovider_picker))), + "changed", + G_CALLBACK (on_account_serviceprovider_selector_changed), self); + + modest_provider_picker_set_others_provider (MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker)); + } + + priv->dirty = FALSE; + +} + typedef struct IdleData { ModestEasysetupWizardDialog *dialog; ModestPresets *presets; @@ -1118,22 +1181,8 @@ presets_idle (gpointer userdata) priv->presets = idle_data->presets; - if (MODEST_IS_COUNTRY_PICKER (priv->account_country_picker)) { -/* gint mcc = get_default_country_code(); */ - gint mcc; - /* Fill the combo in an idle call, as it takes a lot of time */ - modest_country_picker_load_data( - MODEST_COUNTRY_PICKER (priv->account_country_picker)); - modest_country_picker_set_active_country_locale ( - MODEST_COUNTRY_PICKER (priv->account_country_picker)); - mcc = modest_country_picker_get_active_country_mcc ( - MODEST_COUNTRY_PICKER (priv->account_country_picker)); - easysetup_provider_combo_box_fill ( - EASYSETUP_PROVIDER_COMBO_BOX (priv->combo_account_serviceprovider), - priv->presets, mcc); - } - - priv->dirty = FALSE; + if (priv->check_support_done) + fill_providers (self); g_object_unref (idle_data->dialog); g_free (idle_data); @@ -1207,7 +1256,7 @@ static void init_incoming_page (ModestEasysetupWizardDialogPrivate *priv) { priv->page_custom_incoming = NULL; - priv->combo_incoming_servertype = NULL; + priv->incoming_servertype_picker = NULL; priv->caption_incoming = NULL; priv->entry_incomingserver = NULL; priv->entry_user_email = NULL; @@ -1219,8 +1268,6 @@ init_outgoing_page (ModestEasysetupWizardDialogPrivate *priv) { priv->page_custom_outgoing = NULL; priv->entry_outgoingserver = NULL; - priv->combo_outgoing_security = NULL; - priv->combo_outgoing_auth = NULL; priv->checkbox_outgoing_smtp_specific = NULL; priv->button_outgoing_smtp_servers = NULL; priv->outgoing_security = NULL; @@ -1234,6 +1281,7 @@ modest_easysetup_wizard_dialog_init (ModestEasysetupWizardDialog *self) /* Create the notebook to be used by the ModestWizardDialog base class: * Each page of the notebook will be a page of the wizard: */ GtkNotebook *notebook = GTK_NOTEBOOK (gtk_notebook_new()); + gtk_widget_set_size_request (GTK_WIDGET (notebook), -1, MODEST_DIALOG_WINDOW_MAX_HEIGHT); /* Set the notebook used by the ModestWizardDialog base class: */ g_object_set (G_OBJECT(self), "wizard-notebook", notebook, NULL); @@ -1256,6 +1304,11 @@ modest_easysetup_wizard_dialog_init (ModestEasysetupWizardDialog *self) g_object_ref (priv->account_manager); /* Initialize fields */ + priv->check_support_done = FALSE; + priv->check_support_show_progress_id = 0; + priv->check_support_progress_pulse_id = 0; + priv->pending_check_support = 0; + priv->destroyed = FALSE; priv->page_welcome = create_page_welcome (self); priv->page_account_details = create_page_account_details (self); @@ -1301,7 +1354,7 @@ modest_easysetup_wizard_dialog_init (ModestEasysetupWizardDialog *self) /* Reset dirty, because there was no user input until now */ priv->dirty = 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 ( @@ -1311,10 +1364,9 @@ modest_easysetup_wizard_dialog_init (ModestEasysetupWizardDialog *self) g_object_ref (self); g_thread_create (presets_loader, self, FALSE, NULL); - hildon_help_dialog_help_enable (GTK_DIALOG(self), "applications_email_wizardwelcome", - modest_maemo_utils_get_osso_context()); - priv->settings = modest_account_settings_new (); + + check_support_of_protocols (self); } ModestEasysetupWizardDialog* @@ -1426,16 +1478,19 @@ static void create_subsequent_pages (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv; - EasysetupProviderComboBox *combo; - EasysetupProviderComboBoxIdType id_type; + ModestProviderPicker *picker; + ModestProviderPickerIdType id_type; GtkNotebook *notebook; priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); - combo = EASYSETUP_PROVIDER_COMBO_BOX (priv->combo_account_serviceprovider); - id_type = easysetup_provider_combo_box_get_active_id_type (combo); + picker = MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker); + id_type = modest_provider_picker_get_active_id_type (picker); g_object_get (self, "wizard-notebook", ¬ebook, NULL); + modest_wizard_dialog_set_response_override_handler (MODEST_WIZARD_DIALOG (self), + NULL); + - if (id_type == EASYSETUP_PROVIDER_COMBO_BOX_ID_OTHER) { + if (id_type == MODEST_PROVIDER_PICKER_ID_OTHER) { /* "Other..." was selected: */ /* If we come from a rollbacked easysetup */ @@ -1465,7 +1520,7 @@ create_subsequent_pages (ModestEasysetupWizardDialog *self) } /* It's a pluggable protocol and not a provider with presets */ - if (id_type == EASYSETUP_PROVIDER_COMBO_BOX_ID_PLUGIN_PROTOCOL) { + if (id_type == MODEST_PROVIDER_PICKER_ID_PLUGIN_PROTOCOL) { ModestProtocol *protocol; gchar *proto_name; ModestProtocolType proto_type; @@ -1480,7 +1535,7 @@ create_subsequent_pages (ModestEasysetupWizardDialog *self) priv->page_complete_easysetup = NULL; } - proto_name = easysetup_provider_combo_box_get_active_provider_id (combo); + proto_name = modest_provider_picker_get_active_provider_id (picker); protocol = modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (), MODEST_PROTOCOL_REGISTRY_PROVIDER_PROTOCOLS, proto_name); @@ -1490,26 +1545,39 @@ create_subsequent_pages (ModestEasysetupWizardDialog *self) proto_type != priv->last_plugin_protocol_selected) { ModestPairList *tabs; GSList *tmp; + gboolean first_page = TRUE; + ModestWizardDialogResponseOverrideFunc response_override; /* Remember the last selected plugin protocol */ priv->last_plugin_protocol_selected = proto_type; /* Get tabs */ tabs = modest_account_protocol_get_easysetupwizard_tabs (MODEST_ACCOUNT_PROTOCOL (protocol)); + response_override = modest_account_protocol_get_wizard_response_override + (MODEST_ACCOUNT_PROTOCOL (protocol)); + modest_wizard_dialog_set_response_override_handler (MODEST_WIZARD_DIALOG (self), + response_override); tmp = (GSList *) tabs; while (tmp) { ModestPair *pair = (ModestPair *) tmp->data; modest_easysetup_wizard_dialog_append_page (notebook, GTK_WIDGET (pair->second), (const gchar *) pair->first); + if (first_page) { + gtk_container_set_focus_child (GTK_CONTAINER (notebook), + GTK_WIDGET (pair->second)); + first_page = FALSE; + } /* Connect signals */ - priv->missing_data_signals = - modest_signal_mgr_connect (priv->missing_data_signals, - G_OBJECT (pair->second), - "missing-mandatory-data", - G_CALLBACK (on_missing_mandatory_data), - self); + if (MODEST_IS_EASYSETUP_WIZARD_PAGE (pair->second)) { + priv->missing_data_signals = + modest_signal_mgr_connect (priv->missing_data_signals, + G_OBJECT (pair->second), + "missing-mandatory-data", + G_CALLBACK (on_missing_mandatory_data), + self); + } g_free (pair->first); tmp = g_slist_next (tmp); @@ -1590,18 +1658,18 @@ set_default_custom_servernames (ModestEasysetupWizardDialog *self) */ if (priv->entry_user_email && ((priv->server_changes & MODEST_EASYSETUP_WIZARD_DIALOG_INCOMING_CHANGED) == 0)) { - const ModestProtocolType protocol_type = easysetup_servertype_combo_box_get_active_servertype ( - EASYSETUP_SERVERTYPE_COMBO_BOX (priv->combo_incoming_servertype)); + const ModestProtocolType protocol_type = modest_servertype_picker_get_active_servertype ( + MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker)); /* This could happen when the combo box has still no active iter */ if (protocol_type != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) { - const gchar* email_address = gtk_entry_get_text (GTK_ENTRY(priv->entry_user_email)); + const gchar* email_address = hildon_entry_get_text (HILDON_ENTRY(priv->entry_user_email)); gchar* servername = util_get_default_servername_from_email_address (email_address, protocol_type); /* Do not set the INCOMING_CHANGED flag because of this edit */ g_signal_handlers_block_by_func (G_OBJECT (priv->entry_incomingserver), G_CALLBACK (on_entry_incoming_servername_changed), self); - gtk_entry_set_text (GTK_ENTRY (priv->entry_incomingserver), servername); + hildon_entry_set_text (HILDON_ENTRY (priv->entry_incomingserver), servername); g_signal_handlers_unblock_by_func (G_OBJECT (priv->entry_incomingserver), G_CALLBACK (on_entry_incoming_servername_changed), self); g_free (servername); @@ -1616,13 +1684,13 @@ set_default_custom_servernames (ModestEasysetupWizardDialog *self) if (priv->entry_user_email && ((priv->server_changes & MODEST_EASYSETUP_WIZARD_DIALOG_OUTGOING_CHANGED) == 0)) { - const gchar* email_address = gtk_entry_get_text (GTK_ENTRY(priv->entry_user_email)); + const gchar* email_address = hildon_entry_get_text (HILDON_ENTRY(priv->entry_user_email)); gchar* servername = util_get_default_servername_from_email_address (email_address, MODEST_PROTOCOLS_TRANSPORT_SMTP); /* Do not set the OUTGOING_CHANGED flag because of this edit */ g_signal_handlers_block_by_func (G_OBJECT (priv->entry_outgoingserver), G_CALLBACK (on_entry_outgoing_servername_changed), self); - gtk_entry_set_text (GTK_ENTRY (priv->entry_outgoingserver), servername); + hildon_entry_set_text (HILDON_ENTRY (priv->entry_outgoingserver), servername); g_signal_handlers_unblock_by_func (G_OBJECT (priv->entry_outgoingserver), G_CALLBACK (on_entry_outgoing_servername_changed), self); g_free (servername); @@ -1636,7 +1704,7 @@ get_entered_account_title (ModestEasysetupWizardDialog *self) const gchar* account_title; priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); - account_title = gtk_entry_get_text (GTK_ENTRY (priv->entry_account_title)); + account_title = hildon_entry_get_text (HILDON_ENTRY (priv->entry_account_title)); if (!account_title || (g_utf8_strlen (account_title, -1) == 0)) { return NULL; @@ -1684,6 +1752,7 @@ on_before_next (ModestWizardDialog *dialog, GtkWidget *current_page, GtkWidget * /* Aavoid a clash with an existing display name: */ const gboolean name_in_use = modest_account_mgr_account_with_display_name_exists ( priv->account_manager, account_title); + g_free (account_title); if (name_in_use) { /* Warn the user via a dialog: */ @@ -1697,7 +1766,7 @@ on_before_next (ModestWizardDialog *dialog, GtkWidget *current_page, GtkWidget * } else if (current_page == priv->page_user_details) { /* Check that the email address is valud: */ - const gchar* email_address = gtk_entry_get_text (GTK_ENTRY (priv->entry_user_email)); + const gchar* email_address = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_email)); if ((!email_address) || (g_utf8_strlen (email_address, -1) == 0)) return FALSE; @@ -1719,9 +1788,9 @@ on_before_next (ModestWizardDialog *dialog, GtkWidget *current_page, GtkWidget * set_default_custom_servernames (self); /* Check if the server supports secure authentication */ -/* if (modest_security_options_view_auth_check (security_options)) */ -/* if (!check_has_supported_auth_methods (self)) */ -/* return FALSE; */ + if (modest_security_options_view_auth_check (MODEST_SECURITY_OPTIONS_VIEW (priv->incoming_security))) + if (!check_has_supported_auth_methods (self)) + return FALSE; gtk_widget_show (priv->outgoing_security); } @@ -1753,7 +1822,7 @@ static gboolean entry_is_empty (GtkWidget *entry) if (!entry) return FALSE; - const gchar* text = gtk_entry_get_text (GTK_ENTRY (entry)); + const gchar* text = hildon_entry_get_text (HILDON_ENTRY (entry)); if ((!text) || (g_utf8_strlen (text, -1) == 0)) return TRUE; else { @@ -1782,7 +1851,7 @@ real_enable_buttons (ModestWizardDialog *dialog, gboolean enable_next) /* Get data */ priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (dialog); g_object_get (dialog, "wizard-notebook", ¬ebook, NULL); - + /* Disable the Finish button until we are on the last page, * because HildonWizardDialog enables this for all but the * first page */ @@ -1799,8 +1868,12 @@ real_enable_buttons (ModestWizardDialog *dialog, gboolean enable_next) gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), MODEST_WIZARD_DIALOG_FINISH, FALSE); + + /* If the check support is not done then do not enable + the wizard to continue */ + enable_next = enable_next && priv->check_support_done; } - + gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), MODEST_WIZARD_DIALOG_NEXT, enable_next); @@ -1856,6 +1929,8 @@ modest_easysetup_wizard_dialog_class_init (ModestEasysetupWizardDialogClass *kla ModestWizardDialogClass *base_klass = (ModestWizardDialogClass*)(klass); base_klass->before_next = on_before_next; base_klass->enable_buttons = on_enable_buttons; + base_klass->update_model = on_update_model; + base_klass->save = on_save; } /** @@ -1869,7 +1944,7 @@ save_to_settings (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); guint special_port; - gchar *provider_id; + gchar *provider_id = NULL; gchar* display_name; const gchar *username, *password; gchar *store_hostname, *transport_hostname; @@ -1880,20 +1955,20 @@ save_to_settings (ModestEasysetupWizardDialog *self) ModestProtocolType store_auth_protocol, transport_auth_protocol; ModestServerAccountSettings *store_settings, *transport_settings; const gchar *fullname, *email_address; - EasysetupProviderComboBox *combo; - EasysetupProviderComboBoxIdType id_type; + ModestProviderPicker *picker; + ModestProviderPickerIdType id_type; priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); - combo = EASYSETUP_PROVIDER_COMBO_BOX (priv->combo_account_serviceprovider); + picker = MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker); protocol_registry = modest_runtime_get_protocol_registry (); /* Get details from the specified presets: */ - id_type = easysetup_provider_combo_box_get_active_id_type (combo); - provider_id = easysetup_provider_combo_box_get_active_provider_id (combo); - + id_type = modest_provider_picker_get_active_id_type (picker); + provider_id = modest_provider_picker_get_active_provider_id (picker); + /* Let the plugin save the settings. We do a return in order to save an indentation level */ - if (id_type == EASYSETUP_PROVIDER_COMBO_BOX_ID_PLUGIN_PROTOCOL) { + if (id_type == MODEST_PROVIDER_PICKER_ID_PLUGIN_PROTOCOL) { ModestProtocol *protocol; protocol = modest_protocol_registry_get_protocol_by_name ( @@ -1922,12 +1997,13 @@ save_to_settings (ModestEasysetupWizardDialog *self) "but it's not a ModestAccountProtocol"); } + g_free (provider_id); return; } /* username and password (for both incoming and outgoing): */ - username = gtk_entry_get_text (GTK_ENTRY (priv->entry_user_username)); - password = gtk_entry_get_text (GTK_ENTRY (priv->entry_user_password)); + username = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_username)); + password = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_password)); store_settings = modest_account_settings_get_store_settings (priv->settings); transport_settings = modest_account_settings_get_transport_settings (priv->settings); @@ -1944,20 +2020,20 @@ save_to_settings (ModestEasysetupWizardDialog *self) ModestProtocolType store_provider_server_type; gboolean store_provider_use_alternate_port; /* Use presets: */ - store_hostname = modest_presets_get_server (priv->presets, provider_id, + store_hostname = modest_presets_get_server (priv->presets, provider_id, TRUE /* store */); - + store_provider_server_type = modest_presets_get_info_server_type (priv->presets, - provider_id, + provider_id, TRUE /* store */); store_security = modest_presets_get_info_server_security (priv->presets, - provider_id, - TRUE /* store */); + provider_id, + TRUE /* store */); store_auth_protocol = modest_presets_get_info_server_auth (priv->presets, - provider_id, - TRUE /* store */); + provider_id, + TRUE /* store */); store_provider_use_alternate_port = modest_presets_get_info_server_use_alternate_port (priv->presets, - provider_id, + provider_id, TRUE /* store */); /* We don't check for SMTP here as that is impossible for an incoming server. */ @@ -1968,10 +2044,15 @@ save_to_settings (ModestEasysetupWizardDialog *self) /* we check if there is a *special* port */ special_port = modest_presets_get_port (priv->presets, provider_id, TRUE /* incoming */); - if (special_port != 0) + if (special_port != 0) { store_port = special_port; - else - store_port = get_port_from_protocol(store_provider_server_type, store_security); + } else { + gboolean use_alternate_port = FALSE; + if (modest_protocol_registry_protocol_type_is_secure (modest_runtime_get_protocol_registry (), + store_security)) + use_alternate_port = TRUE; + store_port = get_port_from_protocol(store_provider_server_type, use_alternate_port); + } modest_server_account_settings_set_security_protocol (store_settings, store_security); @@ -1981,9 +2062,9 @@ save_to_settings (ModestEasysetupWizardDialog *self) modest_server_account_settings_set_port (store_settings, store_port); } else { /* Use custom pages because no preset was specified: */ - store_hostname = g_strdup (gtk_entry_get_text (GTK_ENTRY (priv->entry_incomingserver) )); - store_protocol = easysetup_servertype_combo_box_get_active_servertype ( - EASYSETUP_SERVERTYPE_COMBO_BOX (priv->combo_incoming_servertype)); + store_hostname = g_strdup (hildon_entry_get_text (HILDON_ENTRY (priv->entry_incomingserver) )); + store_protocol = modest_servertype_picker_get_active_servertype ( + MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker)); modest_security_options_view_save_settings ( MODEST_SECURITY_OPTIONS_VIEW (priv->incoming_security), @@ -2052,7 +2133,7 @@ save_to_settings (ModestEasysetupWizardDialog *self) registry = modest_runtime_get_protocol_registry (); /* Use custom pages because no preset was specified: */ - transport_hostname = g_strdup (gtk_entry_get_text (GTK_ENTRY (priv->entry_outgoingserver) )); + transport_hostname = g_strdup (hildon_entry_get_text (HILDON_ENTRY (priv->entry_outgoingserver) )); store_proto = modest_protocol_registry_get_protocol_by_type (registry, store_protocol); @@ -2078,21 +2159,236 @@ save_to_settings (ModestEasysetupWizardDialog *self) g_object_unref (transport_settings); g_free (transport_hostname); - - fullname = gtk_entry_get_text (GTK_ENTRY (priv->entry_user_name)); - email_address = gtk_entry_get_text (GTK_ENTRY (priv->entry_user_email)); + + fullname = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_name)); + email_address = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_email)); modest_account_settings_set_fullname (priv->settings, fullname); modest_account_settings_set_email_address (priv->settings, email_address); /* we don't set retrieve type to preserve advanced settings if any. By default account settings are set to headers only */ - + /* Save the connection-specific SMTP server accounts. */ - modest_account_settings_set_use_connection_specific_smtp - (priv->settings, - gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->checkbox_outgoing_smtp_specific))); + if (priv->checkbox_outgoing_smtp_specific) { + modest_account_settings_set_use_connection_specific_smtp + (priv->settings, + hildon_check_button_get_active(HILDON_CHECK_BUTTON(priv->checkbox_outgoing_smtp_specific))); + } display_name = get_entered_account_title (self); modest_account_settings_set_display_name (priv->settings, display_name); g_free (display_name); + g_free (provider_id); +} + + +static void +on_update_model (ModestWizardDialog *dialog) +{ + ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (dialog); + save_to_settings (self); + +} + +static gboolean +on_save (ModestWizardDialog *dialog) +{ + ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (dialog); + ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + + save_to_settings (self); + + if (modest_account_mgr_check_already_configured_account (priv->account_manager, priv->settings)) { + modest_platform_information_banner (NULL, NULL, _("mail_ib_setting_failed")); + return FALSE; + } + + return modest_account_mgr_add_account_from_settings (priv->account_manager, priv->settings); + } + +static GList* +check_for_supported_auth_methods (ModestEasysetupWizardDialog* self) +{ + GError *error = NULL; + ModestProtocolType protocol_type; + const gchar* hostname; + const gchar* username; + ModestProtocolType security_protocol_incoming_type; + ModestProtocolRegistry *registry; + int port_num; + GList *list_auth_methods; + ModestEasysetupWizardDialogPrivate *priv; + + priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + registry = modest_runtime_get_protocol_registry (); + protocol_type = modest_servertype_picker_get_active_servertype ( + MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker)); + hostname = gtk_entry_get_text(GTK_ENTRY(priv->entry_incomingserver)); + username = gtk_entry_get_text(GTK_ENTRY(priv->entry_user_username)); + security_protocol_incoming_type = modest_security_options_view_get_connection_protocol + (MODEST_SECURITY_OPTIONS_VIEW (priv->incoming_security)); + port_num = get_port_from_protocol(protocol_type, FALSE); + list_auth_methods = modest_utils_get_supported_secure_authentication_methods (protocol_type, hostname, port_num, + username, GTK_WINDOW (self), &error); + + if (list_auth_methods) { + /* TODO: Select the correct method */ + GList* list = NULL; + GList* method; + for (method = list_auth_methods; method != NULL; method = g_list_next(method)) { + ModestProtocolType auth_protocol_type = (ModestProtocolType) (GPOINTER_TO_INT(method->data)); + if (modest_protocol_registry_protocol_type_has_tag (registry, auth_protocol_type, + MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS)) { + list = g_list_append(list, GINT_TO_POINTER(auth_protocol_type)); + } + } + + g_list_free(list_auth_methods); + + if (list) + return list; + } + + if(error == NULL || error->domain != modest_utils_get_supported_secure_authentication_error_quark() || + error->code != MODEST_UTILS_GET_SUPPORTED_SECURE_AUTHENTICATION_ERROR_CANCELED) + { + modest_platform_information_banner (GTK_WIDGET(self), NULL, + _("mcen_ib_unableto_discover_auth_methods")); + } + + if(error != NULL) + g_error_free(error); + + return NULL; +} + +static gboolean +check_has_supported_auth_methods(ModestEasysetupWizardDialog* self) +{ + GList* methods = check_for_supported_auth_methods(self); + if (!methods) + { + return FALSE; + } + + g_list_free(methods); + return TRUE; +} + +static gboolean +check_support_progress_pulse (gpointer userdata) +{ + ModestEasysetupWizardDialog *self = (ModestEasysetupWizardDialog *) userdata; + ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + + if (priv->destroyed) { + priv->check_support_progress_pulse_id = 0; + return FALSE; + } + + gtk_progress_bar_pulse (GTK_PROGRESS_BAR (priv->check_support_progress)); + + return TRUE; +} + +static gboolean +check_support_show_progress (gpointer userdata) +{ + ModestEasysetupWizardDialog *self = (ModestEasysetupWizardDialog *) userdata; + ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + + priv->check_support_show_progress_id = 0; + + if (priv->destroyed) + return FALSE; + + gtk_widget_show (priv->check_support_progress); + gtk_progress_bar_pulse (GTK_PROGRESS_BAR (priv->check_support_progress)); + + priv->check_support_progress_pulse_id = g_timeout_add (200, check_support_progress_pulse, self); + + return FALSE; +} + +static void +check_support_callback (ModestAccountProtocol *protocol, + gboolean supported, + gpointer userdata) +{ + ModestEasysetupWizardDialog *self = (ModestEasysetupWizardDialog *) userdata; + ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + + priv->pending_check_support --; + + if (priv->check_support_show_progress_id > 0) { + g_source_remove (priv->check_support_show_progress_id); + priv->check_support_show_progress_id = 0; + } + + if (priv->check_support_progress_pulse_id > 0) { + g_source_remove (priv->check_support_progress_pulse_id); + priv->check_support_progress_pulse_id = 0; + } + + if (priv->pending_check_support == 0) { + priv->check_support_done = TRUE; + + if (!priv->destroyed) { + if (priv->presets) + fill_providers (self); + gtk_widget_hide (priv->check_support_progress); + invoke_enable_buttons_vfunc (self); + } + } + g_object_unref (self); +} + + +static void +check_support_of_protocols (ModestEasysetupWizardDialog *self) +{ + ModestProtocolRegistry *registry; + GSList *provider_protos, *node; + ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + + registry = modest_runtime_get_protocol_registry (); + provider_protos = modest_protocol_registry_get_by_tag (registry, + MODEST_PROTOCOL_REGISTRY_PROVIDER_PROTOCOLS); + + for (node = provider_protos; node != NULL; node = g_slist_next (node)) { + ModestProtocol *proto = MODEST_PROTOCOL (node->data); + + if (!modest_protocol_registry_protocol_type_has_tag (registry, + modest_protocol_get_type_id (proto), + MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS)) + continue; + + if (modest_protocol_registry_protocol_type_has_tag + (registry, + modest_protocol_get_type_id (proto), + MODEST_PROTOCOL_REGISTRY_SINGLETON_PROVIDER_PROTOCOLS)) { + /* Check if there's already an account configured with this account type */ + if (modest_account_mgr_singleton_protocol_exists (modest_runtime_get_account_mgr (), + modest_protocol_get_type_id (proto))) + continue; + } + + if (MODEST_ACCOUNT_PROTOCOL (proto)) { + priv->pending_check_support ++; + modest_account_protocol_check_support (MODEST_ACCOUNT_PROTOCOL (proto), + check_support_callback, + g_object_ref (self)); + } + } + g_slist_free (provider_protos); + + if (priv->pending_check_support > 0) { + priv->check_support_show_progress_id = g_timeout_add_full (G_PRIORITY_DEFAULT, 1000, + check_support_show_progress, + g_object_ref (self), g_object_unref); + } else { + priv->check_support_done = TRUE; + } + invoke_enable_buttons_vfunc (self); +}