X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fhildon2%2Fmodest-easysetup-wizard-dialog.c;h=c9b8ad6f696851e557ced60d6f2763b356b48be1;hp=b2369a5ac230c5d8aabe99fda0c3ec91e1831922;hb=d791ed7c0651d118dfd7db58e38446e256958db6;hpb=864d52f23c781badb8a491b8cca5c62c5494061e diff --git a/src/hildon2/modest-easysetup-wizard-dialog.c b/src/hildon2/modest-easysetup-wizard-dialog.c index b2369a5..c9b8ad6 100644 --- a/src/hildon2/modest-easysetup-wizard-dialog.c +++ b/src/hildon2/modest-easysetup-wizard-dialog.c @@ -36,12 +36,8 @@ #include #include #include -#include #include #include -#include "modest-country-picker.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" @@ -60,6 +56,9 @@ #include "modest-maemo-security-options-view.h" #include "modest-account-protocol.h" #include "modest-address-book.h" +#include +#include +#include /* Include config.h so that _() works: */ #ifdef HAVE_CONFIG_H @@ -104,16 +103,17 @@ 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; + GtkWidget *check_support_cancel_note; + GtkWidget *check_support_progress; gint pending_check_support; gboolean destroyed; GtkWidget *page_account_details; - GtkWidget *account_country_picker; - GtkWidget *account_serviceprovider_picker; + GtkWidget *account_country_selector; + GtkWidget *account_serviceprovider_selector; GtkWidget *entry_account_title; GtkWidget *caption_account_title; @@ -126,7 +126,7 @@ struct _ModestEasysetupWizardDialogPrivate GtkWidget *page_complete_easysetup; GtkWidget *page_custom_incoming; - GtkWidget *incoming_servertype_picker; + GtkWidget *incoming_servertype_selector; GtkWidget *caption_incoming; GtkWidget *entry_incomingserver; @@ -200,6 +200,26 @@ modest_easysetup_wizard_dialog_finalize (GObject *object) { ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (object); ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + ModestProtocolRegistry *registry; + GSList *provider_protos, *node; + + 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_ACCOUNT_PROTOCOL (proto)) { + modest_account_protocol_wizard_finished (MODEST_ACCOUNT_PROTOCOL (proto)); + } + } + g_slist_free (provider_protos); if (priv->account_manager) g_object_unref (G_OBJECT (priv->account_manager)); @@ -224,7 +244,9 @@ create_subsequent_easysetup_pages (ModestEasysetupWizardDialog *self); static void set_default_custom_servernames(ModestEasysetupWizardDialog *dialog); +#ifdef HILDON_PICKER_BUTTON static void on_servertype_selector_changed(HildonTouchSelector *selector, gint column, gpointer user_data); +#endif static gint get_port_from_protocol (ModestProtocolType server_type, @@ -285,7 +307,7 @@ on_caption_combobox_changed (GtkComboBox *widget, gpointer user_data) } static void -on_picker_button_value_changed (HildonPickerButton *widget, gpointer user_data) +on_picker_button_value_changed (GtkWidget *widget, gpointer user_data) { ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); g_assert(self); @@ -293,13 +315,13 @@ on_picker_button_value_changed (HildonPickerButton *widget, gpointer user_data) } static void -on_serviceprovider_picker_button_value_changed (HildonPickerButton *widget, gpointer user_data) +on_serviceprovider_selector_value_changed (GtkWidget *widget, gpointer user_data) { gchar* default_account_name_start; gchar* default_account_name; ModestEasysetupWizardDialog *self; ModestEasysetupWizardDialogPrivate *priv; - ModestProviderPickerIdType provider_id_type; + ModestProviderSelectorIdType provider_id_type; ModestProtocol *protocol; gchar *proto_name; ModestProtocolType proto_type; @@ -308,19 +330,15 @@ on_serviceprovider_picker_button_value_changed (HildonPickerButton *widget, gpoi self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); - on_picker_button_value_changed (widget, user_data); + on_picker_button_value_changed (GTK_WIDGET (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) { + provider_id_type = modest_provider_selector_get_active_id_type ( + priv->account_serviceprovider_selector); + if (provider_id_type == MODEST_PROVIDER_SELECTOR_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))); - + /* obtain properly the account name! */ + default_account_name_start = modest_provider_selector_get_active_provider_label (widget); } default_account_name = modest_account_mgr_get_unused_account_display_name ( priv->account_manager, default_account_name_start); @@ -328,7 +346,7 @@ on_serviceprovider_picker_button_value_changed (HildonPickerButton *widget, gpoi default_account_name_start = NULL; hide_account_title = FALSE; - proto_name = modest_provider_picker_get_active_provider_id (MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker)); + proto_name = modest_provider_selector_get_active_provider_id (priv->account_serviceprovider_selector); if (proto_name != NULL) { protocol = modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (), MODEST_PROTOCOL_REGISTRY_PROVIDER_PROTOCOLS, @@ -352,7 +370,7 @@ on_serviceprovider_picker_button_value_changed (HildonPickerButton *widget, gpoi else gtk_widget_show (priv->caption_account_title); - hildon_entry_set_text (HILDON_ENTRY (priv->entry_account_title), default_account_name); + modest_entry_set_text (priv->entry_account_title, default_account_name); g_free (default_account_name); } @@ -369,9 +387,9 @@ create_captioned (ModestEasysetupWizardDialog *self, { GtkWidget *result; - result = modest_maemo_utils_create_captioned_with_size_type (title_size_group, value_size_group, - value, use_markup, control, - MODEST_EDITABLE_SIZE); + result = modest_toolkit_utils_create_captioned_with_size_type (title_size_group, value_size_group, + value, use_markup, control, + MODEST_EDITABLE_SIZE); /* Connect to the appropriate changed signal for the widget, * so we can ask for the prev/next buttons to be enabled/disabled appropriately: @@ -395,29 +413,41 @@ create_page_welcome (ModestEasysetupWizardDialog *self) GtkWidget *box; GtkWidget *align; GtkWidget *label; + GtkWidget *privacy_note; + GtkWidget *scrollable; ModestEasysetupWizardDialogPrivate *priv; priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); + scrollable = modest_toolkit_factory_create_scrollable (modest_runtime_get_toolkit_factory ()); label = gtk_label_new(_("mcen_ia_emailsetup_intro")); - priv->check_support_progress = gtk_progress_bar_new (); + privacy_note = gtk_label_new (_("mcen_ia_privacy_notice")); align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, MODEST_MARGIN_DOUBLE, 0); gtk_widget_set_size_request (label, LABELS_WIDTH, -1); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); + gtk_widget_set_size_request (privacy_note, LABELS_WIDTH, -1); + gtk_label_set_line_wrap (GTK_LABEL (privacy_note), TRUE); + hildon_helper_set_logical_font (privacy_note, "SmallSystemFont"); /* So that it is not truncated: */ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_misc_set_padding (GTK_MISC (label), MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE); - gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0); - gtk_box_pack_end (GTK_BOX (box), priv->check_support_progress, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (box), privacy_note, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (align), box); gtk_widget_show (label); + gtk_widget_show (privacy_note); + + modest_scrollable_add_with_viewport (MODEST_SCROLLABLE (scrollable), align); gtk_widget_show (GTK_WIDGET (box)); - return GTK_WIDGET (align); + gtk_widget_show (GTK_WIDGET (align)); + gtk_widget_show (scrollable); + + return GTK_WIDGET (scrollable); } static void -on_account_country_selector_changed (HildonTouchSelector *widget, gint column, gpointer user_data) +on_account_country_selector_changed (GtkWidget *widget, gpointer user_data) { ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); g_assert(self); @@ -425,12 +455,10 @@ on_account_country_selector_changed (HildonTouchSelector *widget, gint column, g priv->dirty = TRUE; - /* Fill the providers picker, based on the selected country: */ + /* Fill the providers selector, 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)); - modest_provider_picker_fill ( - MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker), priv->presets, mcc); + gint mcc = modest_country_selector_get_active_country_mcc (priv->account_country_selector); + modest_provider_selector_fill (priv->account_serviceprovider_selector, priv->presets, mcc); } } @@ -444,8 +472,8 @@ update_user_email_from_provider (ModestEasysetupWizardDialog *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)); + provider_id = modest_provider_selector_get_active_provider_id ( + priv->account_serviceprovider_selector); if (provider_id) { gchar *domain_name = modest_presets_get_domain (priv->presets, provider_id); @@ -458,14 +486,28 @@ update_user_email_from_provider (ModestEasysetupWizardDialog *self) 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); + modest_entry_set_text (priv->entry_user_email, with_at); g_free (with_at); g_free (provider_id); } +#ifdef HILDON_PICKER_BUTTON static void -on_account_serviceprovider_selector_changed (HildonTouchSelector *widget, gint column, gpointer user_data) +on_account_serviceprovider_selector_changed (GtkWidget *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; + + update_user_email_from_provider (self); +} +#endif + +static void +on_account_serviceprovider_selector_combo_box_changed (GtkWidget *widget, gpointer user_data) { ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); g_assert(self); @@ -504,25 +546,49 @@ create_page_account_details (ModestEasysetupWizardDialog *self) GtkSizeGroup* value_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); /* The country widgets: */ - 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); + priv->account_country_selector = modest_toolkit_factory_create_country_selector (modest_runtime_get_toolkit_factory ()); + if (GTK_IS_COMBO_BOX (priv->account_country_selector)) { + GtkWidget *captioned; + g_signal_connect (G_OBJECT (priv->account_country_selector), "changed", + G_CALLBACK (on_picker_button_value_changed), self); + captioned = modest_toolkit_utils_create_captioned (title_sizegroup, value_sizegroup, + _("mcen_fi_country"), FALSE, + priv->account_country_selector); + + gtk_box_pack_start (GTK_BOX (box), captioned, FALSE, FALSE, MODEST_MARGIN_HALF); + gtk_widget_show (captioned); + } else { + modest_toolkit_utils_set_hbutton_layout (title_sizegroup, value_sizegroup, + _("mcen_fi_country"), priv->account_country_selector); + g_signal_connect (G_OBJECT (priv->account_country_selector), "value-changed", + G_CALLBACK (on_picker_button_value_changed), self); + gtk_box_pack_start (GTK_BOX (box), priv->account_country_selector, FALSE, FALSE, MODEST_MARGIN_HALF); + } + gtk_widget_show (priv->account_country_selector); /* The service provider widgets: */ - 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, 0); - gtk_widget_show (priv->account_serviceprovider_picker); + priv->account_serviceprovider_selector = modest_toolkit_factory_create_provider_selector (modest_runtime_get_toolkit_factory ()); + if (GTK_IS_COMBO_BOX (priv->account_serviceprovider_selector)) { + GtkWidget *captioned; + g_signal_connect (G_OBJECT (priv->account_serviceprovider_selector), "changed", + G_CALLBACK (on_serviceprovider_selector_value_changed), self); + captioned = modest_toolkit_utils_create_captioned (title_sizegroup, value_sizegroup, + _("mcen_fi_serviceprovider"), FALSE, + priv->account_serviceprovider_selector); + + g_signal_connect (G_OBJECT (priv->account_serviceprovider_selector), "changed", + G_CALLBACK (on_serviceprovider_selector_value_changed), self); + gtk_box_pack_start (GTK_BOX (box), captioned, FALSE, FALSE, MODEST_MARGIN_HALF); + gtk_widget_show (captioned); + } else { + modest_toolkit_utils_set_hbutton_layout (title_sizegroup, value_sizegroup, + _("mcen_fi_serviceprovider"), + priv->account_serviceprovider_selector); + g_signal_connect (G_OBJECT (priv->account_serviceprovider_selector), "value-changed", + G_CALLBACK (on_serviceprovider_selector_value_changed), self); + gtk_box_pack_start (GTK_BOX (box), priv->account_serviceprovider_selector, FALSE, FALSE, 0); + } + gtk_widget_show (priv->account_serviceprovider_selector); /* The description widgets: */ priv->entry_account_title = GTK_WIDGET (modest_validating_entry_new ()); @@ -539,7 +605,7 @@ create_page_account_details (ModestEasysetupWizardDialog *self) g_free (default_account_name_start); default_account_name_start = NULL; - hildon_entry_set_text (HILDON_ENTRY (priv->entry_account_title), default_account_name); + modest_entry_set_text (priv->entry_account_title, default_account_name); g_free (default_account_name); default_account_name = NULL; @@ -574,7 +640,7 @@ create_page_account_details (ModestEasysetupWizardDialog *self) g_list_free (list_prevent); list_prevent = NULL; modest_validating_entry_set_func(MODEST_VALIDATING_ENTRY(priv->entry_account_title), - modest_utils_on_entry_invalid_character, self); + modest_utils_on_entry_invalid_character, self); /* Set max length as in the UI spec: * The UI spec seems to want us to show a dialog if we hit the maximum. */ @@ -604,19 +670,26 @@ on_user_username_changed(GtkWidget* widget, ModestEasysetupWizardDialog *self) priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); /* Work out the user email address */ - provider_id = modest_provider_picker_get_active_provider_id ( - MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker)); + provider_id = modest_provider_selector_get_active_provider_id ( + priv->account_serviceprovider_selector); if (provider_id) { + const gchar *current_username; gchar *email_address; gchar *domain_name = modest_presets_get_domain (priv->presets, provider_id); - email_address = g_strdup_printf ("%s@%s", - hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_username)), - domain_name); + current_username = modest_entry_get_text (priv->entry_user_username); + + if (current_username && strstr (current_username, "@")) { + email_address = g_strdup (current_username); + } else { + email_address = g_strdup_printf ("%s@%s", + current_username, + domain_name); + } /* Update the email address */ - hildon_entry_set_text (HILDON_ENTRY (priv->entry_user_email), email_address); + modest_entry_set_text (priv->entry_user_email, email_address); g_free (email_address); g_free (domain_name); @@ -707,7 +780,7 @@ create_page_user_details (ModestEasysetupWizardDialog *self) on_entry_max, self); /* The password widgets: */ - priv->entry_user_password = hildon_entry_new (MODEST_EDITABLE_SIZE); + priv->entry_user_password = modest_toolkit_factory_create_entry (modest_runtime_get_toolkit_factory ()); /* 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); @@ -800,8 +873,8 @@ update_incoming_server_title (ModestEasysetupWizardDialog *self) priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); protocol_registry = modest_runtime_get_protocol_registry (); - protocol_type = modest_servertype_picker_get_active_servertype ( - MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker)); + protocol_type = modest_servertype_selector_get_active_servertype ( + priv->incoming_servertype_selector); /* This could happen when the combo box has still no active iter */ if (protocol_type != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) { @@ -816,7 +889,7 @@ update_incoming_server_title (ModestEasysetupWizardDialog *self) 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); + modest_toolkit_utils_captioned_set_label (priv->caption_incoming, incomingserver_title, TRUE); g_free(incomingserver_title); } @@ -829,14 +902,12 @@ static void update_incoming_server_security_choices (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); - ModestServertypePicker *server_type_picker; + GtkWidget *server_type_selector; ModestProtocolType protocol_type; ModestSecurityOptionsView *view; - server_type_picker = - MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker); - protocol_type = - modest_servertype_picker_get_active_servertype (server_type_picker); + server_type_selector = priv->incoming_servertype_selector; + protocol_type = modest_servertype_selector_get_active_servertype (server_type_selector); /* Fill the combo with appropriately titled choices for all those protocols */ @@ -844,6 +915,7 @@ update_incoming_server_security_choices (ModestEasysetupWizardDialog *self) modest_security_options_view_set_server_type (view, protocol_type); } +#ifdef HILDON_PICKER_BUTTON static void on_servertype_selector_changed(HildonTouchSelector *selector, gint column, gpointer user_data) { @@ -861,6 +933,25 @@ on_servertype_selector_changed(HildonTouchSelector *selector, gint column, gpoin set_default_custom_servernames (self); } +#endif + +static void +on_servertype_combo_changed(GtkWidget *selector, gpointer user_data) +{ + ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); + ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); + + priv->dirty = TRUE; + + /* Update title */ + update_incoming_server_title (self); + + /* Update security options if needed */ + update_incoming_server_security_choices (self); + gtk_widget_show (priv->incoming_security); + + set_default_custom_servernames (self); +} static void on_entry_incoming_servername_changed(GtkEntry *entry, gpointer user_data) @@ -878,7 +969,7 @@ create_page_custom_incoming (ModestEasysetupWizardDialog *self) ModestEasysetupWizardDialogPrivate* priv; GtkWidget *box; GtkWidget *align; - GtkWidget *pannable; + GtkWidget *scrollable; GtkWidget *label; GtkSizeGroup *title_sizegroup; GtkSizeGroup *value_sizegroup; @@ -887,7 +978,7 @@ create_page_custom_incoming (ModestEasysetupWizardDialog *self) protocol_registry = modest_runtime_get_protocol_registry (); box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); - pannable = hildon_pannable_area_new (); + scrollable = modest_toolkit_factory_create_scrollable (modest_runtime_get_toolkit_factory ()); /* Show note that account type cannot be changed in future: */ label = gtk_label_new (_("mcen_ia_emailsetup_account_type")); @@ -905,18 +996,30 @@ create_page_custom_incoming (ModestEasysetupWizardDialog *self) value_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); /* The incoming server widgets: */ - priv->incoming_servertype_picker = GTK_WIDGET (modest_servertype_picker_new (MODEST_EDITABLE_SIZE, - HILDON_BUTTON_ARRANGEMENT_HORIZONTAL, - TRUE)); - modest_maemo_utils_set_hbutton_layout (title_sizegroup, value_sizegroup, - _("mcen_li_emailsetup_type"), - priv->incoming_servertype_picker); - 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, 0); - gtk_widget_show (priv->incoming_servertype_picker); - - priv->entry_incomingserver = hildon_entry_new (MODEST_EDITABLE_SIZE); + priv->incoming_servertype_selector = + modest_toolkit_factory_create_servertype_selector (modest_runtime_get_toolkit_factory (), + TRUE); + if (GTK_IS_COMBO_BOX (priv->incoming_servertype_selector)) { + GtkWidget *captioned; + g_signal_connect (G_OBJECT (priv->incoming_servertype_selector), "changed", + G_CALLBACK (on_picker_button_value_changed), self); + captioned = modest_toolkit_utils_create_captioned (title_sizegroup, value_sizegroup, + _("mcen_fi_country"), FALSE, + priv->incoming_servertype_selector); + + gtk_box_pack_start (GTK_BOX (box), captioned, FALSE, FALSE, MODEST_MARGIN_HALF); + gtk_widget_show (captioned); + } else { + modest_toolkit_utils_set_hbutton_layout (title_sizegroup, value_sizegroup, + _("mcen_li_emailsetup_type"), + priv->incoming_servertype_selector); + g_signal_connect (G_OBJECT (priv->incoming_servertype_selector), "value-changed", + G_CALLBACK (on_picker_button_value_changed), self); + gtk_box_pack_start (GTK_BOX (box), priv->incoming_servertype_selector, FALSE, FALSE, 0); + } + gtk_widget_show (priv->incoming_servertype_selector); + + priv->entry_incomingserver = modest_toolkit_factory_create_entry (modest_runtime_get_toolkit_factory ()); /* 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); @@ -938,35 +1041,42 @@ create_page_custom_incoming (ModestEasysetupWizardDialog *self) /* The secure connection widgets. These are only valid for protocols with security */ - priv->incoming_security = - modest_maemo_security_options_view_new (MODEST_SECURITY_OPTIONS_INCOMING, - FALSE, title_sizegroup, value_sizegroup); + priv->incoming_security = modest_toolkit_factory_create_security_options_view (modest_runtime_get_toolkit_factory (), + MODEST_SECURITY_OPTIONS_INCOMING, + FALSE, title_sizegroup, value_sizegroup); gtk_box_pack_start (GTK_BOX (box), priv->incoming_security, FALSE, FALSE, 0); gtk_widget_show (priv->incoming_security); /* Set default selection */ - modest_servertype_picker_set_active_servertype ( - MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker), - MODEST_PROTOCOLS_STORE_POP); + modest_servertype_selector_set_active_servertype (priv->incoming_servertype_selector, + MODEST_PROTOCOLS_STORE_POP); update_incoming_server_title (self); update_incoming_server_security_choices (self); set_default_custom_servernames (self); /* Change the caption title when the servertype changes, * as in the UI spec: */ - 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); + if (GTK_IS_COMBO_BOX (priv->incoming_servertype_selector)) { + g_signal_connect (priv->incoming_servertype_selector, + "changed", + G_CALLBACK (on_servertype_combo_changed), self); + } else { +#ifdef HILDON_PICKER_BUTTON + g_signal_connect (G_OBJECT (hildon_picker_button_get_selector (HILDON_PICKER_BUTTON (priv->incoming_servertype_selector))), + "changed", + G_CALLBACK (on_servertype_selector_changed), self); +#endif + } align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, MODEST_MARGIN_DOUBLE, 0); gtk_widget_show (align); gtk_container_add (GTK_CONTAINER (align), box); - hildon_pannable_area_add_with_viewport (HILDON_PANNABLE_AREA (pannable), align); + modest_scrollable_add_with_viewport (MODEST_SCROLLABLE (scrollable), align); gtk_widget_show (GTK_WIDGET (box)); - gtk_widget_show (pannable); + gtk_widget_show (scrollable); g_object_unref (title_sizegroup); g_object_unref (value_sizegroup); @@ -976,23 +1086,23 @@ create_page_custom_incoming (ModestEasysetupWizardDialog *self) G_CALLBACK(on_easysetup_changed), self); - return GTK_WIDGET (pannable); + return GTK_WIDGET (scrollable); } static void -on_check_button_changed (HildonCheckButton *button, gpointer user_data) +on_check_button_changed (GtkWidget *button, gpointer user_data) { GtkWidget *widget = GTK_WIDGET (user_data); /* Enable the widget only if the check button is active: */ - const gboolean enable = hildon_check_button_get_active (button); + const gboolean enable = modest_togglable_get_active (button); gtk_widget_set_sensitive (widget, enable); } /* Make the sensitivity of a widget depend on a check button. */ static void -enable_widget_for_checkbutton (GtkWidget *widget, HildonCheckButton* button) +enable_widget_for_checkbutton (GtkWidget *widget, GtkWidget* button) { g_signal_connect (G_OBJECT (button), "toggled", G_CALLBACK (on_check_button_changed), widget); @@ -1034,11 +1144,11 @@ create_page_custom_outgoing (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv; gchar *smtp_caption_label; - GtkWidget *pannable; + GtkWidget *scrollable; GtkWidget *align; GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); - pannable = hildon_pannable_area_new (); + scrollable = modest_toolkit_factory_create_scrollable (modest_runtime_get_toolkit_factory ()); /* 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. @@ -1048,7 +1158,7 @@ create_page_custom_outgoing (ModestEasysetupWizardDialog *self) /* The outgoing server widgets: */ priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); - priv->entry_outgoingserver = hildon_entry_new (MODEST_EDITABLE_SIZE); + priv->entry_outgoingserver = modest_toolkit_factory_create_entry (modest_runtime_get_toolkit_factory ()); /* 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); @@ -1064,8 +1174,9 @@ create_page_custom_outgoing (ModestEasysetupWizardDialog *self) /* The secure connection widgets. These are only valid for protocols with security */ priv->outgoing_security = - modest_maemo_security_options_view_new (MODEST_SECURITY_OPTIONS_OUTGOING, - FALSE, title_sizegroup, value_sizegroup); + modest_toolkit_factory_create_security_options_view (modest_runtime_get_toolkit_factory (), + MODEST_SECURITY_OPTIONS_OUTGOING, + FALSE, title_sizegroup, value_sizegroup); gtk_box_pack_start (GTK_BOX (box), priv->outgoing_security, FALSE, FALSE, 0); gtk_widget_show (priv->outgoing_security); @@ -1075,13 +1186,11 @@ create_page_custom_outgoing (ModestEasysetupWizardDialog *self) gtk_widget_show (separator); /* connection-specific checkbox: */ - 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); + priv->checkbox_outgoing_smtp_specific = modest_toolkit_factory_create_check_button + (modest_runtime_get_toolkit_factory (), + _("mcen_fi_advsetup_connection_smtp")); + modest_togglable_set_active (priv->checkbox_outgoing_smtp_specific, + FALSE); gtk_widget_show (priv->checkbox_outgoing_smtp_specific); gtk_box_pack_start (GTK_BOX (box), priv->checkbox_outgoing_smtp_specific, @@ -1097,7 +1206,7 @@ create_page_custom_outgoing (ModestEasysetupWizardDialog *self) /* Only enable the button when the checkbox is checked: */ enable_widget_for_checkbutton (priv->button_outgoing_smtp_servers, - HILDON_CHECK_BUTTON (priv->checkbox_outgoing_smtp_specific)); + priv->checkbox_outgoing_smtp_specific); g_signal_connect (G_OBJECT (priv->button_outgoing_smtp_servers), "clicked", G_CALLBACK (on_button_outgoing_smtp_servers), self); @@ -1111,9 +1220,9 @@ create_page_custom_outgoing (ModestEasysetupWizardDialog *self) gtk_widget_show (align); gtk_container_add (GTK_CONTAINER (align), box); - hildon_pannable_area_add_with_viewport (HILDON_PANNABLE_AREA (pannable), align); + modest_scrollable_add_with_viewport (MODEST_SCROLLABLE (scrollable), align); gtk_widget_show (GTK_WIDGET (box)); - gtk_widget_show (pannable); + gtk_widget_show (scrollable); g_object_unref (title_sizegroup); g_object_unref (value_sizegroup); @@ -1124,7 +1233,7 @@ create_page_custom_outgoing (ModestEasysetupWizardDialog *self) g_signal_connect (G_OBJECT (priv->checkbox_outgoing_smtp_specific), "toggled", G_CALLBACK (on_easysetup_changed), self); - return GTK_WIDGET (pannable); + return GTK_WIDGET (scrollable); } static gboolean @@ -1223,12 +1332,17 @@ on_response_before (ModestWizardDialog *wizard_dialog, /* This is mostly copied from * src/maemo/modest-account-settings-dialog.c */ if (priv->dirty) { - GtkDialog *dialog = GTK_DIALOG (hildon_note_new_confirmation (GTK_WINDOW (self), - _("imum_nc_wizard_confirm_lose_changes"))); - /* TODO: These button names will be ambiguous, and not - * specified in the UI specification. */ + gint dialog_response; + GtkWidget *dialog; + + dialog = hildon_note_new_confirmation ((GtkWindow *) self, + _("imum_nc_wizard_confirm_lose_changes")); - const gint dialog_response = gtk_dialog_run (dialog); + modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), + (GtkWindow *) dialog, + (GtkWindow *) wizard_dialog); + + dialog_response = gtk_dialog_run ((GtkDialog *) dialog); gtk_widget_destroy (GTK_WIDGET (dialog)); if (dialog_response != GTK_RESPONSE_OK) { @@ -1244,32 +1358,41 @@ fill_providers (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); - if (MODEST_IS_COUNTRY_PICKER (priv->account_country_picker)) { + if (priv->account_country_selector) { /* 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_selector_load_data(priv->account_country_selector); /* 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), + if (GTK_IS_COMBO_BOX (priv->account_country_selector)) { + g_signal_connect ((GObject *) priv->account_country_selector, + "changed", + G_CALLBACK (on_account_country_selector_changed), self); + } else { + g_signal_connect ((GObject *) priv->account_country_selector, + "value-changed", + G_CALLBACK (on_account_country_selector_changed), self); + } + + modest_country_selector_set_active_country_locale (priv->account_country_selector); + mcc = modest_country_selector_get_active_country_mcc (priv->account_country_selector); + modest_provider_selector_fill ( + priv->account_serviceprovider_selector, 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)); + if (GTK_IS_COMBO_BOX (priv->account_serviceprovider_selector)) { + g_signal_connect (priv->account_serviceprovider_selector, + "changed", + G_CALLBACK (on_account_serviceprovider_selector_combo_box_changed), self); + } else { +#ifdef HILDON_PICKER_BUTTON + g_signal_connect (G_OBJECT (hildon_picker_button_get_selector + (HILDON_PICKER_BUTTON (priv->account_serviceprovider_selector))), + "changed", + G_CALLBACK (on_account_serviceprovider_selector_changed), self); +#endif + } + modest_provider_selector_set_others_provider (priv->account_serviceprovider_selector); } priv->dirty = FALSE; @@ -1373,7 +1496,7 @@ static void init_incoming_page (ModestEasysetupWizardDialogPrivate *priv) { priv->page_custom_incoming = NULL; - priv->incoming_servertype_picker = NULL; + priv->incoming_servertype_selector = NULL; priv->caption_incoming = NULL; priv->entry_incomingserver = NULL; priv->entry_user_email = NULL; @@ -1424,6 +1547,8 @@ modest_easysetup_wizard_dialog_init (ModestEasysetupWizardDialog *self) priv->check_support_done = FALSE; priv->check_support_show_progress_id = 0; priv->check_support_progress_pulse_id = 0; + priv->check_support_cancel_note = NULL; + priv->check_support_progress = NULL; priv->pending_check_support = 0; priv->destroyed = FALSE; priv->page_welcome = create_page_welcome (self); @@ -1484,7 +1609,6 @@ modest_easysetup_wizard_dialog_init (ModestEasysetupWizardDialog *self) priv->settings = modest_account_settings_new (); - check_support_of_protocols (self); } ModestEasysetupWizardDialog* @@ -1567,17 +1691,31 @@ create_subsequent_easysetup_pages (ModestEasysetupWizardDialog *self) /* */ static void -remove_non_common_tabs (GtkNotebook *notebook, +remove_non_common_tabs (ModestEasysetupWizardDialog *self, gboolean remove_user_details) { gint starting_tab; + GtkNotebook *notebook; + ModestEasysetupWizardDialogPrivate *priv; + + priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + g_object_get (self, "wizard-notebook", ¬ebook, NULL); + /* The first 2 tabs are the common ones (welcome tab and the providers tab), so we always remove starting from the end */ - starting_tab = (remove_user_details) ? 2 : 3; - while (gtk_notebook_get_n_pages (notebook) > starting_tab) + while (gtk_notebook_get_n_pages (notebook) > starting_tab) { + /* Disconnect signal */ + GtkWidget *page = gtk_notebook_get_nth_page (notebook, -1); + if (modest_signal_mgr_is_connected (priv->missing_data_signals, (GObject *) page, "missing-mandatory-data")) { + priv->missing_data_signals = modest_signal_mgr_disconnect (priv->missing_data_signals, + (GObject *) page, + "missing-mandatory-data"); + } + /* Remove page from notebook */ gtk_notebook_remove_page (notebook, -1); + } } static void @@ -1596,30 +1734,34 @@ static void create_subsequent_pages (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv; - ModestProviderPicker *picker; - ModestProviderPickerIdType id_type; + GtkWidget *picker; + ModestProviderSelectorIdType id_type; GtkNotebook *notebook; priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); - picker = MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker); - id_type = modest_provider_picker_get_active_id_type (picker); + picker = priv->account_serviceprovider_selector; + id_type = modest_provider_selector_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); + /* Remove the response override handler for non-plugin + protocols. For plugins it'll be overriden later */ + if (id_type != MODEST_PROVIDER_SELECTOR_ID_PLUGIN_PROTOCOL) + modest_wizard_dialog_set_response_override_handler (MODEST_WIZARD_DIALOG (self), + NULL); - if (id_type == MODEST_PROVIDER_PICKER_ID_OTHER) { + + if (id_type == MODEST_PROVIDER_SELECTOR_ID_OTHER) { /* "Other..." was selected: */ /* If we come from a rollbacked easysetup */ if (priv->page_complete_easysetup) { - remove_non_common_tabs (notebook, FALSE); + remove_non_common_tabs (self, FALSE); priv->page_complete_easysetup = NULL; } /* If we come from a rollbacked plugin protocol setup */ if (priv->last_plugin_protocol_selected != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) { - remove_non_common_tabs (notebook, TRUE); + remove_non_common_tabs (self, TRUE); priv->last_plugin_protocol_selected = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID; modest_signal_mgr_disconnect_all_and_destroy (priv->missing_data_signals); priv->missing_data_signals = NULL; @@ -1629,7 +1771,7 @@ create_subsequent_pages (ModestEasysetupWizardDialog *self) } else { /* If we come from a rollbacked custom setup */ if (priv->page_custom_incoming) { - remove_non_common_tabs (notebook, TRUE); + remove_non_common_tabs (self, TRUE); init_user_page (priv); init_incoming_page (priv); init_outgoing_page (priv); @@ -1638,13 +1780,14 @@ create_subsequent_pages (ModestEasysetupWizardDialog *self) } /* It's a pluggable protocol and not a provider with presets */ - if (id_type == MODEST_PROVIDER_PICKER_ID_PLUGIN_PROTOCOL) { + if (id_type == MODEST_PROVIDER_SELECTOR_ID_PLUGIN_PROTOCOL) { ModestProtocol *protocol; gchar *proto_name; ModestProtocolType proto_type; + ModestWizardDialogResponseOverrideFunc response_override; /* Get protocol data */ - proto_name = modest_provider_picker_get_active_provider_id (picker); + proto_name = modest_provider_selector_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); @@ -1654,27 +1797,30 @@ create_subsequent_pages (ModestEasysetupWizardDialog *self) /* If we come from a rollbacked easy setup */ if (priv->last_plugin_protocol_selected != proto_type && priv->page_complete_easysetup) { - remove_non_common_tabs (notebook, TRUE); + remove_non_common_tabs (self, TRUE); init_user_page (priv); priv->page_complete_easysetup = NULL; } + /* Ensure that the response override handler + is set. It might happen that plugins clear + them incorrectly */ + 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); + if (protocol && MODEST_IS_ACCOUNT_PROTOCOL (protocol) && 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; @@ -1708,7 +1854,7 @@ create_subsequent_pages (ModestEasysetupWizardDialog *self) } else { if (priv->last_plugin_protocol_selected != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) { - remove_non_common_tabs (notebook, TRUE); + remove_non_common_tabs (self, TRUE); init_user_page (priv); priv->page_complete_easysetup = NULL; priv->last_plugin_protocol_selected = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID; @@ -1776,18 +1922,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 = modest_servertype_picker_get_active_servertype ( - MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker)); + const ModestProtocolType protocol_type = modest_servertype_selector_get_active_servertype ( + priv->incoming_servertype_selector); /* This could happen when the combo box has still no active iter */ if (protocol_type != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) { - const gchar* email_address = hildon_entry_get_text (HILDON_ENTRY(priv->entry_user_email)); + const gchar* email_address = modest_entry_get_text (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); - hildon_entry_set_text (HILDON_ENTRY (priv->entry_incomingserver), servername); + modest_entry_set_text (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); @@ -1802,13 +1948,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 = hildon_entry_get_text (HILDON_ENTRY(priv->entry_user_email)); + const gchar* email_address = modest_entry_get_text (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); - hildon_entry_set_text (HILDON_ENTRY (priv->entry_outgoingserver), servername); + modest_entry_set_text (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); @@ -1822,7 +1968,7 @@ get_entered_account_title (ModestEasysetupWizardDialog *self) const gchar* account_title; priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); - account_title = hildon_entry_get_text (HILDON_ENTRY (priv->entry_account_title)); + account_title = modest_entry_get_text (priv->entry_account_title); if (!account_title || (g_utf8_strlen (account_title, -1) == 0)) { return NULL; @@ -1861,7 +2007,12 @@ on_before_next (ModestWizardDialog *dialog, GtkWidget *current_page, GtkWidget * * either because it was too slow, * or because it requires interaction: */ - if (current_page == priv->page_account_details) { + if (current_page == priv->page_welcome) { + if (!priv->check_support_done) { + check_support_of_protocols (self); + return priv->check_support_done; + } + } else if (current_page == priv->page_account_details) { /* Check that the title is not already in use: */ gchar* account_title = get_entered_account_title (self); if (!account_title) @@ -1874,7 +2025,7 @@ on_before_next (ModestWizardDialog *dialog, GtkWidget *current_page, GtkWidget * if (name_in_use) { /* Warn the user via a dialog: */ - hildon_banner_show_information(NULL, NULL, _("mail_ib_account_name_already_existing")); + modest_platform_system_banner(NULL, NULL, _("mail_ib_account_name_already_existing")); return FALSE; } @@ -1884,13 +2035,13 @@ 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 = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_email)); + const gchar* email_address = modest_entry_get_text (priv->entry_user_email); if ((!email_address) || (g_utf8_strlen (email_address, -1) == 0)) return FALSE; if (!modest_text_utils_validate_email_address (email_address, NULL)) { /* Warn the user via a dialog: */ - hildon_banner_show_information (NULL, NULL, _("mcen_ib_invalid_email")); + modest_platform_system_banner (NULL, NULL, _("mcen_ib_invalid_email")); /* Return focus to the email address entry: */ gtk_widget_grab_focus (priv->entry_user_email); @@ -1959,7 +2110,7 @@ static gboolean entry_is_empty (GtkWidget *entry) if (!entry) return FALSE; - const gchar* text = hildon_entry_get_text (HILDON_ENTRY (entry)); + const gchar* text = modest_entry_get_text (entry); if ((!text) || (g_utf8_strlen (text, -1) == 0)) return TRUE; else { @@ -2008,7 +2159,7 @@ real_enable_buttons (ModestWizardDialog *dialog, gboolean enable_next) /* If the check support is not done then do not enable the wizard to continue */ - enable_next = enable_next && priv->check_support_done; + enable_next = enable_next && priv->pending_check_support == 0; } gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), @@ -2070,6 +2221,35 @@ modest_easysetup_wizard_dialog_class_init (ModestEasysetupWizardDialogClass *kla base_klass->save = on_save; } +static void +check_username_for_provider (const gchar *provider_id, + const gchar *domain, + gchar **username) +{ + gchar *providers_to_check[] = { "ovi.com", "yahoomailplus.com", "hotmail.com" }; + gint i; + gboolean found = FALSE; + gchar *old; + + /* Check if the username contains the @hostname, if not then add it */ + if (strchr (*username, '@')) + return; + + /* Check if it's one of the providers to check */ + for (i = 0; i < G_N_ELEMENTS (providers_to_check) && !found; i++) { + if (!g_ascii_strncasecmp (providers_to_check[i], provider_id, strlen (providers_to_check[i]))) + found = TRUE; + } + + if (!found) + return; + + /* Replace the username */ + old = *username; + *username = g_strconcat (*username, "@", domain, NULL); + g_free (old); +} + /** * save_to_settings: * @self: a #ModestEasysetupWizardDialog @@ -2082,7 +2262,8 @@ save_to_settings (ModestEasysetupWizardDialog *self) ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); guint special_port; gchar *provider_id = NULL; - gchar* display_name; + gchar *alternate_username = NULL; + gchar *display_name; const gchar *username, *password; gchar *store_hostname, *transport_hostname; guint store_port, transport_port; @@ -2092,20 +2273,20 @@ save_to_settings (ModestEasysetupWizardDialog *self) ModestProtocolType store_auth_protocol, transport_auth_protocol; ModestServerAccountSettings *store_settings, *transport_settings; const gchar *fullname, *email_address; - ModestProviderPicker *picker; - ModestProviderPickerIdType id_type; + GtkWidget *picker; + ModestProviderSelectorIdType id_type; priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); - picker = MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker); + picker = priv->account_serviceprovider_selector; protocol_registry = modest_runtime_get_protocol_registry (); /* Get details from the specified presets: */ - id_type = modest_provider_picker_get_active_id_type (picker); - provider_id = modest_provider_picker_get_active_provider_id (picker); + id_type = modest_provider_selector_get_active_id_type (picker); + provider_id = modest_provider_selector_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 == MODEST_PROVIDER_PICKER_ID_PLUGIN_PROTOCOL) { + if (id_type == MODEST_PROVIDER_SELECTOR_ID_PLUGIN_PROTOCOL) { ModestProtocol *protocol; protocol = modest_protocol_registry_get_protocol_by_name ( @@ -2139,8 +2320,8 @@ save_to_settings (ModestEasysetupWizardDialog *self) } /* username and password (for both incoming and outgoing): */ - username = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_username)); - password = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_password)); + username = modest_entry_get_text (priv->entry_user_username); + password = modest_entry_get_text (priv->entry_user_password); store_settings = modest_account_settings_get_store_settings (priv->settings); transport_settings = modest_account_settings_get_transport_settings (priv->settings); @@ -2156,6 +2337,8 @@ save_to_settings (ModestEasysetupWizardDialog *self) if (provider_id) { ModestProtocolType store_provider_server_type; gboolean store_provider_use_alternate_port; + gchar *domain = NULL; + /* Use presets: */ store_hostname = modest_presets_get_server (priv->presets, provider_id, TRUE /* store */); @@ -2173,6 +2356,17 @@ save_to_settings (ModestEasysetupWizardDialog *self) provider_id, TRUE /* store */); + + /* This is HORRIBLE, but it seems that somehow it helps users + that do not like to read the user instructions for their + email accounts */ + domain = modest_presets_get_domain (priv->presets, provider_id); + if (domain) { + alternate_username = g_strdup (username); + check_username_for_provider (provider_id, domain, &alternate_username); + g_free (domain); + } + /* We don't check for SMTP here as that is impossible for an incoming server. */ if (store_provider_server_type == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) store_protocol = MODEST_PROTOCOLS_STORE_POP; @@ -2199,9 +2393,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 (hildon_entry_get_text (HILDON_ENTRY (priv->entry_incomingserver) )); - store_protocol = modest_servertype_picker_get_active_servertype ( - MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker)); + store_hostname = g_strdup (modest_entry_get_text (priv->entry_incomingserver )); + store_protocol = modest_servertype_selector_get_active_servertype ( + priv->incoming_servertype_selector); modest_security_options_view_save_settings ( MODEST_SECURITY_OPTIONS_VIEW (priv->incoming_security), @@ -2210,7 +2404,7 @@ save_to_settings (ModestEasysetupWizardDialog *self) /* now we store the common store account settings */ modest_server_account_settings_set_hostname (store_settings, store_hostname); - modest_server_account_settings_set_username (store_settings, username); + modest_server_account_settings_set_username (store_settings, (alternate_username) ? alternate_username : username); modest_server_account_settings_set_password (store_settings, password); modest_server_account_settings_set_protocol (store_settings, store_protocol); @@ -2276,7 +2470,7 @@ save_to_settings (ModestEasysetupWizardDialog *self) registry = modest_runtime_get_protocol_registry (); /* Use custom pages because no preset was specified: */ - transport_hostname = g_strdup (hildon_entry_get_text (HILDON_ENTRY (priv->entry_outgoingserver) )); + transport_hostname = g_strdup (modest_entry_get_text (priv->entry_outgoingserver )); store_proto = modest_protocol_registry_get_protocol_by_type (registry, store_protocol); @@ -2296,15 +2490,17 @@ save_to_settings (ModestEasysetupWizardDialog *self) /* now we store the common transport account settings */ modest_server_account_settings_set_hostname (transport_settings, transport_hostname); - modest_server_account_settings_set_username (transport_settings, username); + modest_server_account_settings_set_username (transport_settings, (alternate_username) ? alternate_username : username); modest_server_account_settings_set_password (transport_settings, password); modest_server_account_settings_set_protocol (transport_settings, transport_protocol); g_object_unref (transport_settings); g_free (transport_hostname); + if (alternate_username) + g_free (alternate_username); - fullname = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_name)); - email_address = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_email)); + fullname = modest_entry_get_text (priv->entry_user_name); + email_address = modest_entry_get_text (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 @@ -2314,13 +2510,18 @@ save_to_settings (ModestEasysetupWizardDialog *self) 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))); + modest_togglable_get_active(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); + + /* This values are hardcoded for Fremantle */ + modest_account_settings_set_retrieve_type (priv->settings, + MODEST_ACCOUNT_RETRIEVE_MESSAGES_AND_ATTACHMENTS); + modest_account_settings_set_retrieve_limit (priv->settings, 20); } @@ -2365,8 +2566,8 @@ check_for_supported_auth_methods (ModestEasysetupWizardDialog* self) 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)); + protocol_type = modest_servertype_selector_get_active_servertype ( + priv->incoming_servertype_selector); 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 @@ -2420,38 +2621,35 @@ check_has_supported_auth_methods(ModestEasysetupWizardDialog* self) } static gboolean -check_support_progress_pulse (gpointer userdata) +check_support_show_progress (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; + priv->check_support_show_progress_id = 0; + + if (priv->destroyed) return FALSE; - } - gtk_progress_bar_pulse (GTK_PROGRESS_BAR (priv->check_support_progress)); + hildon_gtk_window_set_progress_indicator (GTK_WINDOW (self), TRUE); - return TRUE; + return FALSE; } static gboolean -check_support_show_progress (gpointer userdata) +check_support_progress_pulse (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) + if (priv->destroyed || priv->check_support_progress == NULL) { + priv->check_support_progress_pulse_id = 0; 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; + return TRUE; } static void @@ -2469,36 +2667,80 @@ check_support_callback (ModestAccountProtocol *protocol, 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->check_support_cancel_note) { + gtk_widget_destroy (priv->check_support_cancel_note); + priv->check_support_cancel_note = NULL; + priv->check_support_progress = NULL; + } + if (!priv->destroyed) { if (priv->presets) fill_providers (self); - gtk_widget_hide (priv->check_support_progress); + hildon_gtk_window_set_progress_indicator (GTK_WINDOW (self), FALSE); invoke_enable_buttons_vfunc (self); + gtk_dialog_response (GTK_DIALOG (self), MODEST_WIZARD_DIALOG_NEXT); } } g_object_unref (self); } +static void +on_check_support_cancel (GtkDialog *cancel_note, + gint response, + ModestEasysetupWizardDialog *self) +{ + ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); + ModestProtocolRegistry *registry; + GSList *provider_protos, *node; + + 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)) { + modest_account_protocol_cancel_check_support (MODEST_ACCOUNT_PROTOCOL (proto)); + } + } + g_slist_free (provider_protos); + + gtk_widget_destroy (GTK_WIDGET (cancel_note)); + priv->check_support_cancel_note = NULL; + priv->check_support_progress = NULL; +} static void check_support_of_protocols (ModestEasysetupWizardDialog *self) { ModestProtocolRegistry *registry; - GSList *provider_protos, *node; + GSList *provider_protos, *node, *check_support_providers; 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); + check_support_providers = NULL; for (node = provider_protos; node != NULL; node = g_slist_next (node)) { ModestProtocol *proto = MODEST_PROTOCOL (node->data); @@ -2519,19 +2761,37 @@ check_support_of_protocols (ModestEasysetupWizardDialog *self) 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)); + check_support_providers = g_slist_prepend (check_support_providers, proto); } } g_slist_free (provider_protos); + + for (node = check_support_providers; node != NULL; node = g_slist_next (node)) { + ModestProtocol *proto = MODEST_PROTOCOL (node->data); + + modest_account_protocol_check_support (MODEST_ACCOUNT_PROTOCOL (proto), + check_support_callback, + g_object_ref (self)); + } + g_slist_free (check_support_providers); 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); + priv->check_support_progress_pulse_id = g_timeout_add_full (G_PRIORITY_DEFAULT, 200, + check_support_progress_pulse, + g_object_ref (self), g_object_unref); + priv->check_support_progress = gtk_progress_bar_new (); + priv->check_support_cancel_note = hildon_note_new_cancel_with_progress_bar (GTK_WINDOW (self), + _("mcen_cn_availability_check"), + GTK_PROGRESS_BAR (priv->check_support_progress)); + gtk_widget_show (priv->check_support_cancel_note); + g_signal_connect (priv->check_support_cancel_note, "response", G_CALLBACK (on_check_support_cancel), self); } else { priv->check_support_done = TRUE; + if (priv->presets) + fill_providers (self); } invoke_enable_buttons_vfunc (self); }