X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fhildon2%2Fmodest-easysetup-wizard-dialog.c;h=8c9731ce2f3d85c5414316612edef97b14c9a1b0;hp=4cee57a3acd4008775c76b4ff73a2cc3c5f697dc;hb=366e77fcfcd44e42ad443802a10ac403056fbe89;hpb=702279725404c1737f5942bf4e2a41efbabedbf7 diff --git a/src/hildon2/modest-easysetup-wizard-dialog.c b/src/hildon2/modest-easysetup-wizard-dialog.c index 4cee57a..8c9731c 100644 --- a/src/hildon2/modest-easysetup-wizard-dialog.c +++ b/src/hildon2/modest-easysetup-wizard-dialog.c @@ -27,7 +27,7 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - + #include #include "modest-easysetup-wizard-dialog.h" #include @@ -59,6 +59,7 @@ #include "modest-hildon-includes.h" #include "modest-maemo-security-options-view.h" #include "modest-account-protocol.h" +#include "modest-address-book.h" /* Include config.h so that _() works: */ #ifdef HAVE_CONFIG_H @@ -71,7 +72,7 @@ G_DEFINE_TYPE (ModestEasysetupWizardDialog, modest_easysetup_wizard_dialog, MODE MODEST_TYPE_EASYSETUP_WIZARD_DIALOG, \ ModestEasysetupWizardDialogPrivate)) -#define LABELS_WIDTH 480 +#define LABELS_WIDTH 520 #define DIALOG_WIDTH LABELS_WIDTH + MODEST_MARGIN_DOUBLE typedef struct _ModestEasysetupWizardDialogPrivate ModestEasysetupWizardDialogPrivate; @@ -89,40 +90,40 @@ struct _ModestEasysetupWizardDialogPrivate /* Remember what fields the user edited manually to not prefill them * again. */ ModestEasysetupWizardDialogServerChanges server_changes; - + /* Check if the user changes a field to show a confirmation dialog */ gboolean dirty; /* If we have a pending load of settings or not. */ gboolean pending_load_settings; - + /* Used by derived widgets to query existing accounts, * and to create new accounts: */ ModestAccountMgr *account_manager; ModestAccountSettings *settings; - + /* 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; gint pending_check_support; gboolean destroyed; - + GtkWidget *page_account_details; GtkWidget *account_country_picker; GtkWidget *account_serviceprovider_picker; GtkWidget *entry_account_title; - + GtkWidget *caption_account_title; + GtkWidget *page_user_details; GtkWidget *entry_user_name; GtkWidget *entry_user_username; GtkWidget *entry_user_password; GtkWidget *entry_user_email; - + GtkWidget *page_complete_easysetup; - + GtkWidget *page_custom_incoming; GtkWidget *incoming_servertype_picker; GtkWidget *caption_incoming; @@ -136,7 +137,7 @@ struct _ModestEasysetupWizardDialogPrivate GtkWidget *entry_outgoingserver; GtkWidget *checkbox_outgoing_smtp_specific; GtkWidget *button_outgoing_smtp_servers; - + GtkWidget *page_complete_customsetup; ModestProtocolType last_plugin_protocol_selected; @@ -154,7 +155,6 @@ static void check_support_callback (ModestAccountProtocol *protocol, 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, @@ -184,11 +184,6 @@ modest_easysetup_wizard_dialog_dispose (GObject *object) 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); } @@ -198,10 +193,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); @@ -212,7 +207,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); } @@ -224,7 +219,7 @@ set_default_custom_servernames(ModestEasysetupWizardDialog *dialog); static void on_servertype_selector_changed(HildonTouchSelector *selector, gint column, gpointer user_data); -static gint +static gint get_port_from_protocol (ModestProtocolType server_type, gboolean alternate_port) { @@ -247,16 +242,16 @@ 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); } @@ -265,8 +260,12 @@ 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; + + g_return_if_fail (user_data); + + self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); + invoke_enable_buttons_vfunc(self); } @@ -294,6 +293,10 @@ on_serviceprovider_picker_button_value_changed (HildonPickerButton *widget, gpoi ModestEasysetupWizardDialog *self; ModestEasysetupWizardDialogPrivate *priv; ModestProviderPickerIdType provider_id_type; + ModestProtocol *protocol; + gchar *proto_name; + ModestProtocolType proto_type; + gboolean hide_account_title; self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); @@ -308,15 +311,40 @@ on_serviceprovider_picker_button_value_changed (HildonPickerButton *widget, gpoi GtkWidget *selector; selector = GTK_WIDGET (hildon_picker_button_get_selector (HILDON_PICKER_BUTTON (widget))); - default_account_name_start = + 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; + hide_account_title = FALSE; + proto_name = modest_provider_picker_get_active_provider_id (MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker)); + if (proto_name != NULL) { + protocol = modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (), + MODEST_PROTOCOL_REGISTRY_PROVIDER_PROTOCOLS, + proto_name); + if (protocol != NULL) { + proto_type = modest_protocol_get_type_id (protocol); + + hide_account_title = (modest_protocol_registry_protocol_type_has_tag + (modest_runtime_get_protocol_registry (), + proto_type, + MODEST_PROTOCOL_REGISTRY_SINGLETON_PROVIDER_PROTOCOLS) || + modest_protocol_registry_protocol_type_has_tag + (modest_runtime_get_protocol_registry (), + proto_type, + MODEST_PROTOCOL_REGISTRY_MULTI_MAILBOX_PROVIDER_PROTOCOLS)); + } + } + + if (hide_account_title) + gtk_widget_hide (priv->caption_account_title); + else + gtk_widget_show (priv->caption_account_title); + hildon_entry_set_text (HILDON_ENTRY (priv->entry_account_title), default_account_name); g_free (default_account_name); } @@ -324,7 +352,7 @@ on_serviceprovider_picker_button_value_changed (HildonPickerButton *widget, gpoi /** 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* +static GtkWidget* create_captioned (ModestEasysetupWizardDialog *self, GtkSizeGroup *title_size_group, GtkSizeGroup *value_size_group, @@ -334,56 +362,74 @@ create_captioned (ModestEasysetupWizardDialog *self, { GtkWidget *result; - result = modest_maemo_utils_create_captioned (title_size_group, value_size_group, - value, use_markup, control); + result = modest_maemo_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, + /* Connect to the appropriate changed signal for the widget, * so we can ask for the prev/next buttons to be enabled/disabled appropriately: */ if (GTK_IS_ENTRY (control)) { g_signal_connect (G_OBJECT (control), "changed", G_CALLBACK (on_caption_entry_changed), self); - + } else if (GTK_IS_COMBO_BOX (control)) { g_signal_connect (G_OBJECT (control), "changed", G_CALLBACK (on_caption_combobox_changed), self); } - + return result; } - + static GtkWidget* create_page_welcome (ModestEasysetupWizardDialog *self) { GtkWidget *box; - GtkWidget *label; + GtkWidget *align; + GtkWidget *label; + GtkWidget *privacy_note; + GtkWidget *pannable; ModestEasysetupWizardDialogPrivate *priv; priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); + pannable = hildon_pannable_area_new (); 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_widget_set_size_request (label, LABELS_WIDTH, -1); 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, FALSE, FALSE, 0); - gtk_box_pack_end (GTK_BOX (box), priv->check_support_progress, 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); + + hildon_pannable_area_add_with_viewport (HILDON_PANNABLE_AREA (pannable), align); gtk_widget_show (GTK_WIDGET (box)); - return GTK_WIDGET (box); + gtk_widget_show (GTK_WIDGET (align)); + gtk_widget_show (pannable); + + return GTK_WIDGET (pannable); } static void -on_account_country_selector_changed (HildonTouchSelector *widget, gint column, gpointer user_data) +on_account_country_selector_changed (HildonTouchSelector *widget, 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 picker, based on the selected country: */ if (priv->presets != NULL) { gint mcc = modest_country_picker_get_active_country_mcc ( @@ -396,9 +442,8 @@ on_account_country_selector_changed (HildonTouchSelector *widget, gint column, g static void update_user_email_from_provider (ModestEasysetupWizardDialog *self) { - ModestEasysetupWizardDialogPrivate *priv; - gchar* provider_id; - gchar* domain_name = NULL; + ModestEasysetupWizardDialogPrivate *priv; + gchar* provider_id = NULL, *with_at = NULL; g_assert(self); priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); @@ -406,18 +451,21 @@ update_user_email_from_provider (ModestEasysetupWizardDialog *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) - domain_name = modest_presets_get_domain (priv->presets, provider_id); - - if(!domain_name) - domain_name = g_strdup (MODEST_EXAMPLE_EMAIL_ADDRESS); - + + 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), domain_name); - - g_free (domain_name); - + hildon_entry_set_text (HILDON_ENTRY (priv->entry_user_email), with_at); + + g_free (with_at); g_free (provider_id); } @@ -427,7 +475,7 @@ on_account_serviceprovider_selector_changed (HildonTouchSelector *widget, gint c 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); @@ -443,14 +491,15 @@ on_entry_max (ModestValidatingEntry *self, gpointer user_data) static GtkWidget* create_page_account_details (ModestEasysetupWizardDialog *self) { - GtkWidget *caption; + GtkWidget *align; GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); GtkWidget *label = gtk_label_new(_("mcen_ia_accountdetails")); ModestEasysetupWizardDialogPrivate* priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); - gtk_widget_set_size_request (label, LABELS_WIDTH, -1); - gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, MODEST_MARGIN_HALF); + 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, FALSE, FALSE, 0); gtk_widget_show (label); /* Create a size group to be used by all captions. @@ -462,36 +511,31 @@ create_page_account_details (ModestEasysetupWizardDialog *self) /* 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, + 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); - - 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: */ + + /* 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"), + _("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_box_pack_start (GTK_BOX (box), priv->account_serviceprovider_picker, FALSE, FALSE, 0); gtk_widget_show (priv->account_serviceprovider_picker); - - /* The description widgets: */ + + /* The description widgets: */ priv->entry_account_title = GTK_WIDGET (modest_validating_entry_new ()); - g_signal_connect(G_OBJECT(priv->entry_account_title), "changed", - G_CALLBACK(on_easysetup_changed), self); + /* Do use auto-capitalization: */ - hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_account_title), + hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_account_title), HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_AUTOCAP); - + /* Set a default account title, choosing one that does not already exist: */ /* Note that this is irrelevant to the non-user visible name, which we will create later. */ gchar* default_account_name_start = g_strdup (_("mcen_ia_emailsetup_defaultname")); @@ -499,18 +543,24 @@ create_page_account_details (ModestEasysetupWizardDialog *self) 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); default_account_name = NULL; - caption = create_captioned (self, title_sizegroup, value_sizegroup, _("mcen_fi_account_title"), FALSE, - priv->entry_account_title); + /* Connect signal after changing the text in the entry */ + g_signal_connect(G_OBJECT(priv->entry_account_title), "changed", + G_CALLBACK(on_easysetup_changed), self); + + priv->caption_account_title = 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); - - /* Prevent the use of some characters in the account title, + gtk_box_pack_start (GTK_BOX (box), priv->caption_account_title, FALSE, FALSE, 0); + gtk_widget_show (priv->caption_account_title); + gtk_widget_set_no_show_all (priv->caption_account_title, TRUE); + + /* Prevent the use of some characters in the account title, * as required by our UI specification: */ GList *list_prevent = NULL; list_prevent = g_list_append (list_prevent, "\\"); @@ -520,31 +570,76 @@ create_page_account_details (ModestEasysetupWizardDialog *self) list_prevent = g_list_append (list_prevent, "?"); list_prevent = g_list_append (list_prevent, "\""); /* The UI spec mentions “, but maybe means ", maybe both. */ list_prevent = g_list_append (list_prevent, "“"); - list_prevent = g_list_append (list_prevent, "<"); - list_prevent = g_list_append (list_prevent, ">"); + list_prevent = g_list_append (list_prevent, "<"); + list_prevent = g_list_append (list_prevent, ">"); list_prevent = g_list_append (list_prevent, "|"); - list_prevent = g_list_append (list_prevent, "^"); + list_prevent = g_list_append (list_prevent, "^"); modest_validating_entry_set_unallowed_characters ( MODEST_VALIDATING_ENTRY (priv->entry_account_title), list_prevent); 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); - + /* Set max length as in the UI spec: * The UI spec seems to want us to show a dialog if we hit the maximum. */ gtk_entry_set_max_length (GTK_ENTRY (priv->entry_account_title), 64); - modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (priv->entry_account_title), + modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (priv->entry_account_title), on_entry_max, self); - + gtk_widget_show (GTK_WIDGET (box)); g_object_unref (title_sizegroup); g_object_unref (value_sizegroup); - - return GTK_WIDGET (box); + + align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); + gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE, 0); + gtk_widget_show (align); + gtk_container_add (GTK_CONTAINER (align), box); + + return GTK_WIDGET (align); +} + +static void +on_user_username_changed(GtkWidget* widget, ModestEasysetupWizardDialog *self) +{ + ModestEasysetupWizardDialogPrivate* priv; + gchar* provider_id = NULL; + + 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)); + + if (provider_id) { + const gchar *current_username; + gchar *email_address; + gchar *domain_name = modest_presets_get_domain (priv->presets, provider_id); + + current_username = hildon_entry_get_text (HILDON_ENTRY (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); + + g_free (email_address); + g_free (domain_name); + g_free (provider_id); + } + + /* Update state */ + on_easysetup_changed(widget, self); } + static GtkWidget* create_page_user_details (ModestEasysetupWizardDialog *self) { @@ -552,35 +647,43 @@ create_page_user_details (ModestEasysetupWizardDialog *self) GtkSizeGroup* value_sizegroup; GtkWidget *box; ModestEasysetupWizardDialogPrivate *priv; + GtkWidget *align; + const gchar *my_name; priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); - + /* 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. */ box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); 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 ()); - hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_user_name), + hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_user_name), HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_AUTOCAP); - + /* Set max length as in the UI spec: * The UI spec seems to want us to show a dialog if we hit the maximum. */ 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), + modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (priv->entry_user_name), on_entry_max, self); 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", + + /* Try to initialize the user name with my own contact */ + my_name = modest_address_book_get_my_name (); + if (my_name) + gtk_entry_set_text (GTK_ENTRY (priv->entry_user_name), my_name); + + g_signal_connect(G_OBJECT(priv->entry_user_name), "changed", G_CALLBACK(on_easysetup_changed), self); gtk_widget_show (priv->entry_user_name); - gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF); + gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, 0); gtk_widget_show (caption); - - /* Prevent the use of some characters in the name, + + /* Prevent the use of some characters in the name, * as required by our UI specification: */ GList *list_prevent = NULL; list_prevent = g_list_append (list_prevent, "<"); @@ -590,47 +693,47 @@ create_page_user_details (ModestEasysetupWizardDialog *self) modest_validating_entry_set_func(MODEST_VALIDATING_ENTRY(priv->entry_user_name), modest_utils_on_entry_invalid_character, self); g_list_free (list_prevent); - - /* The username widgets: */ + + /* The username widgets: */ priv->entry_user_username = 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_username), + hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_user_username), HILDON_GTK_INPUT_MODE_FULL); 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", - G_CALLBACK(on_easysetup_changed), self); + gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, 0); + g_signal_connect(G_OBJECT(priv->entry_user_username), "changed", + G_CALLBACK(on_user_username_changed), self); gtk_widget_show (caption); - - /* Prevent the use of some characters in the username, + + /* Prevent the use of some characters in the username, * as required by our UI specification: */ modest_validating_entry_set_func(MODEST_VALIDATING_ENTRY(priv->entry_user_username), 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. */ gtk_entry_set_max_length (GTK_ENTRY (priv->entry_user_username), 64); - modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (priv->entry_user_username), + modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (priv->entry_user_username), on_entry_max, self); - - /* The password widgets: */ + + /* The password widgets: */ 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_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_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_signal_connect(G_OBJECT(priv->entry_user_password), "changed", G_CALLBACK(on_easysetup_changed), self); gtk_widget_show (priv->entry_user_password); - gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF); + gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, 0); gtk_widget_show (caption); - - /* The email address widgets: */ + + /* The email address widgets: */ 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); @@ -638,33 +741,40 @@ create_page_user_details (ModestEasysetupWizardDialog *self) _("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", + gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, 0); + g_signal_connect(G_OBJECT(priv->entry_user_email), "changed", G_CALLBACK(on_easysetup_changed), self); gtk_widget_show (caption); - + /* Set max length as in the UI spec: * The UI spec seems to want us to show a dialog if we hit the maximum. */ gtk_entry_set_max_length (GTK_ENTRY (priv->entry_user_email), 64); - modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (priv->entry_user_email), + modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (priv->entry_user_email), on_entry_max, self); - - + + gtk_widget_show (GTK_WIDGET (box)); g_object_unref (title_sizegroup); g_object_unref (value_sizegroup); - return GTK_WIDGET (box); + align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); + gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE, 0); + gtk_widget_show (align); + gtk_container_add (GTK_CONTAINER (align), box); + + return GTK_WIDGET (align); } static GtkWidget* create_page_complete_easysetup (ModestEasysetupWizardDialog *self) { + GtkWidget *align; 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, LABELS_WIDTH, -1); + gtk_misc_set_padding (GTK_MISC (label), MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); @@ -674,22 +784,29 @@ create_page_complete_easysetup (ModestEasysetupWizardDialog *self) gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); 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_misc_set_padding (GTK_MISC (label), MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE); + gtk_misc_set_alignment (GTK_MISC (label), 0.0, 1.0); + gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0); gtk_widget_show (label); gtk_widget_show (GTK_WIDGET (box)); - return GTK_WIDGET (box); + + align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); + gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE, 0); + gtk_widget_show (align); + gtk_container_add (GTK_CONTAINER (align), box); + + return GTK_WIDGET (align); } -/** Change the caption title for the incoming server, +/** Change the caption title for the incoming server, * as specified in the UI spec: */ -static void +static void update_incoming_server_title (ModestEasysetupWizardDialog *self) { - ModestEasysetupWizardDialogPrivate* priv; - ModestProtocolType protocol_type; + ModestEasysetupWizardDialogPrivate* priv; + ModestProtocolType protocol_type; ModestProtocolRegistry *protocol_registry; priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); @@ -704,7 +821,7 @@ update_incoming_server_title (ModestEasysetupWizardDialog *self) const gchar *protocol_display_name; ModestProtocol *protocol; - protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, + protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, protocol_type); protocol_display_name = modest_protocol_get_display_name (protocol); @@ -717,10 +834,10 @@ update_incoming_server_title (ModestEasysetupWizardDialog *self) } } -/** Change the caption title for the incoming server, +/** Change the caption title for the incoming server, * as specified in the UI spec: */ -static void +static void update_incoming_server_security_choices (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); @@ -728,40 +845,36 @@ update_incoming_server_security_choices (ModestEasysetupWizardDialog *self) ModestProtocolType protocol_type; ModestSecurityOptionsView *view; - server_type_picker = + server_type_picker = MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker); - protocol_type = + protocol_type = modest_servertype_picker_get_active_servertype (server_type_picker); - + /* Fill the combo with appropriately titled choices for all those protocols */ view = MODEST_SECURITY_OPTIONS_VIEW (priv->incoming_security); modest_security_options_view_set_server_type (view, protocol_type); } -static void +static void 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); - ModestServertypePicker *picker; - ModestProtocolType protocol_type; priv->dirty = TRUE; - + /* Update title */ update_incoming_server_title (self); /* Update security options if needed */ - 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); set_default_custom_servernames (self); } -static void +static void on_entry_incoming_servername_changed(GtkEntry *entry, gpointer user_data) { ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); @@ -770,12 +883,13 @@ on_entry_incoming_servername_changed(GtkEntry *entry, gpointer user_data) priv->server_changes |= MODEST_EASYSETUP_WIZARD_DIALOG_INCOMING_CHANGED; } -static GtkWidget* +static GtkWidget* create_page_custom_incoming (ModestEasysetupWizardDialog *self) { ModestProtocolRegistry *protocol_registry; - ModestEasysetupWizardDialogPrivate* priv; - GtkWidget *box; + ModestEasysetupWizardDialogPrivate* priv; + GtkWidget *box; + GtkWidget *align; GtkWidget *pannable; GtkWidget *label; GtkSizeGroup *title_sizegroup; @@ -790,28 +904,32 @@ create_page_custom_incoming (ModestEasysetupWizardDialog *self) /* 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_misc_set_padding (GTK_MISC (label), MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE); + gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); 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. */ 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->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")); + 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, MODEST_MARGIN_HALF); + 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); - 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); set_default_custom_servernames (self); @@ -819,46 +937,57 @@ 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: */ priv->caption_incoming = create_captioned (self, title_sizegroup, value_sizegroup, - "This will be removed", + "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); + gtk_box_pack_start (GTK_BOX (box), priv->caption_incoming, FALSE, FALSE, 0); gtk_widget_show (priv->caption_incoming); - - /* 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); /* Remember when the servername was changed manually: */ g_signal_connect (G_OBJECT (priv->entry_incomingserver), "changed", G_CALLBACK (on_entry_incoming_servername_changed), self); /* The secure connection widgets. These are only valid for - protocols with security */ - priv->incoming_security = + protocols with security */ + priv->incoming_security = modest_maemo_security_options_view_new (MODEST_SECURITY_OPTIONS_INCOMING, 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); + 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_SERVERTYPE_PICKER (priv->incoming_servertype_picker), MODEST_PROTOCOLS_STORE_POP); + update_incoming_server_title (self); + update_incoming_server_security_choices (self); + set_default_custom_servernames (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))); + /* 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); + + 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); gtk_widget_show (GTK_WIDGET (box)); gtk_widget_show (pannable); g_object_unref (title_sizegroup); g_object_unref (value_sizegroup); + /* Connect changed signals. We do it here after initializing everything */ + g_signal_connect (G_OBJECT(priv->entry_incomingserver), "changed", + G_CALLBACK(on_easysetup_changed), self); + + return GTK_WIDGET (pannable); } @@ -866,7 +995,7 @@ static void on_check_button_changed (HildonCheckButton *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); gtk_widget_set_sensitive (widget, enable); @@ -879,7 +1008,7 @@ enable_widget_for_checkbutton (GtkWidget *widget, HildonCheckButton* button) { g_signal_connect (G_OBJECT (button), "toggled", G_CALLBACK (on_check_button_changed), widget); - + /* Set the starting sensitivity: */ on_check_button_changed (button, widget); } @@ -890,11 +1019,11 @@ on_button_outgoing_smtp_servers (GtkButton *button, gpointer user_data) ModestEasysetupWizardDialog * self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); ModestEasysetupWizardDialogPrivate* priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); GtkWidget *specific_window; - + /* We set dirty here because setting it depending on the connection specific dialog seems overkill */ priv->dirty = TRUE; - + /* Create the window, if necessary: */ specific_window = (GtkWidget *) modest_connection_specific_smtp_window_new (); modest_connection_specific_smtp_window_fill_with_connections (MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window), priv->account_manager); @@ -904,7 +1033,7 @@ on_button_outgoing_smtp_servers (GtkButton *button, gpointer user_data) gtk_widget_show (specific_window); } -static void +static void on_entry_outgoing_servername_changed (GtkEntry *entry, gpointer user_data) { ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); @@ -912,27 +1041,27 @@ on_entry_outgoing_servername_changed (GtkEntry *entry, gpointer user_data) priv->server_changes |= MODEST_EASYSETUP_WIZARD_DIALOG_OUTGOING_CHANGED; } -static GtkWidget* +static GtkWidget* create_page_custom_outgoing (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv; gchar *smtp_caption_label; GtkWidget *pannable; + GtkWidget *align; 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 *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 = 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); smtp_caption_label = g_strconcat (_("mcen_li_emailsetup_smtp"), "\n(SMTP)", NULL); @@ -940,48 +1069,46 @@ create_page_custom_outgoing (ModestEasysetupWizardDialog *self) 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_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, 0); gtk_widget_show (caption); set_default_custom_servernames (self); /* The secure connection widgets. These are only valid for - protocols with security */ - priv->outgoing_security = + protocols with security */ + priv->outgoing_security = modest_maemo_security_options_view_new (MODEST_SECURITY_OPTIONS_OUTGOING, FALSE, title_sizegroup, value_sizegroup); - gtk_box_pack_start (GTK_BOX (box), priv->outgoing_security, - FALSE, FALSE, MODEST_MARGIN_HALF); + gtk_box_pack_start (GTK_BOX (box), priv->outgoing_security, + FALSE, FALSE, 0); 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_box_pack_start (GTK_BOX (box), separator, FALSE, FALSE, 0); 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), + 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); gtk_widget_show (priv->checkbox_outgoing_smtp_specific); gtk_box_pack_start (GTK_BOX (box), priv->checkbox_outgoing_smtp_specific, - FALSE, FALSE, MODEST_MARGIN_HALF); + FALSE, FALSE, 0); /* Connection-specific SMTP-Severs Edit button: */ 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); + 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), priv->button_outgoing_smtp_servers, - FALSE, FALSE, MODEST_MARGIN_HALF); + gtk_box_pack_start (GTK_BOX (box), priv->button_outgoing_smtp_servers, + FALSE, FALSE, 0); /* Only enable the button when the checkbox is checked: */ - enable_widget_for_checkbutton (priv->button_outgoing_smtp_servers, + 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", @@ -991,15 +1118,24 @@ create_page_custom_outgoing (ModestEasysetupWizardDialog *self) 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))); + 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); gtk_widget_show (GTK_WIDGET (box)); gtk_widget_show (pannable); g_object_unref (title_sizegroup); g_object_unref (value_sizegroup); - + + /* Connect changed signals. We do it here after initializing everything */ + g_signal_connect (G_OBJECT (priv->entry_outgoingserver), "changed", + G_CALLBACK (on_easysetup_changed), self); + g_signal_connect (G_OBJECT (priv->checkbox_outgoing_smtp_specific), "toggled", + G_CALLBACK (on_easysetup_changed), self); + return GTK_WIDGET (pannable); } @@ -1009,7 +1145,7 @@ show_advanced_edit(gpointer user_data) ModestEasysetupWizardDialog * self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); gint response; - + /* Show the Account Settings window: */ ModestAccountSettingsDialog *dialog = modest_default_account_settings_dialog_new (); if (priv->pending_load_settings) { @@ -1017,13 +1153,13 @@ show_advanced_edit(gpointer user_data) priv->pending_load_settings = FALSE; } modest_account_settings_dialog_load_settings (dialog, priv->settings); - + modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog), GTK_WINDOW (self)); - + response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (GTK_WIDGET (dialog)); - + return FALSE; /* Do not call this timeout callback again. */ } @@ -1031,44 +1167,54 @@ static void on_button_edit_advanced_settings (GtkButton *button, gpointer user_data) { ModestEasysetupWizardDialog * self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); - + /* Show the Account Settings window: */ show_advanced_edit(self); } -static GtkWidget* +static GtkWidget* create_page_complete_custom (ModestEasysetupWizardDialog *self) { - 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_fi_advanced_settings")); - hildon_gtk_widget_set_theme_size (button_edit, HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH); + gchar *complete_string; + GtkWidget *align; + GtkWidget *box; + GtkWidget *label; + GtkWidget *button_edit; + + box = gtk_vbox_new (FALSE, MODEST_MARGIN_DEFAULT); + complete_string = g_strconcat (_("mcen_ia_emailsetup_setup_complete"), " ", + _("mcen_ia_customsetup_complete"), NULL); + label = gtk_label_new(complete_string); + g_free (complete_string); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); 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_padding (GTK_MISC (label), MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE); 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, TRUE, TRUE, 0); gtk_widget_show (label); + 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_widget_show (button_edit); - gtk_box_pack_start (GTK_BOX (box), button_edit, FALSE, FALSE, MODEST_MARGIN_HALF); + gtk_box_pack_start (GTK_BOX (box), button_edit, FALSE, FALSE, 0); - g_signal_connect (G_OBJECT (button_edit), "clicked", + 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); + + align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); + gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE, 0); + gtk_widget_show (align); + gtk_container_add (GTK_CONTAINER (align), box); + + return GTK_WIDGET (align); } /* */ -static void +static void on_response (ModestWizardDialog *wizard_dialog, gint response_id, gpointer user_data) @@ -1078,7 +1224,7 @@ on_response (ModestWizardDialog *wizard_dialog, invoke_enable_buttons_vfunc (self); } -static void +static void on_response_before (ModestWizardDialog *wizard_dialog, gint response_id, gpointer user_data) @@ -1089,12 +1235,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) { @@ -1117,11 +1268,10 @@ fill_providers (ModestEasysetupWizardDialog *self) 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_signal_connect ((GObject *) priv->account_country_picker, + "value-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 ( @@ -1130,11 +1280,11 @@ fill_providers (ModestEasysetupWizardDialog *self) 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 + 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)); } @@ -1180,9 +1330,9 @@ presets_loader (gpointer userdata) const gchar* path = NULL; const gchar* path1 = MODEST_PROVIDER_DATA_FILE; - const gchar* path2 = MODEST_MAEMO_PROVIDER_DATA_FILE; - - if (access(path1, R_OK) == 0) + const gchar* path2 = MODEST_FALLBACK_PROVIDER_DATA_FILE; + + if (access(path1, R_OK) == 0) path = path1; else if (access(path2, R_OK) == 0) path = path2; @@ -1197,12 +1347,12 @@ presets_loader (gpointer userdata) g_warning ("%s: failed to parse '%s'", __FUNCTION__, path); return NULL; } - + idle_data = g_new0 (IdleData, 1); idle_data->dialog = self; idle_data->presets = presets; - - g_idle_add (presets_idle, idle_data); + + g_idle_add (presets_idle, idle_data); return NULL; } @@ -1213,11 +1363,15 @@ modest_easysetup_wizard_dialog_append_page (GtkNotebook *notebook, const gchar *label) { gint index; + /* Append page and set attributes */ index = gtk_notebook_append_page (notebook, page, gtk_label_new (label)); gtk_container_child_set (GTK_CONTAINER (notebook), page, "tab-expand", TRUE, "tab-fill", TRUE, NULL); + + /* Give focus to page and show it */ + gtk_container_set_focus_child (GTK_CONTAINER (notebook), page); gtk_widget_show (page); } @@ -1256,67 +1410,68 @@ static void modest_easysetup_wizard_dialog_init (ModestEasysetupWizardDialog *self) { gtk_container_set_border_width (GTK_CONTAINER (self), MODEST_MARGIN_HALF); - + /* 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); - + /* Set the wizard title: * The actual window title will be a combination of this and the page's tab label title. */ g_object_set (G_OBJECT(self), "wizard-name", _("mcen_ti_emailsetup"), NULL); /* Read in the information about known service providers: */ ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); - + /* The server fields did not have been manually changed yet */ priv->server_changes = 0; priv->pending_load_settings = TRUE; - /* Get the account manager object, + /* Get the account manager object, * so we can check for existing accounts, * and create new accounts: */ priv->account_manager = modest_runtime_get_account_mgr (); 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->check_support_cancel_note = NULL; priv->pending_check_support = 0; priv->destroyed = FALSE; priv->page_welcome = create_page_welcome (self); + gtk_widget_show (priv->page_welcome); priv->page_account_details = create_page_account_details (self); init_user_page (priv); init_incoming_page (priv); init_outgoing_page (priv); - priv->page_complete_easysetup = NULL; + priv->page_complete_easysetup = NULL; priv->page_complete_customsetup = NULL; priv->last_plugin_protocol_selected = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID; priv->missing_data_signals = NULL; /* Add the common pages */ - modest_easysetup_wizard_dialog_append_page (notebook, priv->page_welcome, + modest_easysetup_wizard_dialog_append_page (notebook, priv->page_welcome, _("mcen_ti_emailsetup_welcome")); - modest_easysetup_wizard_dialog_append_page (notebook, priv->page_account_details, + modest_easysetup_wizard_dialog_append_page (notebook, priv->page_account_details, _("mcen_ti_accountdetails")); - - /* Connect to the dialog's response signal so we can enable/disable buttons + + /* Connect to the dialog's response signal so we can enable/disable buttons * for the newly-selected page, because the prev/next buttons cause response to be emitted. * Note that we use g_signal_connect_after() instead of g_signal_connect() - * so that we can be enable/disable after ModestWizardDialog has done its own + * so that we can be enable/disable after ModestWizardDialog has done its own * enabling/disabling of buttons. - * - * HOWEVER, this doesn't work because ModestWizardDialog's response signal handler + * + * HOWEVER, this doesn't work because ModestWizardDialog's response signal handler * does g_signal_stop_emission_by_name(), stopping our signal handler from running. - * - * It's not enough to connect to the notebook's switch-page signal, because - * ModestWizardDialog's "response" signal handler enables the buttons itself, + * + * It's not enough to connect to the notebook's switch-page signal, because + * ModestWizardDialog's "response" signal handler enables the buttons itself, * _after_ switching the page (understandably). * (Note that if we had, if we used g_signal_connect() instead of g_signal_connect_after() * then gtk_notebook_get_current_page() would return an incorrect value.) @@ -1333,11 +1488,11 @@ 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, + + /* When this window is shown, hibernation should not be possible, * because there is no sensible way to save the state: */ modest_window_mgr_prevent_hibernation_while_window_is_shown ( - modest_runtime_get_window_mgr (), GTK_WINDOW (self)); + modest_runtime_get_window_mgr (), GTK_WINDOW (self)); /* Load provider presets */ g_object_ref (self); @@ -1345,17 +1500,16 @@ modest_easysetup_wizard_dialog_init (ModestEasysetupWizardDialog *self) priv->settings = modest_account_settings_new (); - check_support_of_protocols (self); } ModestEasysetupWizardDialog* modest_easysetup_wizard_dialog_new (void) -{ - +{ + return g_object_new (MODEST_TYPE_EASYSETUP_WIZARD_DIALOG, NULL); } -static void +static void create_subsequent_customsetup_pages (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv; @@ -1368,18 +1522,18 @@ create_subsequent_customsetup_pages (ModestEasysetupWizardDialog *self) if (!priv->page_user_details) { priv->page_user_details = create_page_user_details (self); - } + } /* Create the custom pages: */ if(!(priv->page_custom_incoming)) { priv->page_custom_incoming = create_page_custom_incoming (self); } - + /* TODO: only if needed */ if(!(priv->page_custom_outgoing)) { priv->page_custom_outgoing = create_page_custom_outgoing (self); } - + if(!(priv->page_complete_customsetup)) { priv->page_complete_customsetup = create_page_complete_custom (self); } @@ -1389,22 +1543,22 @@ create_subsequent_customsetup_pages (ModestEasysetupWizardDialog *self) _("mcen_ti_emailsetup_userdetails")); if (!gtk_widget_get_parent (GTK_WIDGET (priv->page_custom_incoming))) - modest_easysetup_wizard_dialog_append_page (notebook, priv->page_custom_incoming, + modest_easysetup_wizard_dialog_append_page (notebook, priv->page_custom_incoming, _("mcen_ti_emailsetup_incomingdetails")); - - if (!gtk_widget_get_parent (GTK_WIDGET (priv->page_custom_outgoing))) - modest_easysetup_wizard_dialog_append_page (notebook, priv->page_custom_outgoing, + + if (!gtk_widget_get_parent (GTK_WIDGET (priv->page_custom_outgoing))) + modest_easysetup_wizard_dialog_append_page (notebook, priv->page_custom_outgoing, _("mcen_ti_emailsetup_outgoingdetails")); - + if (!gtk_widget_get_parent (GTK_WIDGET (priv->page_complete_customsetup))) - modest_easysetup_wizard_dialog_append_page (notebook, priv->page_complete_customsetup, + modest_easysetup_wizard_dialog_append_page (notebook, priv->page_complete_customsetup, _("mcen_ti_emailsetup_complete")); - + /* This is unnecessary with GTK+ 2.10: */ modest_wizard_dialog_force_title_update (MODEST_WIZARD_DIALOG(self)); } - -static void + +static void create_subsequent_easysetup_pages (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv; @@ -1412,33 +1566,47 @@ create_subsequent_easysetup_pages (ModestEasysetupWizardDialog *self) g_object_get (self, "wizard-notebook", ¬ebook, NULL); g_assert(notebook); - + /* Create the easysetup-specific pages: */ priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); if(!priv->page_complete_easysetup) priv->page_complete_easysetup = create_page_complete_easysetup (self); if (!gtk_widget_get_parent (GTK_WIDGET (priv->page_complete_easysetup))) - modest_easysetup_wizard_dialog_append_page (notebook, priv->page_complete_easysetup, + modest_easysetup_wizard_dialog_append_page (notebook, priv->page_complete_easysetup, _("mcen_ti_emailsetup_complete")); - + /* This is unnecessary with GTK+ 2.10: */ modest_wizard_dialog_force_title_update (MODEST_WIZARD_DIALOG(self)); } /* */ static void -remove_non_common_tabs (GtkNotebook *notebook, - gboolean remove_user_details) +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) - gtk_notebook_remove_page (notebook, -1); + 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 @@ -1450,10 +1618,10 @@ on_missing_mandatory_data (ModestAccountProtocol *protocol, } /* After the user details page, - * the following pages depend on whether "Other" was chosen + * the following pages depend on whether "Other" was chosen * in the provider combobox on the account page */ -static void +static void create_subsequent_pages (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv; @@ -1465,22 +1633,26 @@ create_subsequent_pages (ModestEasysetupWizardDialog *self) 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); - + + /* Remove the response override handler for non-plugin + protocols. For plugins it'll be overriden later */ + if (id_type != MODEST_PROVIDER_PICKER_ID_PLUGIN_PROTOCOL) + modest_wizard_dialog_set_response_override_handler (MODEST_WIZARD_DIALOG (self), + NULL); + if (id_type == MODEST_PROVIDER_PICKER_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; @@ -1490,7 +1662,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); @@ -1503,39 +1675,43 @@ create_subsequent_pages (ModestEasysetupWizardDialog *self) ModestProtocol *protocol; gchar *proto_name; ModestProtocolType proto_type; + ModestWizardDialogResponseOverrideFunc response_override; - - /* If we come from a rollbacked easy setup */ - if (priv->last_plugin_protocol_selected == - MODEST_PROTOCOL_REGISTRY_TYPE_INVALID && - priv->page_complete_easysetup) { - remove_non_common_tabs (notebook, TRUE); - init_user_page (priv); - priv->page_complete_easysetup = NULL; - } - + /* Get protocol data */ 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); proto_type = modest_protocol_get_type_id (protocol); + + /* If we come from a rollbacked easy setup */ + if (priv->last_plugin_protocol_selected != proto_type && + priv->page_complete_easysetup) { + 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; @@ -1550,11 +1726,11 @@ create_subsequent_pages (ModestEasysetupWizardDialog *self) /* Connect signals */ if (MODEST_IS_EASYSETUP_WIZARD_PAGE (pair->second)) { - priv->missing_data_signals = - modest_signal_mgr_connect (priv->missing_data_signals, - G_OBJECT (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), + G_CALLBACK (on_missing_mandatory_data), self); } @@ -1567,9 +1743,9 @@ create_subsequent_pages (ModestEasysetupWizardDialog *self) } g_free (proto_name); } else { - if (priv->last_plugin_protocol_selected != + 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; @@ -1578,12 +1754,12 @@ create_subsequent_pages (ModestEasysetupWizardDialog *self) } if (!priv->page_user_details) { priv->page_user_details = create_page_user_details (self); - modest_easysetup_wizard_dialog_append_page (notebook, + modest_easysetup_wizard_dialog_append_page (notebook, priv->page_user_details, _("mcen_ti_emailsetup_userdetails")); } } - + /* Create the easysetup pages: */ create_subsequent_easysetup_pages (self); } @@ -1601,37 +1777,37 @@ util_get_default_servername_from_email_address (const gchar* email_address, Mode if (!email_address) return NULL; - + at = g_utf8_strchr (email_address, -1, '@'); if (!at || (g_utf8_strlen (at, -1) < 2)) return NULL; - + domain = g_utf8_next_char (at); if(!domain) return NULL; protocol_registry = modest_runtime_get_protocol_registry (); protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, protocol_type); - + if (modest_protocol_registry_protocol_type_has_tag (protocol_registry, protocol_type, MODEST_PROTOCOL_REGISTRY_REMOTE_STORE_PROTOCOLS) || modest_protocol_registry_protocol_type_has_tag (protocol_registry, protocol_type, MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS)) { hostname = modest_protocol_get_name (protocol); } - + if (!hostname) return NULL; - + return g_strdup_printf ("%s.%s", hostname, domain); } -static void +static void set_default_custom_servernames (ModestEasysetupWizardDialog *self) { ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self); if (!priv->entry_incomingserver) return; - + /* Set a default domain for the server, based on the email address, * if no server name was already specified. */ @@ -1642,29 +1818,29 @@ set_default_custom_servernames (ModestEasysetupWizardDialog *self) /* 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)); - gchar* servername = util_get_default_servername_from_email_address (email_address, + 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); 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); } } - + /* Set a default domain for the server, based on the email address, * if no server name was already specified. */ if (!priv->entry_outgoingserver) return; - + 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)); - + 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 */ @@ -1691,15 +1867,15 @@ get_entered_account_title (ModestEasysetupWizardDialog *self) /* Strip it of whitespace at the start and end: */ gchar *result = g_strdup (account_title); result = g_strstrip (result); - + if (!result) return NULL; - + if (g_utf8_strlen (result, -1) == 0) { g_free (result); - return NULL; + return NULL; } - + return result; } } @@ -1717,17 +1893,22 @@ on_before_next (ModestWizardDialog *dialog, GtkWidget *current_page, GtkWidget * * this wizard */ if (next_page != NULL) priv->pending_load_settings = TRUE; - + /* Do extra validation that couldn't be done for every key press, * 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) return FALSE; - + /* 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); @@ -1736,7 +1917,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")); - + return FALSE; } @@ -1748,19 +1929,38 @@ on_before_next (ModestWizardDialog *dialog, GtkWidget *current_page, GtkWidget * 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; - + 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")); - + /* Return focus to the email address entry: */ gtk_widget_grab_focus (priv->entry_user_email); gtk_editable_select_region (GTK_EDITABLE (priv->entry_user_email), 0, -1); return FALSE; } + } else if (current_page == priv->page_custom_incoming || + current_page == priv->page_custom_outgoing) { + + const gchar *hostname; + GtkWidget *entry = (current_page == priv->page_custom_incoming) ? + priv->entry_incomingserver : + priv->entry_outgoingserver; + + hostname = gtk_entry_get_text (GTK_ENTRY (entry)); + if (!modest_text_utils_validate_domain_name (hostname)) { + /* Show error */ + modest_platform_information_banner (NULL, NULL, _("mcen_ib_invalid_servername")); + + /* Return focus to the email address entry: */ + gtk_widget_grab_focus (entry); + gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1); + + return FALSE; + } } - + if (next_page == priv->page_custom_incoming) { set_default_custom_servernames (self); } else if (next_page == priv->page_custom_outgoing) { @@ -1772,11 +1972,11 @@ on_before_next (ModestWizardDialog *dialog, GtkWidget *current_page, GtkWidget * return FALSE; gtk_widget_show (priv->outgoing_security); } - - /* If this is the last page, and this is a click on Finish, + + /* If this is the last page, and this is a click on Finish, * then attempt to create the dialog. */ - if(!next_page && + if(!next_page && current_page != priv->page_account_details) /* This is NULL when this is a click on Finish. */ { if (priv->pending_load_settings) { @@ -1791,8 +1991,8 @@ on_before_next (ModestWizardDialog *dialog, GtkWidget *current_page, GtkWidget * modest_account_mgr_add_account_from_settings (priv->account_manager, priv->settings); } - - + + return TRUE; } @@ -1800,7 +2000,7 @@ static gboolean entry_is_empty (GtkWidget *entry) { if (!entry) return FALSE; - + const gchar* text = hildon_entry_get_text (HILDON_ENTRY (entry)); if ((!text) || (g_utf8_strlen (text, -1) == 0)) return TRUE; @@ -1808,12 +2008,12 @@ static gboolean entry_is_empty (GtkWidget *entry) /* Strip it of whitespace at the start and end: */ gchar *stripped = g_strdup (text); stripped = g_strstrip (stripped); - + if (!stripped) return TRUE; - + const gboolean result = (g_utf8_strlen (stripped, -1) == 0); - + g_free (stripped); return result; } @@ -1821,7 +2021,7 @@ static gboolean entry_is_empty (GtkWidget *entry) static void real_enable_buttons (ModestWizardDialog *dialog, gboolean enable_next) -{ +{ GtkNotebook *notebook = NULL; gboolean is_finish_tab; GtkWidget *current; @@ -1830,7 +2030,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 */ @@ -1847,9 +2047,12 @@ real_enable_buttons (ModestWizardDialog *dialog, gboolean enable_next) gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), MODEST_WIZARD_DIALOG_FINISH, FALSE); - enable_next = priv->check_support_done; + + /* If the check support is not done then do not enable + the wizard to continue */ + enable_next = enable_next && priv->pending_check_support == 0; } - + gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), MODEST_WIZARD_DIALOG_NEXT, enable_next); @@ -1860,7 +2063,7 @@ on_enable_buttons (ModestWizardDialog *dialog, GtkWidget *current_page) { ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (dialog); ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); - + gboolean enable_next = TRUE; if (current_page == priv->page_welcome) { enable_next = TRUE; @@ -1868,11 +2071,11 @@ on_enable_buttons (ModestWizardDialog *dialog, GtkWidget *current_page) /* The account details title is mandatory: */ if (entry_is_empty(priv->entry_account_title)) enable_next = FALSE; - } else if (current_page == priv->page_user_details) { + } else if (current_page == priv->page_user_details) { /* The user details username is mandatory: */ if (entry_is_empty(priv->entry_user_username)) enable_next = FALSE; - + /* The user details email address is mandatory: */ if (enable_next && entry_is_empty (priv->entry_user_email)) enable_next = FALSE; @@ -1884,8 +2087,8 @@ on_enable_buttons (ModestWizardDialog *dialog, GtkWidget *current_page) enable_next = !modest_easysetup_wizard_page_validate ( MODEST_EASYSETUP_WIZARD_PAGE (current_page)); } - - /* Enable/disable buttons */ + + /* Enable/disable buttons */ real_enable_buttons (dialog, enable_next); } @@ -1898,8 +2101,8 @@ modest_easysetup_wizard_dialog_class_init (ModestEasysetupWizardDialogClass *kla object_class->dispose = modest_easysetup_wizard_dialog_dispose; object_class->finalize = modest_easysetup_wizard_dialog_finalize; - - /* Provide a vfunc implementation so we can decide + + /* Provide a vfunc implementation so we can decide * when to enable/disable the prev/next buttons. */ ModestWizardDialogClass *base_klass = (ModestWizardDialogClass*)(klass); @@ -1969,8 +2172,8 @@ save_to_settings (ModestEasysetupWizardDialog *self) priv->settings); g_list_free (wizard_pages); } else { - g_warning ("The selected protocol is a plugin protocol "// - "but it's not a ModestAccountProtocol"); + g_debug ("The selected protocol is a plugin protocol "// + "but it's not a ModestAccountProtocol"); } g_free (provider_id); @@ -1985,7 +2188,7 @@ save_to_settings (ModestEasysetupWizardDialog *self) transport_settings = modest_account_settings_get_transport_settings (priv->settings); /* Incoming server: */ - /* Note: We need something as default for the transport store protocol values, + /* Note: We need something as default for the transport store protocol values, * or modest_account_mgr_add_server_account will fail. */ store_port = 0; store_protocol = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID; @@ -2030,17 +2233,17 @@ save_to_settings (ModestEasysetupWizardDialog *self) store_port = get_port_from_protocol(store_provider_server_type, use_alternate_port); } - modest_server_account_settings_set_security_protocol (store_settings, + modest_server_account_settings_set_security_protocol (store_settings, store_security); - modest_server_account_settings_set_auth_protocol (store_settings, + modest_server_account_settings_set_auth_protocol (store_settings, store_auth_protocol); if (store_port != 0) 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_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_SERVERTYPE_PICKER (priv->incoming_servertype_picker)); modest_security_options_view_save_settings ( MODEST_SECURITY_OPTIONS_VIEW (priv->incoming_security), @@ -2055,53 +2258,59 @@ save_to_settings (ModestEasysetupWizardDialog *self) g_object_unref (store_settings); g_free (store_hostname); - + /* Outgoing server: */ transport_hostname = NULL; transport_protocol = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID; transport_security = MODEST_PROTOCOLS_CONNECTION_NONE; transport_auth_protocol = MODEST_PROTOCOLS_AUTH_NONE; transport_port = 0; - + if (provider_id) { ModestProtocolType transport_provider_server_type; ModestProtocolType transport_provider_security; + gboolean is_secure; /* Use presets */ - transport_hostname = modest_presets_get_server (priv->presets, provider_id, + transport_hostname = modest_presets_get_server (priv->presets, provider_id, FALSE /* transport */); - + transport_provider_server_type = modest_presets_get_info_server_type (priv->presets, - provider_id, - FALSE /* transport */); - transport_provider_security = modest_presets_get_info_server_security (priv->presets, - provider_id, + provider_id, + FALSE /* transport */); + transport_provider_security = modest_presets_get_info_server_security (priv->presets, + provider_id, FALSE /* transport */); /* Note: We need something as default, or modest_account_mgr_add_server_account will fail. */ transport_protocol = transport_provider_server_type; transport_security = transport_provider_security; - if (transport_security == MODEST_PROTOCOLS_CONNECTION_SSL) { - /* printf("DEBUG: %s: using secure SMTP\n", __FUNCTION__); */ - /* we check if there is a *special* port */ - special_port = modest_presets_get_port (priv->presets, provider_id, - FALSE /* transport */); - if (special_port != 0) - transport_port = special_port; - else - transport_port = 465; - transport_auth_protocol = MODEST_PROTOCOLS_AUTH_PASSWORD; + is_secure = modest_protocol_registry_protocol_type_is_secure (modest_runtime_get_protocol_registry (), + transport_security); + + /* we check if there is a *special* port */ + special_port = modest_presets_get_port (priv->presets, provider_id, + FALSE /* transport */); + if (special_port != 0) { + transport_port = special_port; } else { - /* printf("DEBUG: %s: using non-secure SMTP\n", __FUNCTION__); */ - transport_auth_protocol = MODEST_PROTOCOLS_AUTH_NONE; + gboolean use_alternate_port = FALSE; + if (transport_security == MODEST_PROTOCOLS_CONNECTION_SSL) + use_alternate_port = TRUE; + transport_port = get_port_from_protocol(transport_provider_server_type, use_alternate_port); } - modest_server_account_settings_set_security_protocol (transport_settings, + if (is_secure) + transport_auth_protocol = MODEST_PROTOCOLS_AUTH_PASSWORD; + else + transport_auth_protocol = MODEST_PROTOCOLS_AUTH_NONE; + + modest_server_account_settings_set_security_protocol (transport_settings, transport_security); - modest_server_account_settings_set_auth_protocol (transport_settings, + modest_server_account_settings_set_auth_protocol (transport_settings, transport_auth_protocol); if (transport_port != 0) - modest_server_account_settings_set_port (transport_settings, + modest_server_account_settings_set_port (transport_settings, transport_port); } else { ModestProtocolRegistry *registry; @@ -2111,7 +2320,7 @@ save_to_settings (ModestEasysetupWizardDialog *self) /* Use custom pages because no preset was specified: */ transport_hostname = g_strdup (hildon_entry_get_text (HILDON_ENTRY (priv->entry_outgoingserver) )); - store_proto = modest_protocol_registry_get_protocol_by_type (registry, + store_proto = modest_protocol_registry_get_protocol_by_type (registry, store_protocol); if (transport_protocol == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) { @@ -2154,6 +2363,11 @@ save_to_settings (ModestEasysetupWizardDialog *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); } @@ -2195,7 +2409,7 @@ check_for_supported_auth_methods (ModestEasysetupWizardDialog* self) 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 ( @@ -2239,7 +2453,7 @@ check_for_supported_auth_methods (ModestEasysetupWizardDialog* self) return NULL; } -static gboolean +static gboolean check_has_supported_auth_methods(ModestEasysetupWizardDialog* self) { GList* methods = check_for_supported_auth_methods(self); @@ -2252,23 +2466,7 @@ check_has_supported_auth_methods(ModestEasysetupWizardDialog* self) 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 +static gboolean check_support_show_progress (gpointer userdata) { ModestEasysetupWizardDialog *self = (ModestEasysetupWizardDialog *) userdata; @@ -2279,10 +2477,7 @@ check_support_show_progress (gpointer userdata) 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); + hildon_gtk_window_set_progress_indicator (GTK_WINDOW (self), TRUE); return FALSE; } @@ -2302,24 +2497,65 @@ 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; + } + 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); } + 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; +} static void check_support_of_protocols (ModestEasysetupWizardDialog *self) @@ -2329,18 +2565,18 @@ check_support_of_protocols (ModestEasysetupWizardDialog *self) ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self); registry = modest_runtime_get_protocol_registry (); - provider_protos = modest_protocol_registry_get_by_tag (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, + 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 + if (modest_protocol_registry_protocol_type_has_tag (registry, modest_protocol_get_type_id (proto), MODEST_PROTOCOL_REGISTRY_SINGLETON_PROVIDER_PROTOCOLS)) { @@ -2354,15 +2590,20 @@ check_support_of_protocols (ModestEasysetupWizardDialog *self) priv->pending_check_support ++; modest_account_protocol_check_support (MODEST_ACCOUNT_PROTOCOL (proto), check_support_callback, - self); + g_object_ref (self)); } } g_slist_free (provider_protos); if (priv->pending_check_support > 0) { - g_object_ref (self); - priv->check_support_show_progress_id = g_timeout_add (1000, check_support_show_progress, self); - + 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_cancel_note = hildon_note_new_cancel_with_progress_bar (GTK_WINDOW (self), + _("mcen_cn_availability_check"), + NULL); + 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; }