}
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);
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);
}
}
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*
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. */
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 ());
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,
/* The port widgets: */
/* TODO: There are various rules about this in the UI spec. */
if (!self->entry_incoming_port)
- self->entry_incoming_port = GTK_WIDGET (hildon_number_editor_new (0, 65535));
+ self->entry_incoming_port = GTK_WIDGET (hildon_number_editor_new (1, 65535));
caption = hildon_caption_new (sizegroup, _("mcen_fi_emailsetup_port"),
self->entry_incoming_port, NULL, HILDON_CAPTION_OPTIONAL);
gtk_widget_show (self->entry_incoming_port);
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.
* 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);
/* The port widgets: */
if (!self->entry_outgoing_port)
- self->entry_outgoing_port = GTK_WIDGET (hildon_number_editor_new (0, 65535));
+ self->entry_outgoing_port = GTK_WIDGET (hildon_number_editor_new (1, 65535));
caption = hildon_caption_new (sizegroup, _("mcen_fi_emailsetup_port"),
self->entry_outgoing_port, NULL, HILDON_CAPTION_OPTIONAL);
gtk_widget_show (self->entry_outgoing_port);
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
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;
}
}
-
- /* Check that the email address is valud: */
+
+ /* Check that the email address is valid: */
const gchar* email_address = gtk_entry_get_text (GTK_ENTRY (self->entry_user_email));
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;
}
+
+ /* make sure the domain name for the incoming server is valid */
+ const gchar* hostname = gtk_entry_get_text (GTK_ENTRY (self->entry_incomingserver));
+ if ((!hostname) || (strlen(hostname) == 0))
+ return FALSE;
+ if (!modest_text_utils_validate_domain_name (hostname)) {
+ /* Warn the user via a dialog: */
+ /*show_error (GTK_WINDOW (self), _("mcen_ib_invalid_email"));*/
+ hildon_banner_show_information (NULL, NULL, _("mcen_ib_invalid_servername"));
+
+ /* Return focus to the email address entry: */
+ gtk_widget_grab_focus (self->entry_incomingserver);
+ gtk_editable_select_region (GTK_EDITABLE (self->entry_incomingserver), 0, -1);
+ return FALSE;
+ }
+
+ /* make sure the domain name for the outgoing server is valid */
+ const gchar* hostname2 = gtk_entry_get_text (GTK_ENTRY (self->entry_outgoingserver));
+ if ((!hostname2) || (strlen(hostname2) == 0))
+ return FALSE;
+ if (!modest_text_utils_validate_domain_name (hostname2)) {
+ /* Warn the user via a dialog: */
+ /*show_error (GTK_WINDOW (self), _("mcen_ib_invalid_email"));*/
+ hildon_banner_show_information (NULL, NULL, _("mcen_ib_invalid_servername"));
+
+ /* Return focus to the email address entry: */
+ gtk_widget_grab_focus (self->entry_outgoingserver);
+ gtk_editable_select_region (GTK_EDITABLE (self->entry_outgoingserver), 0, -1);
+ return FALSE;
+ }
+
+
+ /* Find a suitable authentication method when secure authentication is desired */
+
+ 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.
- */
-
return TRUE;
}
/*
enable_buttons (self);
gboolean prevent_response = FALSE;
-
+
/* Warn about unsaved changes: */
if (response_id == GTK_RESPONSE_CANCEL && self->modified) {
GtkDialog *dialog = GTK_DIALOG (hildon_note_new_confirmation (GTK_WINDOW (self),
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;
}
{
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_ok (GTK_WINDOW (self), _("mcen_ib_advsetup_settings_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_WINDOW (self), _("mail_ib_setting_failed"));
+ show_error (GTK_WIDGET (self), _("mail_ib_setting_failed"));
}
}
}
{
/* 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());
/* Get the account manager object,
* so we can check for existing accounts,
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);
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);
} else {
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;
* 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 ModestAuthProtocol 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);
- /* Note that MODEST_PROTOCOL_AUTH_PLAIN should probably never be used. */
-
- update_incoming_server_title (dialog, incoming_account->proto);
- update_incoming_server_security_choices (dialog, incoming_account->proto);
-
+ */
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 */);
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)
{
* 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.
*/
- ModestAuthProtocol protocol_authentication_incoming =
- MODEST_PROTOCOL_AUTH_PASSWORD;
- if (gtk_toggle_button_get_active (
- GTK_TOGGLE_BUTTON (dialog->checkbox_incoming_auth))) {
- GList *list_auth_methods =
- modest_maemo_utils_get_supported_secure_authentication_methods (dialog->incoming_protocol,
- hostname, port_num, GTK_WINDOW (dialog));
- if (list_auth_methods) {
- /* Use the first supported method.
- * TODO: Should we prioritize them, to prefer a particular one? */
- protocol_authentication_incoming =
- (ModestAuthProtocol)(GPOINTER_TO_INT(list_auth_methods->data));
- g_list_free (list_auth_methods);
- }
- else
- {
- GtkWidget* error_dialog = gtk_message_dialog_new(GTK_WINDOW(dialog),
- GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
- GTK_BUTTONS_OK, _("Server does not support secure authentication!"));
- gtk_dialog_run(GTK_DIALOG(error_dialog));
- gtk_widget_destroy(error_dialog);
- /* This is a nasty hack. jschmid. */
- /* Don't let the dialog close */
- g_signal_stop_emission_by_name (dialog, "response");
- return FALSE;
- }
-
- }
-
- modest_server_account_set_secure_auth (dialog->account_manager, incoming_account_name, protocol_authentication_incoming);
-
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);
}
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);
+#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_ERROR,
+ GTK_BUTTONS_OK,
+ text ));
+ */
+
gtk_dialog_run (dialog);
gtk_widget_destroy (GTK_WIDGET (dialog));
+#endif
}
-
-static void
-show_ok (GtkWindow *parent_window, const gchar* text)
-{
- /* Don't show a dialog but Banner (NB #59248) */
- hildon_banner_show_information(GTK_WIDGET(
- gtk_widget_get_parent_window(GTK_WIDGET(parent_window))), NULL, text);
-}
-
-
-
-