X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmaemo%2Fmodest-account-settings-dialog.c;h=592303464cf3f1d41644a3fda7dbf94b9ea50e4a;hp=21ba1cf5eba8b9552912c7a1668a33297792de99;hb=12f0687cf55bb339ad9892cbce8c7d35a6509af5;hpb=3004a44def3f307f1243ce936d21abcd09d3fcd3 diff --git a/src/maemo/modest-account-settings-dialog.c b/src/maemo/modest-account-settings-dialog.c index 21ba1cf..5923034 100644 --- a/src/maemo/modest-account-settings-dialog.c +++ b/src/maemo/modest-account-settings-dialog.c @@ -1,6 +1,30 @@ -/* Copyright (c) 2007, Nokia Corporation +/* Copyright (c) 2006, Nokia Corporation * All rights reserved. * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the Nokia Corporation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ @@ -26,9 +50,17 @@ #include "modest-account-mgr.h" #include "modest-account-mgr-helpers.h" /* For modest_account_mgr_get_account_data(). */ #include "modest-runtime.h" /* For modest_runtime_get_account_mgr(). */ +#include "modest-protocol-info.h" #include "maemo/modest-connection-specific-smtp-window.h" #include "maemo/modest-signature-editor-dialog.h" -#include +#include "maemo/modest-maemo-utils.h" +#include "widgets/modest-ui-constants.h" + +#include +#include +#include +#include + #include #include /* For strlen(). */ @@ -107,10 +139,7 @@ modest_account_settings_dialog_finalize (GObject *object) } static void -show_error (GtkWindow *parent_window, const gchar* text); - -static void -show_ok (GtkWindow *parent_window, const gchar* text); +show_error (GtkWidget *parent_widget, const gchar* text); static void on_combo_incoming_security_changed (GtkComboBox *widget, gpointer user_data); @@ -139,21 +168,32 @@ on_modified_checkbox_toggled (GtkToggleButton *togglebutton, gpointer user_data) self->modified = TRUE; } +static void +on_modified_number_editor_changed (HildonNumberEditor *number_editor, gint new_value, gpointer user_data) +{ + ModestAccountSettingsDialog *self = MODEST_ACCOUNT_SETTINGS_DIALOG (user_data); + self->modified = TRUE; +} + /* Set a modified boolean whenever the widget is changed, * so we can check for it later. */ static void connect_for_modified (ModestAccountSettingsDialog *self, GtkWidget *widget) { - if (GTK_IS_ENTRY (widget)) { - g_signal_connect (G_OBJECT (widget), "changed", - G_CALLBACK (on_modified_entry_changed), self); + if (HILDON_IS_NUMBER_EDITOR (widget)) { + g_signal_connect (G_OBJECT (widget), "notify::value", + G_CALLBACK (on_modified_number_editor_changed), self); + } + else if (GTK_IS_ENTRY (widget)) { + g_signal_connect (G_OBJECT (widget), "changed", + G_CALLBACK (on_modified_entry_changed), self); } else if (GTK_IS_COMBO_BOX (widget)) { g_signal_connect (G_OBJECT (widget), "changed", - G_CALLBACK (on_modified_combobox_changed), self); + G_CALLBACK (on_modified_combobox_changed), self); } else if (GTK_IS_TOGGLE_BUTTON (widget)) { g_signal_connect (G_OBJECT (widget), "toggled", - G_CALLBACK (on_modified_checkbox_toggled), self); + G_CALLBACK (on_modified_checkbox_toggled), self); } } @@ -176,19 +216,18 @@ on_caption_combobox_changed (GtkComboBox *widget, gpointer user_data) /** This is a convenience function to create a caption containing a mandatory widget. * When the widget is edited, the enable_buttons() vfunc will be called. */ -static GtkWidget* create_caption_new_with_asterix(ModestAccountSettingsDialog *self, +static GtkWidget* create_caption_new_with_asterisk(ModestAccountSettingsDialog *self, GtkSizeGroup *group, const gchar *value, GtkWidget *control, GtkWidget *icon, HildonCaptionStatus flag) { - GtkWidget *caption = hildon_caption_new (group, value, control, icon, flag); + GtkWidget *caption = NULL; -/* The translated strings seem to already contain the *, - * but this code can be used if that is not true in future. - */ -#if 0 + /* Note: Previously, the translated strings already contained the "*", + * Comment out this code if they do again. + */ /* Add a * character to indicate mandatory fields, * as specified in our "Email UI Specification": */ if (flag == HILDON_CAPTION_MANDATORY) { @@ -198,7 +237,6 @@ static GtkWidget* create_caption_new_with_asterix(ModestAccountSettingsDialog *s } else caption = hildon_caption_new (group, value, control, icon, flag); -#endif /* Connect to the appropriate changed signal for the widget, * so we can ask for the prev/next buttons to be enabled/disabled appropriately: @@ -216,12 +254,23 @@ static GtkWidget* create_caption_new_with_asterix(ModestAccountSettingsDialog *s return caption; } +static void +on_entry_invalid_character (ModestValidatingEntry *self, const gchar* character, gpointer user_data) +{ + /* ModestEasysetupWizardDialog *dialog = MODEST_EASYSETUP_WIZARD_DIALOG (user_data); */ + /* We could add a special case for whitespace here + if (character == NULL) ... + */ + /* TODO: Should this show just this one bad character or all the not-allowed characters? */ + gchar *message = g_strdup_printf (_CS("ckdg_ib_illegal_characters_entered"), character); + show_error (GTK_WIDGET (self), message); +} static void on_entry_max (ModestValidatingEntry *self, gpointer user_data) { - ModestAccountSettingsDialog *dialog = MODEST_ACCOUNT_SETTINGS_DIALOG (user_data); - show_error (GTK_WINDOW (dialog), _("ckdg_ib_maximum_characters_reached")); + /* ModestAccountSettingsDialog *dialog = MODEST_ACCOUNT_SETTINGS_DIALOG (user_data); */ + show_error (GTK_WIDGET (self), _CS("ckdg_ib_maximum_characters_reached")); } static GtkWidget* @@ -242,7 +291,7 @@ create_page_account_details (ModestAccountSettingsDialog *self) /* Do use auto-capitalization: */ hildon_gtk_entry_set_input_mode (GTK_ENTRY (self->entry_account_title), HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_AUTOCAP); - GtkWidget *caption = create_caption_new_with_asterix (self, sizegroup, _("mcen_fi_account_title"), + GtkWidget *caption = create_caption_new_with_asterisk (self, sizegroup, _("mcen_fi_account_title"), self->entry_account_title, NULL, HILDON_CAPTION_MANDATORY); gtk_widget_show (self->entry_account_title); connect_for_modified (self, self->entry_account_title); @@ -266,6 +315,8 @@ create_page_account_details (ModestAccountSettingsDialog *self) modest_validating_entry_set_unallowed_characters ( MODEST_VALIDATING_ENTRY (self->entry_account_title), list_prevent); g_list_free (list_prevent); + modest_validating_entry_set_func(MODEST_VALIDATING_ENTRY(self->entry_account_title), + on_entry_invalid_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. */ @@ -275,7 +326,7 @@ create_page_account_details (ModestAccountSettingsDialog *self) /* The retrieve combobox: */ self->combo_retrieve = GTK_WIDGET (modest_retrieve_combo_box_new ()); - caption = create_caption_new_with_asterix (self, sizegroup, _("mcen_fi_advsetup_retrievetype"), + caption = create_caption_new_with_asterisk (self, sizegroup, _("mcen_fi_advsetup_retrievetype"), self->combo_retrieve, NULL, HILDON_CAPTION_MANDATORY); gtk_widget_show (self->combo_retrieve); connect_for_modified (self, self->combo_retrieve); @@ -284,7 +335,7 @@ create_page_account_details (ModestAccountSettingsDialog *self) /* The limit-retrieve combobox: */ self->combo_limit_retrieve = GTK_WIDGET (modest_limit_retrieve_combo_box_new ()); - caption = create_caption_new_with_asterix (self, sizegroup, _("mcen_fi_advsetup_limit_retrieve"), + caption = create_caption_new_with_asterisk (self, sizegroup, _("mcen_fi_advsetup_limit_retrieve"), self->combo_limit_retrieve, NULL, HILDON_CAPTION_MANDATORY); gtk_widget_show (self->combo_limit_retrieve); connect_for_modified (self, self->combo_limit_retrieve); @@ -294,12 +345,15 @@ create_page_account_details (ModestAccountSettingsDialog *self) /* The leave-messages widgets: */ if(!self->checkbox_leave_messages) self->checkbox_leave_messages = gtk_check_button_new (); - caption = create_caption_new_with_asterix (self, sizegroup, _("mcen_fi_advsetup_leave_on_server"), - self->checkbox_leave_messages, NULL, HILDON_CAPTION_MANDATORY); + if (!self->caption_leave_messages) { + self->caption_leave_messages = create_caption_new_with_asterisk (self, sizegroup, _("mcen_fi_advsetup_leave_on_server"), + self->checkbox_leave_messages, NULL, HILDON_CAPTION_MANDATORY); + } + gtk_widget_show (self->checkbox_leave_messages); connect_for_modified (self, self->checkbox_leave_messages); - gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, MODEST_MARGIN_HALF); - gtk_widget_show (caption); + gtk_box_pack_start (GTK_BOX (box), self->caption_leave_messages, FALSE, FALSE, MODEST_MARGIN_HALF); + gtk_widget_show (self->caption_leave_messages); gtk_widget_show (GTK_WIDGET (box)); @@ -346,11 +400,15 @@ static GtkWidget* create_page_user_details (ModestAccountSettingsDialog *self) { GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); + GtkAdjustment *focus_adjustment = NULL; /* Create a size group to be used by all captions. * Note that HildonCaption does not create a default size group if we do not specify one. * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */ GtkSizeGroup* sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); + GtkWidget *scrollwin = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); /* The name widgets: */ self->entry_user_name = GTK_WIDGET (modest_validating_entry_new ()); @@ -361,7 +419,7 @@ create_page_user_details (ModestAccountSettingsDialog *self) gtk_entry_set_max_length (GTK_ENTRY (self->entry_user_name), 64); modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (self->entry_user_name), on_entry_max, self); - GtkWidget *caption = create_caption_new_with_asterix (self, sizegroup, + GtkWidget *caption = create_caption_new_with_asterisk (self, sizegroup, _("mcen_li_emailsetup_name"), self->entry_user_name, NULL, HILDON_CAPTION_OPTIONAL); gtk_widget_show (self->entry_user_name); connect_for_modified (self, self->entry_user_name); @@ -381,7 +439,7 @@ create_page_user_details (ModestAccountSettingsDialog *self) self->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 (self->entry_user_username), HILDON_GTK_INPUT_MODE_FULL); - caption = create_caption_new_with_asterix (self, sizegroup, _("mail_fi_username"), + caption = create_caption_new_with_asterisk (self, sizegroup, _("mail_fi_username"), self->entry_user_username, NULL, HILDON_CAPTION_MANDATORY); gtk_widget_show (self->entry_user_username); connect_for_modified (self, self->entry_user_username); @@ -402,10 +460,11 @@ create_page_user_details (ModestAccountSettingsDialog *self) /* The password widgets: */ self->entry_user_password = gtk_entry_new (); /* Auto-capitalization is the default, so let's turn it off: */ - hildon_gtk_entry_set_input_mode (GTK_ENTRY (self->entry_user_password), HILDON_GTK_INPUT_MODE_FULL); + hildon_gtk_entry_set_input_mode (GTK_ENTRY (self->entry_user_password), + HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE); gtk_entry_set_visibility (GTK_ENTRY (self->entry_user_password), FALSE); /* gtk_entry_set_invisible_char (GTK_ENTRY (self->entry_user_password), '*'); */ - caption = create_caption_new_with_asterix (self, sizegroup, + caption = create_caption_new_with_asterisk (self, sizegroup, _("mail_fi_password"), self->entry_user_password, NULL, HILDON_CAPTION_OPTIONAL); gtk_widget_show (self->entry_user_password); connect_for_modified (self, self->entry_user_password); @@ -416,7 +475,7 @@ create_page_user_details (ModestAccountSettingsDialog *self) self->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 (self->entry_user_email), HILDON_GTK_INPUT_MODE_FULL); - caption = create_caption_new_with_asterix (self, sizegroup, + caption = create_caption_new_with_asterisk (self, sizegroup, _("mcen_li_emailsetup_email_address"), self->entry_user_email, NULL, HILDON_CAPTION_MANDATORY); gtk_entry_set_text (GTK_ENTRY (self->entry_user_email), EXAMPLE_EMAIL_ADDRESS); /* Default text. */ gtk_widget_show (self->entry_user_email); @@ -444,14 +503,19 @@ create_page_user_details (ModestAccountSettingsDialog *self) G_CALLBACK (on_button_signature), self); gtk_widget_show (GTK_WIDGET (box)); + gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrollwin), box); + gtk_widget_show (scrollwin); + + focus_adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrollwin)); + gtk_container_set_focus_vadjustment (GTK_CONTAINER (box), focus_adjustment); - return GTK_WIDGET (box); + return GTK_WIDGET (scrollwin); } /** Change the caption title for the incoming server, * as specified in the UI spec: */ -static void update_incoming_server_title (ModestAccountSettingsDialog *self, ModestProtocol protocol) +static void update_incoming_server_title (ModestAccountSettingsDialog *self, ModestTransportStoreProtocol protocol) { const gchar* type = (protocol == MODEST_PROTOCOL_STORE_POP ? @@ -463,14 +527,20 @@ static void update_incoming_server_title (ModestAccountSettingsDialog *self, Mod * because the compiler does not know that the translated string will have a %s in it. * I do not see a way to avoid the warning while still using these Logical IDs. murrayc. */ gchar* incomingserver_title = g_strdup_printf(_("mcen_li_emailsetup_servertype"), type); - g_object_set (G_OBJECT (self->caption_incoming), "label", incomingserver_title, NULL); - g_free(incomingserver_title); + + /* This is a mandatory field, so add a *. This is usually done by + * create_caption_new_with_asterisk() but we can't use that here. */ + gchar *with_asterisk = g_strconcat (incomingserver_title, "*", NULL); + g_free (incomingserver_title); + + g_object_set (G_OBJECT (self->caption_incoming), "label", with_asterisk, NULL); + g_free(with_asterisk); } /** Change the caption title for the incoming server, * as specified in the UI spec: */ -static void update_incoming_server_security_choices (ModestAccountSettingsDialog *self, ModestProtocol protocol) +static void update_incoming_server_security_choices (ModestAccountSettingsDialog *self, ModestTransportStoreProtocol protocol) { /* Fill the combo with appropriately titled choices for POP or IMAP. */ /* The choices are the same, but the titles are different, as in the UI spec. */ @@ -499,7 +569,7 @@ static GtkWidget* create_page_incoming (ModestAccountSettingsDialog *self) /* The caption title will be updated in update_incoming_server_title(). * so this default text will never be seen: */ /* (Note: Changing the title seems pointless. murrayc) */ - self->caption_incoming = create_caption_new_with_asterix (self, sizegroup, + self->caption_incoming = create_caption_new_with_asterisk (self, sizegroup, "Incoming Server", self->entry_incomingserver, NULL, HILDON_CAPTION_MANDATORY); gtk_widget_show (self->entry_incomingserver); connect_for_modified (self, self->entry_incomingserver); @@ -593,7 +663,7 @@ on_combo_outgoing_auth_changed (GtkComboBox *widget, gpointer user_data) { ModestAccountSettingsDialog *self = MODEST_ACCOUNT_SETTINGS_DIALOG (user_data); - ModestProtocol protocol_security = + ModestAuthProtocol protocol_security = modest_secureauth_combo_box_get_active_secureauth ( MODEST_SECUREAUTH_COMBO_BOX (self->combo_outgoing_auth)); const gboolean secureauth_used = protocol_security != MODEST_PROTOCOL_AUTH_NONE; @@ -636,6 +706,13 @@ on_combo_incoming_security_changed (GtkComboBox *widget, gpointer user_data) static GtkWidget* create_page_outgoing (ModestAccountSettingsDialog *self) { GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE); + GtkAdjustment *focus_adjustment = NULL; + + /* Put it all in a scrolled window, so that all widgets can be + * accessed even when the on-screen keyboard is visible: */ + GtkWidget *scrollwin = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); /* Create a size group to be used by all captions. * Note that HildonCaption does not create a default size group if we do not specify one. @@ -647,7 +724,7 @@ static GtkWidget* create_page_outgoing (ModestAccountSettingsDialog *self) self->entry_outgoingserver = gtk_entry_new (); /* Auto-capitalization is the default, so let's turn it off: */ hildon_gtk_entry_set_input_mode (GTK_ENTRY (self->entry_outgoingserver), HILDON_GTK_INPUT_MODE_FULL); - GtkWidget *caption = create_caption_new_with_asterix (self, sizegroup, + GtkWidget *caption = create_caption_new_with_asterisk (self, sizegroup, _("mcen_li_emailsetup_smtp"), self->entry_outgoingserver, NULL, HILDON_CAPTION_OPTIONAL); gtk_widget_show (self->entry_outgoingserver); connect_for_modified (self, self->entry_outgoingserver); @@ -671,7 +748,7 @@ static GtkWidget* create_page_outgoing (ModestAccountSettingsDialog *self) self->entry_outgoing_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 (self->entry_outgoing_username), HILDON_GTK_INPUT_MODE_FULL); - self->caption_outgoing_username = create_caption_new_with_asterix (self, sizegroup, _("mail_fi_username"), + self->caption_outgoing_username = create_caption_new_with_asterisk (self, sizegroup, _("mail_fi_username"), self->entry_outgoing_username, NULL, HILDON_CAPTION_MANDATORY); gtk_widget_show (self->entry_outgoing_username); connect_for_modified (self, self->entry_outgoing_username); @@ -692,10 +769,11 @@ static GtkWidget* create_page_outgoing (ModestAccountSettingsDialog *self) /* The password widgets: */ self->entry_outgoing_password = gtk_entry_new (); /* Auto-capitalization is the default, so let's turn it off: */ - hildon_gtk_entry_set_input_mode (GTK_ENTRY (self->entry_outgoing_password), HILDON_GTK_INPUT_MODE_FULL); + hildon_gtk_entry_set_input_mode (GTK_ENTRY (self->entry_outgoing_password), + HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE); gtk_entry_set_visibility (GTK_ENTRY (self->entry_outgoing_password), FALSE); /* gtk_entry_set_invisible_char (GTK_ENTRY (self->entry_outgoing_password), '*'); */ - self->caption_outgoing_password = create_caption_new_with_asterix (self, sizegroup, + self->caption_outgoing_password = create_caption_new_with_asterisk (self, sizegroup, _("mail_fi_password"), self->entry_outgoing_password, NULL, HILDON_CAPTION_OPTIONAL); gtk_widget_show (self->entry_outgoing_password); connect_for_modified (self, self->entry_outgoing_password); @@ -707,6 +785,7 @@ static GtkWidget* create_page_outgoing (ModestAccountSettingsDialog *self) * and modest_serversecurity_combo_box_set_active_serversecurity(). */ if (!self->combo_outgoing_security) + self->combo_outgoing_security = GTK_WIDGET (modest_serversecurity_combo_box_new ()); caption = hildon_caption_new (sizegroup, _("mcen_li_emailsetup_secure_connection"), self->combo_outgoing_security, NULL, HILDON_CAPTION_OPTIONAL); @@ -761,11 +840,15 @@ static GtkWidget* create_page_outgoing (ModestAccountSettingsDialog *self) g_signal_connect (G_OBJECT (self->button_outgoing_smtp_servers), "clicked", G_CALLBACK (on_button_outgoing_smtp_servers), self); - - + gtk_widget_show (GTK_WIDGET (box)); + gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrollwin), box); + gtk_widget_show(scrollwin); + + focus_adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrollwin)); + gtk_container_set_focus_vadjustment (GTK_CONTAINER (box), focus_adjustment); - return GTK_WIDGET (box); + return GTK_WIDGET (scrollwin); } static gboolean @@ -783,7 +866,7 @@ check_data (ModestAccountSettingsDialog *self) if (name_in_use) { /* Warn the user via a dialog: */ - show_error (GTK_WINDOW (self), _("mail_ib_account_name_already_existing")); + hildon_banner_show_information(NULL, NULL, _("mail_ib_account_name_already_existing")); return FALSE; } @@ -794,16 +877,72 @@ check_data (ModestAccountSettingsDialog *self) if ((!email_address) || (strlen(email_address) == 0)) return FALSE; - if (!modest_text_utils_validate_email_address (email_address)) { + if (!modest_text_utils_validate_email_address (email_address, NULL)) { /* Warn the user via a dialog: */ - show_error (GTK_WINDOW (self), _("mcen_ib_invalid_email")); + /*show_error (GTK_WINDOW (self), _("mcen_ib_invalid_email"));*/ + hildon_banner_show_information (NULL, NULL, _("mcen_ib_invalid_email")); - /* Return focus to the email address entry: */ - gtk_widget_grab_focus (self->entry_user_email); - + /* Return focus to the email address entry: */ + gtk_widget_grab_focus (self->entry_user_email); + gtk_editable_select_region (GTK_EDITABLE (self->entry_user_email), 0, -1); return FALSE; } - + + /* Find a suitable authentication method when secure authentication is desired */ + const gchar* hostname = gtk_entry_get_text (GTK_ENTRY (self->entry_incomingserver)); + gint port_num = hildon_number_editor_get_value ( + HILDON_NUMBER_EDITOR (self->entry_incoming_port)); + const gchar* username = gtk_entry_get_text (GTK_ENTRY (self->entry_user_username)); + + const ModestConnectionProtocol protocol_security_incoming = modest_serversecurity_combo_box_get_active_serversecurity ( + MODEST_SERVERSECURITY_COMBO_BOX (self->combo_incoming_security)); + + /* If we use an encrypted protocol then there is no need to encrypt the password */ + if (!modest_protocol_info_is_secure(protocol_security_incoming)) + { + if (gtk_toggle_button_get_active ( + GTK_TOGGLE_BUTTON (self->checkbox_incoming_auth))) { + GError *error = NULL; + GList *list_auth_methods = + modest_maemo_utils_get_supported_secure_authentication_methods (self->incoming_protocol, + hostname, port_num, username, GTK_WINDOW (self), &error); + if (list_auth_methods) { + /* Use the first supported method. + * TODO: Should we prioritize them, to prefer a particular one? */ + GList* method; + for (method = list_auth_methods; method != NULL; method = g_list_next(method)) + { + ModestAuthProtocol proto = (ModestAuthProtocol)(GPOINTER_TO_INT(list_auth_methods->data)); + // Allow secure methods, e.g MD5 only + if (modest_protocol_info_auth_is_secure(proto)) + { + self->protocol_authentication_incoming = proto; + break; + } + } + g_list_free (list_auth_methods); + } + + if (list_auth_methods == NULL || + !modest_protocol_info_auth_is_secure(self->protocol_authentication_incoming)) + { + if(error == NULL || error->domain != modest_maemo_utils_get_supported_secure_authentication_error_quark() || + error->code != MODEST_MAEMO_UTILS_GET_SUPPORTED_SECURE_AUTHENTICATION_ERROR_CANCELED) + { + show_error (GTK_WIDGET (self), _("Could not discover supported secure authentication methods.")); + } + + if(error != NULL) + g_error_free(error); + + /* This is a nasty hack. jschmid. */ + /* Don't let the dialog close */ + /*g_signal_stop_emission_by_name (dialog, "response");*/ + return FALSE; + } + } + } + /* TODO: The UI Spec wants us to check that the servernames are valid, * but does not specify how. */ @@ -821,14 +960,12 @@ on_response (GtkDialog *wizard_dialog, enable_buttons (self); gboolean prevent_response = FALSE; - + /* Warn about unsaved changes: */ if (response_id == GTK_RESPONSE_CANCEL && self->modified) { - GtkDialog *dialog = GTK_DIALOG (gtk_message_dialog_new (GTK_WINDOW (self), - (GtkDialogFlags)0, - GTK_MESSAGE_INFO, - GTK_BUTTONS_OK_CANCEL, /* TODO: These button names are ambiguous, and not specified in the UI specification. */ - _("imum_nc_wizard_confirm_lose_changes") )); + 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. */ const gint dialog_response = gtk_dialog_run (dialog); gtk_widget_destroy (GTK_WIDGET (dialog)); @@ -837,25 +974,35 @@ on_response (GtkDialog *wizard_dialog, prevent_response = TRUE; } /* Check for invalid input: */ - else if (!check_data (self)) { + else if (response_id != GTK_RESPONSE_CANCEL && !check_data (self)) { prevent_response = TRUE; } if (prevent_response) { /* This is a nasty hack. murrayc. */ /* Don't let the dialog close */ - g_signal_stop_emission_by_name (wizard_dialog, "response"); + g_signal_stop_emission_by_name (wizard_dialog, "response"); return; } - if (response_id == GTK_RESPONSE_OK) { - /* Try to save the changes: */ - const gboolean saved = save_configuration (self); - if (saved) - show_ok (GTK_WINDOW (self), _("mcen_ib_advsetup_settings_saved")); - else - show_error (GTK_WINDOW (self), _("mail_ib_setting_failed")); + /* Try to save the changes if modified (NB #59251): */ + if (self->modified) + { + const gboolean saved = save_configuration (self); + if (saved) { + /* Do not show the account-saved dialog if we are just saving this + * temporarily, because from the user's point of view it will not + * really be saved (saved + enabled) until later. + */ + const gboolean enabled = + modest_account_mgr_get_enabled (self->account_manager, self->account_name); + if (enabled) + show_error (GTK_WIDGET (self), _("mcen_ib_advsetup_settings_saved")); + } + else + show_error (GTK_WIDGET (self), _("mail_ib_setting_failed")); + } } } @@ -864,11 +1011,8 @@ modest_account_settings_dialog_init (ModestAccountSettingsDialog *self) { /* Create the notebook to be used by the GtkDialog base class: * Each page of the notebook will be a page of the wizard: */ - GtkNotebook *notebook = GTK_NOTEBOOK (gtk_notebook_new()); + self->notebook = GTK_NOTEBOOK (gtk_notebook_new()); - - gtk_window_set_title (GTK_WINDOW (self), _("mcen_ti_emailsetup")); - /* Get the account manager object, * so we can check for existing accounts, * and create new accounts: */ @@ -876,6 +1020,8 @@ modest_account_settings_dialog_init (ModestAccountSettingsDialog *self) g_assert (self->account_manager); g_object_ref (self->account_manager); + self->protocol_authentication_incoming = MODEST_PROTOCOL_AUTH_PASSWORD; + /* Create the common pages, */ self->page_account_details = create_page_account_details (self); @@ -884,19 +1030,19 @@ modest_account_settings_dialog_init (ModestAccountSettingsDialog *self) self->page_outgoing = create_page_outgoing (self); /* Add the notebook pages: */ - gtk_notebook_append_page (notebook, self->page_account_details, + gtk_notebook_append_page (self->notebook, self->page_account_details, gtk_label_new (_("mcen_ti_account_settings_account"))); - gtk_notebook_append_page (notebook, self->page_user_details, + gtk_notebook_append_page (self->notebook, self->page_user_details, gtk_label_new (_("mcen_ti_account_settings_userinfo"))); - gtk_notebook_append_page (notebook, self->page_incoming, + gtk_notebook_append_page (self->notebook, self->page_incoming, gtk_label_new (_("mcen_ti_advsetup_retrieval"))); - gtk_notebook_append_page (notebook, self->page_outgoing, + gtk_notebook_append_page (self->notebook, self->page_outgoing, gtk_label_new (_("mcen_ti_advsetup_sending"))); GtkDialog *dialog = GTK_DIALOG (self); - gtk_container_add (GTK_CONTAINER (dialog->vbox), GTK_WIDGET (notebook)); + gtk_container_add (GTK_CONTAINER (dialog->vbox), GTK_WIDGET (self->notebook)); gtk_container_set_border_width (GTK_CONTAINER (dialog->vbox), MODEST_MARGIN_HALF); - gtk_widget_show (GTK_WIDGET (notebook)); + gtk_widget_show (GTK_WIDGET (self->notebook)); /* Add the buttons: */ gtk_dialog_add_button (GTK_DIALOG(self), GTK_STOCK_OK, GTK_RESPONSE_OK); @@ -910,7 +1056,12 @@ modest_account_settings_dialog_init (ModestAccountSettingsDialog *self) g_signal_connect (G_OBJECT (self), "response", G_CALLBACK (on_response), self); - self->modified = FALSE; + self->modified = FALSE; + + /* When this window is shown, hibernation should not be possible, + * because there is no sensible way to save the state: */ + modest_window_mgr_prevent_hibernation_while_window_is_shown ( + modest_runtime_get_window_mgr (), GTK_WINDOW (self)); } ModestAccountSettingsDialog* @@ -989,12 +1140,16 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo /* Only show the leave-on-server checkbox for POP, * as per the UI spec: */ if (incoming_account->proto != MODEST_PROTOCOL_STORE_POP) { - gtk_widget_hide (dialog->checkbox_leave_messages); + gtk_widget_hide (dialog->caption_leave_messages); } else { - gtk_widget_show (dialog->checkbox_leave_messages); + gtk_widget_show (dialog->caption_leave_messages); } - + + update_incoming_server_security_choices (dialog, incoming_account->proto); if (incoming_account) { + /* Remember this for later: */ + dialog->incoming_protocol = incoming_account->proto; + gtk_entry_set_text( GTK_ENTRY (dialog->entry_user_username), incoming_account->username ? incoming_account->username : ""); gtk_entry_set_text( GTK_ENTRY (dialog->entry_user_password), @@ -1003,28 +1158,58 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo gtk_entry_set_text( GTK_ENTRY (dialog->entry_incomingserver), incoming_account->hostname ? incoming_account->hostname : ""); - const ModestProtocol secure_auth = modest_server_account_get_secure_auth( - dialog->account_manager, incoming_account->account_name); - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dialog->checkbox_incoming_auth), - secure_auth == MODEST_PROTOCOL_AUTH_PASSWORD); - - update_incoming_server_title (dialog, incoming_account->proto); - update_incoming_server_security_choices (dialog, incoming_account->proto); - - const ModestProtocol security = modest_server_account_get_security ( + /* The UI spec says: + * If secure authentication is unchecked, allow sending username and password also as plain text. + * If secure authentication is checked, require one of the secure methods during connection: SSL, TLS, CRAM-MD5 etc. + * TODO: Do we need to discover which of these (SSL, TLS, CRAM-MD5) is supported? + */ + const ModestConnectionProtocol security = modest_server_account_get_security ( dialog->account_manager, incoming_account->account_name); modest_serversecurity_combo_box_set_active_serversecurity ( MODEST_SERVERSECURITY_COMBO_BOX (dialog->combo_incoming_security), security); + /* Check if we have + - a secure protocol + OR + - use encrypted passwords + */ + const ModestAuthProtocol secure_auth = modest_server_account_get_secure_auth( + dialog->account_manager, incoming_account->account_name); + dialog->protocol_authentication_incoming = secure_auth; + if (modest_protocol_info_is_secure(security) || + modest_protocol_info_auth_is_secure(secure_auth)) + { + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dialog->checkbox_incoming_auth), + TRUE); + } + else + { + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dialog->checkbox_incoming_auth), + FALSE); + }; + + update_incoming_server_title (dialog, incoming_account->proto); + const gint port_num = modest_account_mgr_get_int (dialog->account_manager, incoming_account->account_name, MODEST_ACCOUNT_PORT, TRUE /* server account */); - hildon_number_editor_set_value ( - HILDON_NUMBER_EDITOR (dialog->entry_incoming_port), port_num); - + + if (port_num == 0) { + /* Show the appropriate port number: */ + on_combo_incoming_security_changed ( + GTK_COMBO_BOX (dialog->combo_incoming_security), dialog); + } else { + /* Keep the user-entered port-number, + * or the already-appropriate automatic port number: */ + hildon_number_editor_set_value ( + HILDON_NUMBER_EDITOR (dialog->entry_incoming_port), port_num); + } } ModestServerAccountData *outgoing_account = account_data->transport_account; if (outgoing_account) { + /* Remember this for later: */ + dialog->outgoing_protocol = outgoing_account->proto; + gtk_entry_set_text( GTK_ENTRY (dialog->entry_outgoingserver), outgoing_account->hostname ? outgoing_account->hostname : ""); @@ -1034,7 +1219,7 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo outgoing_account->password ? outgoing_account->password : ""); /* Get the secure-auth setting: */ - const ModestProtocol secure_auth = modest_server_account_get_secure_auth( + const ModestAuthProtocol secure_auth = modest_server_account_get_secure_auth( dialog->account_manager, outgoing_account->account_name); modest_secureauth_combo_box_set_active_secureauth ( MODEST_SECUREAUTH_COMBO_BOX (dialog->combo_outgoing_auth), secure_auth); @@ -1044,17 +1229,48 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo MODEST_SERVERSECURITY_COMBO_BOX (dialog->combo_outgoing_security), outgoing_account->proto); /* Get the security setting: */ - const ModestProtocol security = modest_server_account_get_security ( + const ModestConnectionProtocol security = modest_server_account_get_security ( dialog->account_manager, outgoing_account->account_name); modest_serversecurity_combo_box_set_active_serversecurity ( MODEST_SERVERSECURITY_COMBO_BOX (dialog->combo_outgoing_security), security); const gint port_num = modest_account_mgr_get_int (dialog->account_manager, outgoing_account->account_name, MODEST_ACCOUNT_PORT, TRUE /* server account */); - hildon_number_editor_set_value ( - HILDON_NUMBER_EDITOR (dialog->entry_outgoing_port), port_num); + if (port_num == 0) { + /* Show the appropriate port number: */ + on_combo_outgoing_security_changed ( + GTK_COMBO_BOX (dialog->combo_outgoing_security), dialog); + } + else { + /* Keep the user-entered port-number, + * or the already-appropriate automatic port number: */ + hildon_number_editor_set_value ( + HILDON_NUMBER_EDITOR (dialog->entry_outgoing_port), port_num); + } + + const gboolean has_specific = + modest_account_mgr_get_has_connection_specific_smtp ( + dialog->account_manager, + account_name); + gtk_toggle_button_set_active ( + GTK_TOGGLE_BUTTON (dialog->checkbox_outgoing_smtp_specific), + has_specific); } - + + /* Set window title according to account: */ + /* TODO: Is this the correct way to find a human-readable name for + * the protocol used? */ + const gchar* proto_str = modest_protocol_info_get_transport_store_protocol_name (dialog->incoming_protocol); + gchar *proto_name = g_utf8_strup(proto_str, -1); + gchar *account_title = modest_account_mgr_get_display_name(dialog->account_manager, account_name); + + gchar *title = g_strdup_printf(_("mcen_ti_account_settings"), proto_name, account_title); + g_free (proto_name); + g_free (account_title); + + gtk_window_set_title (GTK_WINDOW (dialog), title); + g_free (title); + /* account_data->is_enabled, */ /*account_data->is_default, */ @@ -1066,6 +1282,24 @@ void modest_account_settings_dialog_set_account_name (ModestAccountSettingsDialo dialog->modified = FALSE; } +/** Show the User Info tab. + */ +void modest_account_settings_dialog_switch_to_user_info (ModestAccountSettingsDialog *dialog) +{ + const gint page_num = gtk_notebook_page_num (dialog->notebook, dialog->page_user_details); + if (page_num == -1) { + g_warning ("%s: notebook page not found.\n", __FUNCTION__); + } + + /* Ensure that the widget is visible so that gtk_notebook_set_current_page() works: */ + /* TODO: even this hack (recommened by the GTK+ documentation) doesn't seem to work. */ + + gtk_widget_show (dialog->page_user_details); + gtk_widget_show (GTK_WIDGET (dialog->notebook)); + gtk_widget_show (GTK_WIDGET (dialog)); + gtk_notebook_set_current_page (dialog->notebook, page_num); +} + static gboolean save_configuration (ModestAccountSettingsDialog *dialog) { @@ -1127,32 +1361,28 @@ save_configuration (ModestAccountSettingsDialog *dialog) return FALSE; const gchar* username = gtk_entry_get_text (GTK_ENTRY (dialog->entry_user_username)); - test = modest_account_mgr_set_string (dialog->account_manager, incoming_account_name, - MODEST_ACCOUNT_USERNAME, username, TRUE /* server account */); - if (!test) - return FALSE; - + modest_server_account_set_username (dialog->account_manager, incoming_account_name, username); + const gchar* password = gtk_entry_get_text (GTK_ENTRY (dialog->entry_user_password)); - test = modest_account_mgr_set_string (dialog->account_manager, incoming_account_name, - MODEST_ACCOUNT_PASSWORD, password, TRUE /* server account */); - if (!test) - return FALSE; - - const ModestProtocol protocol_authentication_incoming = gtk_toggle_button_get_active - (GTK_TOGGLE_BUTTON (dialog->checkbox_incoming_auth)) - ? MODEST_PROTOCOL_AUTH_PASSWORD - : MODEST_PROTOCOL_AUTH_NONE; - modest_server_account_set_secure_auth (dialog->account_manager, incoming_account_name, protocol_authentication_incoming); + modest_server_account_set_password (dialog->account_manager, incoming_account_name, password); - const ModestProtocol protocol_security_incoming = modest_serversecurity_combo_box_get_active_serversecurity ( - MODEST_SERVERSECURITY_COMBO_BOX (dialog->combo_incoming_security)); - modest_server_account_set_security (dialog->account_manager, incoming_account_name, protocol_security_incoming); - /* port: */ gint port_num = hildon_number_editor_get_value ( HILDON_NUMBER_EDITOR (dialog->entry_incoming_port)); modest_account_mgr_set_int (dialog->account_manager, incoming_account_name, MODEST_ACCOUNT_PORT, port_num, TRUE /* server account */); + + /* The UI spec says: + * If secure authentication is unchecked, allow sending username and password also as plain text. + * If secure authentication is checked, require one of the secure methods during connection: SSL, TLS, CRAM-MD5 etc. + */ + + const ModestConnectionProtocol protocol_security_incoming = modest_serversecurity_combo_box_get_active_serversecurity ( + MODEST_SERVERSECURITY_COMBO_BOX (dialog->combo_incoming_security)); + modest_server_account_set_security (dialog->account_manager, incoming_account_name, protocol_security_incoming); + + modest_server_account_set_secure_auth (dialog->account_manager, incoming_account_name, dialog->protocol_authentication_incoming); + g_free (incoming_account_name); @@ -1168,25 +1398,21 @@ save_configuration (ModestAccountSettingsDialog *dialog) return FALSE; username = gtk_entry_get_text (GTK_ENTRY (dialog->entry_outgoing_username)); - test = modest_account_mgr_set_string (dialog->account_manager, outgoing_account_name, - MODEST_ACCOUNT_USERNAME, username, TRUE /* server account */); - if (!test) - return FALSE; + modest_server_account_set_username (dialog->account_manager, outgoing_account_name, + username); password = gtk_entry_get_text (GTK_ENTRY (dialog->entry_outgoing_password)); - test = modest_account_mgr_set_string (dialog->account_manager, outgoing_account_name, - MODEST_ACCOUNT_PASSWORD, password, TRUE /* server account */); - if (!test) - return FALSE; + modest_server_account_set_password (dialog->account_manager, outgoing_account_name, + password); - const ModestProtocol protocol_security_outgoing = modest_serversecurity_combo_box_get_active_serversecurity ( + const ModestConnectionProtocol protocol_security_outgoing = modest_serversecurity_combo_box_get_active_serversecurity ( MODEST_SERVERSECURITY_COMBO_BOX (dialog->combo_outgoing_security)); modest_server_account_set_security (dialog->account_manager, outgoing_account_name, protocol_security_outgoing); - const ModestProtocol protocol_authentication_outgoing = modest_secureauth_combo_box_get_active_secureauth ( + const ModestAuthProtocol protocol_authentication_outgoing = modest_secureauth_combo_box_get_active_secureauth ( MODEST_SECUREAUTH_COMBO_BOX (dialog->combo_outgoing_auth)); modest_server_account_set_secure_auth (dialog->account_manager, outgoing_account_name, protocol_authentication_outgoing); - + /* port: */ port_num = hildon_number_editor_get_value ( HILDON_NUMBER_EDITOR (dialog->entry_outgoing_port)); @@ -1210,9 +1436,10 @@ save_configuration (ModestAccountSettingsDialog *dialog) } /* Save connection-specific SMTP server accounts: */ - if (dialog->specific_window) + if (dialog->specific_window) { return modest_connection_specific_smtp_window_save_server_accounts ( MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (dialog->specific_window), account_name); + } else return TRUE; } @@ -1273,36 +1500,21 @@ modest_account_settings_dialog_class_init (ModestAccountSettingsDialogClass *kla } static void -show_error (GtkWindow *parent_window, const gchar* text) +show_error (GtkWidget *parent_widget, const gchar* text) { - GtkDialog *dialog = GTK_DIALOG (hildon_note_new_information (parent_window, text)); - /* - GtkDialog *dialog = GTK_DIALOG (gtk_message_dialog_new (parent_window, - (GtkDialogFlags)0, - GTK_MESSAGE_ERROR, - GTK_BUTTONS_OK, - text )); - */ + hildon_banner_show_information(parent_widget, NULL, text); - gtk_dialog_run (dialog); - gtk_widget_destroy (GTK_WIDGET (dialog)); -} - -static void -show_ok (GtkWindow *parent_window, const gchar* text) -{ - GtkDialog *dialog = GTK_DIALOG (hildon_note_new_information (parent_window, text)); +#if 0 + GtkDialog *dialog = GTK_DIALOG (hildon_note_new_information (parent_widget, text); /* - GtkDialog *dialog = GTK_DIALOG (gtk_message_dialog_new (parent_window, - (GtkDialogFlags)0, - GTK_MESSAGE_INFO, - GTK_BUTTONS_OK, - text )); + GtkDialog *dialog = GTK_DIALOG (gtk_message_dialog_new (parent_window, + (GtkDialogFlags)0, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_OK, + text )); */ gtk_dialog_run (dialog); gtk_widget_destroy (GTK_WIDGET (dialog)); +#endif } - - -