2 /* Copyright (c) 2006, Nokia Corporation
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
9 * * Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * * Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * * Neither the name of the Nokia Corporation nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
19 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
20 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
21 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
22 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
27 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 #include "modest-easysetup-wizard-dialog.h"
33 #include <glib/gi18n.h>
34 #include <gtk/gtknotebook.h>
35 #include <gtk/gtkvbox.h>
36 #include <gtk/gtklabel.h>
37 #include <gtk/gtkentry.h>
38 #include <gtk/gtkbutton.h>
39 #include <gtk/gtkcheckbutton.h>
40 #include <gtk/gtkmessagedialog.h>
41 #include <gtk/gtkseparator.h>
42 #include "modest-country-picker.h"
43 #include "modest-provider-picker.h"
44 #include "modest-servertype-picker.h"
45 #include "widgets/modest-validating-entry.h"
46 #include "modest-text-utils.h"
47 #include "modest-conf.h"
48 #include "modest-defs.h"
49 #include "modest-account-mgr.h"
50 #include "modest-signal-mgr.h"
51 #include "modest-account-mgr-helpers.h"
52 #include "modest-runtime.h" /* For modest_runtime_get_account_mgr(). */
53 #include "modest-connection-specific-smtp-window.h"
54 #include "widgets/modest-ui-constants.h"
55 #include "widgets/modest-default-account-settings-dialog.h"
56 #include "widgets/modest-easysetup-wizard-page.h"
57 #include "modest-maemo-utils.h"
58 #include "modest-utils.h"
59 #include "modest-hildon-includes.h"
60 #include "modest-maemo-security-options-view.h"
61 #include "modest-account-protocol.h"
62 #include "modest-address-book.h"
64 /* Include config.h so that _() works: */
69 G_DEFINE_TYPE (ModestEasysetupWizardDialog, modest_easysetup_wizard_dialog, MODEST_TYPE_WIZARD_DIALOG);
71 #define MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
72 MODEST_TYPE_EASYSETUP_WIZARD_DIALOG, \
73 ModestEasysetupWizardDialogPrivate))
75 #define LABELS_WIDTH 520
76 #define DIALOG_WIDTH LABELS_WIDTH + MODEST_MARGIN_DOUBLE
78 typedef struct _ModestEasysetupWizardDialogPrivate ModestEasysetupWizardDialogPrivate;
82 MODEST_EASYSETUP_WIZARD_DIALOG_INCOMING_CHANGED = 0x01,
83 MODEST_EASYSETUP_WIZARD_DIALOG_OUTGOING_CHANGED = 0x02
84 } ModestEasysetupWizardDialogServerChanges;
86 struct _ModestEasysetupWizardDialogPrivate
88 ModestPresets *presets;
90 /* Remember what fields the user edited manually to not prefill them
92 ModestEasysetupWizardDialogServerChanges server_changes;
94 /* Check if the user changes a field to show a confirmation dialog */
97 /* If we have a pending load of settings or not. */
98 gboolean pending_load_settings;
100 /* Used by derived widgets to query existing accounts,
101 * and to create new accounts: */
102 ModestAccountMgr *account_manager;
103 ModestAccountSettings *settings;
105 /* notebook pages: */
106 GtkWidget *page_welcome;
107 gboolean check_support_done;
108 guint check_support_show_progress_id;
109 guint check_support_progress_pulse_id;
110 GtkWidget *check_support_cancel_note;
111 GtkWidget *check_support_progress;
112 gint pending_check_support;
115 GtkWidget *page_account_details;
116 GtkWidget *account_country_picker;
117 GtkWidget *account_serviceprovider_picker;
118 GtkWidget *entry_account_title;
119 GtkWidget *caption_account_title;
121 GtkWidget *page_user_details;
122 GtkWidget *entry_user_name;
123 GtkWidget *entry_user_username;
124 GtkWidget *entry_user_password;
125 GtkWidget *entry_user_email;
127 GtkWidget *page_complete_easysetup;
129 GtkWidget *page_custom_incoming;
130 GtkWidget *incoming_servertype_picker;
131 GtkWidget *caption_incoming;
132 GtkWidget *entry_incomingserver;
134 /* Security widgets */
135 GtkWidget *incoming_security;
136 GtkWidget *outgoing_security;
138 GtkWidget *page_custom_outgoing;
139 GtkWidget *entry_outgoingserver;
140 GtkWidget *checkbox_outgoing_smtp_specific;
141 GtkWidget *button_outgoing_smtp_servers;
143 GtkWidget *page_complete_customsetup;
146 ModestProtocolType last_plugin_protocol_selected;
147 GSList *missing_data_signals;
150 static void save_to_settings (ModestEasysetupWizardDialog *self);
151 static void real_enable_buttons (ModestWizardDialog *dialog, gboolean enable_next);
152 static void on_update_model (ModestWizardDialog *dialog);
153 static gboolean on_save (ModestWizardDialog *dialog);
154 static GList* check_for_supported_auth_methods (ModestEasysetupWizardDialog* self);
155 static gboolean check_has_supported_auth_methods(ModestEasysetupWizardDialog* self);
156 static void check_support_callback (ModestAccountProtocol *protocol,
159 static void check_support_of_protocols (ModestEasysetupWizardDialog *self);
160 static gboolean check_support_show_progress (gpointer userdata);
161 static gboolean check_support_progress_pulse (gpointer userdata);
164 on_delete_event (GtkWidget *widget,
166 ModestEasysetupWizardDialog *wizard)
168 gtk_dialog_response (GTK_DIALOG (wizard), GTK_RESPONSE_CANCEL);
173 on_easysetup_changed(GtkWidget* widget, ModestEasysetupWizardDialog* wizard)
175 ModestEasysetupWizardDialogPrivate* priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(wizard);
176 g_return_if_fail (priv != NULL);
181 modest_easysetup_wizard_dialog_dispose (GObject *object)
183 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (object);
184 priv->destroyed = TRUE;
186 if (priv->check_support_show_progress_id > 0) {
187 g_source_remove (priv->check_support_show_progress_id);
188 priv->check_support_show_progress_id = 0;
191 if (priv->check_support_progress_pulse_id > 0) {
192 g_source_remove (priv->check_support_progress_pulse_id);
193 priv->check_support_progress_pulse_id = 0;
196 if (G_OBJECT_CLASS (modest_easysetup_wizard_dialog_parent_class)->dispose)
197 G_OBJECT_CLASS (modest_easysetup_wizard_dialog_parent_class)->dispose (object);
201 modest_easysetup_wizard_dialog_finalize (GObject *object)
203 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (object);
204 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
205 ModestProtocolRegistry *registry;
206 GSList *provider_protos, *node;
208 registry = modest_runtime_get_protocol_registry ();
209 provider_protos = modest_protocol_registry_get_by_tag (registry,
210 MODEST_PROTOCOL_REGISTRY_PROVIDER_PROTOCOLS);
212 for (node = provider_protos; node != NULL; node = g_slist_next (node)) {
213 ModestProtocol *proto = MODEST_PROTOCOL (node->data);
215 if (!modest_protocol_registry_protocol_type_has_tag (registry,
216 modest_protocol_get_type_id (proto),
217 MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS))
220 if (MODEST_ACCOUNT_PROTOCOL (proto)) {
221 modest_account_protocol_wizard_finished (MODEST_ACCOUNT_PROTOCOL (proto));
224 g_slist_free (provider_protos);
226 if (priv->account_manager)
227 g_object_unref (G_OBJECT (priv->account_manager));
230 modest_presets_destroy (priv->presets);
233 g_object_unref (priv->settings);
235 if (priv->missing_data_signals) {
236 modest_signal_mgr_disconnect_all_and_destroy (priv->missing_data_signals);
237 priv->missing_data_signals = NULL;
240 G_OBJECT_CLASS (modest_easysetup_wizard_dialog_parent_class)->finalize (object);
244 create_subsequent_easysetup_pages (ModestEasysetupWizardDialog *self);
247 set_default_custom_servernames(ModestEasysetupWizardDialog *dialog);
249 static void on_servertype_selector_changed(HildonTouchSelector *selector, gint column, gpointer user_data);
252 get_port_from_protocol (ModestProtocolType server_type,
253 gboolean alternate_port)
256 ModestProtocol *protocol;
257 ModestProtocolRegistry *protocol_registry;
259 protocol_registry = modest_runtime_get_protocol_registry ();
260 protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, server_type);
262 if (alternate_port) {
263 server_port = modest_account_protocol_get_alternate_port (MODEST_ACCOUNT_PROTOCOL (protocol));
265 server_port = modest_account_protocol_get_port (MODEST_ACCOUNT_PROTOCOL (protocol));
271 invoke_enable_buttons_vfunc (ModestEasysetupWizardDialog *wizard_dialog)
273 ModestWizardDialogClass *klass = MODEST_WIZARD_DIALOG_GET_CLASS (wizard_dialog);
275 /* Call the vfunc, which may be overridden by derived classes: */
276 if (klass->enable_buttons) {
277 GtkNotebook *notebook = NULL;
278 g_object_get (wizard_dialog, "wizard-notebook", ¬ebook, NULL);
280 const gint current_page_num = gtk_notebook_get_current_page (notebook);
281 if (current_page_num == -1)
284 GtkWidget* current_page_widget = gtk_notebook_get_nth_page (notebook, current_page_num);
285 (*(klass->enable_buttons))(MODEST_WIZARD_DIALOG (wizard_dialog), current_page_widget);
290 on_caption_entry_changed (GtkEditable *editable, gpointer user_data)
292 ModestEasysetupWizardDialog *self;
294 g_return_if_fail (user_data);
296 self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data);
298 invoke_enable_buttons_vfunc(self);
302 on_caption_combobox_changed (GtkComboBox *widget, gpointer user_data)
304 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data);
306 invoke_enable_buttons_vfunc(self);
310 on_picker_button_value_changed (HildonPickerButton *widget, gpointer user_data)
312 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data);
314 invoke_enable_buttons_vfunc(self);
318 on_serviceprovider_picker_button_value_changed (HildonPickerButton *widget, gpointer user_data)
320 gchar* default_account_name_start;
321 gchar* default_account_name;
322 ModestEasysetupWizardDialog *self;
323 ModestEasysetupWizardDialogPrivate *priv;
324 ModestProviderPickerIdType provider_id_type;
325 ModestProtocol *protocol;
327 ModestProtocolType proto_type;
328 gboolean hide_account_title;
330 self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data);
331 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
333 on_picker_button_value_changed (widget, user_data);
335 provider_id_type = modest_provider_picker_get_active_id_type (
336 MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker));
337 if (provider_id_type == MODEST_PROVIDER_PICKER_ID_OTHER) {
338 default_account_name_start = g_strdup (_("mcen_ia_emailsetup_defaultname"));
342 selector = GTK_WIDGET (hildon_picker_button_get_selector (HILDON_PICKER_BUTTON (widget)));
343 default_account_name_start =
344 g_strdup (hildon_touch_selector_get_current_text (HILDON_TOUCH_SELECTOR (selector)));
347 default_account_name = modest_account_mgr_get_unused_account_display_name (
348 priv->account_manager, default_account_name_start);
349 g_free (default_account_name_start);
350 default_account_name_start = NULL;
352 hide_account_title = FALSE;
353 proto_name = modest_provider_picker_get_active_provider_id (MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker));
354 if (proto_name != NULL) {
355 protocol = modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (),
356 MODEST_PROTOCOL_REGISTRY_PROVIDER_PROTOCOLS,
358 if (protocol != NULL) {
359 proto_type = modest_protocol_get_type_id (protocol);
361 hide_account_title = (modest_protocol_registry_protocol_type_has_tag
362 (modest_runtime_get_protocol_registry (),
364 MODEST_PROTOCOL_REGISTRY_SINGLETON_PROVIDER_PROTOCOLS) ||
365 modest_protocol_registry_protocol_type_has_tag
366 (modest_runtime_get_protocol_registry (),
368 MODEST_PROTOCOL_REGISTRY_MULTI_MAILBOX_PROVIDER_PROTOCOLS));
372 if (hide_account_title)
373 gtk_widget_hide (priv->caption_account_title);
375 gtk_widget_show (priv->caption_account_title);
377 hildon_entry_set_text (HILDON_ENTRY (priv->entry_account_title), default_account_name);
378 g_free (default_account_name);
381 /** This is a convenience function to create a caption containing a mandatory widget.
382 * When the widget is edited, the enable_buttons() vfunc will be called.
385 create_captioned (ModestEasysetupWizardDialog *self,
386 GtkSizeGroup *title_size_group,
387 GtkSizeGroup *value_size_group,
394 result = modest_maemo_utils_create_captioned_with_size_type (title_size_group, value_size_group,
395 value, use_markup, control,
396 MODEST_EDITABLE_SIZE);
398 /* Connect to the appropriate changed signal for the widget,
399 * so we can ask for the prev/next buttons to be enabled/disabled appropriately:
401 if (GTK_IS_ENTRY (control)) {
402 g_signal_connect (G_OBJECT (control), "changed",
403 G_CALLBACK (on_caption_entry_changed), self);
406 else if (GTK_IS_COMBO_BOX (control)) {
407 g_signal_connect (G_OBJECT (control), "changed",
408 G_CALLBACK (on_caption_combobox_changed), self);
415 create_page_welcome (ModestEasysetupWizardDialog *self)
420 GtkWidget *privacy_note;
422 ModestEasysetupWizardDialogPrivate *priv;
424 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
425 box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE);
426 pannable = hildon_pannable_area_new ();
427 label = gtk_label_new(_("mcen_ia_emailsetup_intro"));
428 privacy_note = gtk_label_new (_("mcen_ia_privacy_notice"));
429 align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
430 gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, MODEST_MARGIN_DOUBLE, 0);
431 gtk_widget_set_size_request (label, LABELS_WIDTH, -1);
432 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
433 gtk_widget_set_size_request (privacy_note, LABELS_WIDTH, -1);
434 gtk_label_set_line_wrap (GTK_LABEL (privacy_note), TRUE);
435 hildon_helper_set_logical_font (privacy_note, "SmallSystemFont");
436 /* So that it is not truncated: */
437 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
438 gtk_misc_set_padding (GTK_MISC (label), MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE);
439 gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
440 gtk_box_pack_start (GTK_BOX (box), privacy_note, FALSE, FALSE, 0);
441 gtk_container_add (GTK_CONTAINER (align), box);
442 gtk_widget_show (label);
443 gtk_widget_show (privacy_note);
445 hildon_pannable_area_add_with_viewport (HILDON_PANNABLE_AREA (pannable), align);
446 gtk_widget_show (GTK_WIDGET (box));
447 gtk_widget_show (GTK_WIDGET (align));
448 gtk_widget_show (pannable);
450 return GTK_WIDGET (pannable);
454 on_account_country_selector_changed (HildonTouchSelector *widget, gpointer user_data)
456 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data);
458 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
460 /* Fill the providers picker, based on the selected country: */
461 if (priv->presets != NULL) {
462 gint mcc = modest_country_picker_get_active_country_mcc (
463 MODEST_COUNTRY_PICKER (priv->account_country_picker));
464 if (priv->last_mcc != mcc) {
465 modest_provider_picker_fill (
466 MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker), priv->presets, mcc);
468 modest_provider_picker_refresh (MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker));
470 priv->last_mcc = mcc;
475 update_user_email_from_provider (ModestEasysetupWizardDialog *self)
477 ModestEasysetupWizardDialogPrivate *priv;
478 gchar* provider_id = NULL, *with_at = NULL;
481 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
483 /* Fill the providers combo, based on the selected country: */
484 provider_id = modest_provider_picker_get_active_provider_id (
485 MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker));
488 gchar *domain_name = modest_presets_get_domain (priv->presets, provider_id);
489 with_at = g_strdup_printf ("%c%s", '@', domain_name);
490 g_free (domain_name);
493 /* The sample address already contains the '@' */
495 with_at = g_strdup (MODEST_EXAMPLE_EMAIL_ADDRESS);
497 if (priv->entry_user_email)
498 hildon_entry_set_text (HILDON_ENTRY (priv->entry_user_email), with_at);
501 g_free (provider_id);
505 on_account_serviceprovider_selector_changed (HildonTouchSelector *widget, gint column, gpointer user_data)
507 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data);
510 update_user_email_from_provider (self);
514 on_entry_max (ModestValidatingEntry *self, gpointer user_data)
516 modest_platform_information_banner (GTK_WIDGET (self), NULL,
517 _CS("ckdg_ib_maximum_characters_reached"));
521 create_page_account_details (ModestEasysetupWizardDialog *self)
524 GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE);
525 GtkWidget *label = gtk_label_new(_("mcen_ia_accountdetails"));
526 ModestEasysetupWizardDialogPrivate* priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self);
529 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
530 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
531 gtk_misc_set_padding (GTK_MISC (label), MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE);
532 gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
533 gtk_widget_show (label);
535 /* Create a size group to be used by all captions.
536 * Note that HildonCaption does not create a default size group if we do not specify one.
537 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
538 GtkSizeGroup* title_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
539 GtkSizeGroup* value_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
541 /* The country widgets: */
542 priv->account_country_picker = GTK_WIDGET (modest_country_picker_new (MODEST_EDITABLE_SIZE,
543 HILDON_BUTTON_ARRANGEMENT_HORIZONTAL));
544 modest_maemo_utils_set_hbutton_layout (title_sizegroup, value_sizegroup,
545 _("mcen_fi_country"), priv->account_country_picker);
546 g_signal_connect (G_OBJECT (priv->account_country_picker), "value-changed",
547 G_CALLBACK (on_picker_button_value_changed), self);
548 gtk_box_pack_start (GTK_BOX (box), priv->account_country_picker, FALSE, FALSE, MODEST_MARGIN_HALF);
549 gtk_widget_show (priv->account_country_picker);
551 /* The service provider widgets: */
552 priv->account_serviceprovider_picker = GTK_WIDGET (modest_provider_picker_new (MODEST_EDITABLE_SIZE,
553 HILDON_BUTTON_ARRANGEMENT_HORIZONTAL));
554 modest_maemo_utils_set_hbutton_layout (title_sizegroup, value_sizegroup,
555 _("mcen_fi_serviceprovider"),
556 priv->account_serviceprovider_picker);
557 g_signal_connect (G_OBJECT (priv->account_serviceprovider_picker), "value-changed",
558 G_CALLBACK (on_serviceprovider_picker_button_value_changed), self);
559 gtk_box_pack_start (GTK_BOX (box), priv->account_serviceprovider_picker, FALSE, FALSE, 0);
560 gtk_widget_show (priv->account_serviceprovider_picker);
562 /* The description widgets: */
563 priv->entry_account_title = GTK_WIDGET (modest_validating_entry_new ());
565 /* Do use auto-capitalization: */
566 hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_account_title),
567 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_AUTOCAP);
569 /* Set a default account title, choosing one that does not already exist: */
570 /* Note that this is irrelevant to the non-user visible name, which we will create later. */
571 gchar* default_account_name_start = g_strdup (_("mcen_ia_emailsetup_defaultname"));
572 gchar* default_account_name = modest_account_mgr_get_unused_account_display_name (
573 priv->account_manager, default_account_name_start);
574 g_free (default_account_name_start);
575 default_account_name_start = NULL;
577 hildon_entry_set_text (HILDON_ENTRY (priv->entry_account_title), default_account_name);
578 g_free (default_account_name);
579 default_account_name = NULL;
581 /* Connect signal after changing the text in the entry */
582 g_signal_connect(G_OBJECT(priv->entry_account_title), "changed",
583 G_CALLBACK(on_easysetup_changed), self);
585 tmp_str = g_strconcat (_("mcen_fi_account_title"), "*", NULL);
586 priv->caption_account_title = create_captioned (self, title_sizegroup, value_sizegroup,
588 priv->entry_account_title);
590 gtk_widget_show (priv->entry_account_title);
591 gtk_box_pack_start (GTK_BOX (box), priv->caption_account_title, FALSE, FALSE, 0);
592 gtk_widget_show (priv->caption_account_title);
593 gtk_widget_set_no_show_all (priv->caption_account_title, TRUE);
595 /* Prevent the use of some characters in the account title,
596 * as required by our UI specification: */
597 GList *list_prevent = NULL;
598 list_prevent = g_list_append (list_prevent, "\\");
599 list_prevent = g_list_append (list_prevent, "/");
600 list_prevent = g_list_append (list_prevent, ":");
601 list_prevent = g_list_append (list_prevent, "*");
602 list_prevent = g_list_append (list_prevent, "?");
603 list_prevent = g_list_append (list_prevent, "\""); /* The UI spec mentions “, but maybe means ", maybe both. */
604 list_prevent = g_list_append (list_prevent, "“");
605 list_prevent = g_list_append (list_prevent, "<");
606 list_prevent = g_list_append (list_prevent, ">");
607 list_prevent = g_list_append (list_prevent, "|");
608 list_prevent = g_list_append (list_prevent, "^");
609 modest_validating_entry_set_unallowed_characters (
610 MODEST_VALIDATING_ENTRY (priv->entry_account_title), list_prevent);
611 g_list_free (list_prevent);
613 modest_validating_entry_set_func(MODEST_VALIDATING_ENTRY(priv->entry_account_title),
614 modest_utils_on_entry_invalid_character, self);
616 /* Set max length as in the UI spec:
617 * The UI spec seems to want us to show a dialog if we hit the maximum. */
618 gtk_entry_set_max_length (GTK_ENTRY (priv->entry_account_title), 64);
619 modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (priv->entry_account_title),
622 gtk_widget_show (GTK_WIDGET (box));
624 g_object_unref (title_sizegroup);
625 g_object_unref (value_sizegroup);
627 align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
628 gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE, 0);
629 gtk_widget_show (align);
630 gtk_container_add (GTK_CONTAINER (align), box);
632 return GTK_WIDGET (align);
636 on_user_username_changed(GtkWidget* widget, ModestEasysetupWizardDialog *self)
638 ModestEasysetupWizardDialogPrivate* priv;
639 gchar* provider_id = NULL;
641 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
643 /* Work out the user email address */
644 provider_id = modest_provider_picker_get_active_provider_id (
645 MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker));
648 const gchar *current_username;
649 gchar *email_address;
650 gchar *domain_name = modest_presets_get_domain (priv->presets, provider_id);
652 current_username = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_username));
654 if (current_username && strstr (current_username, "@")) {
655 email_address = g_strdup (current_username);
657 email_address = g_strdup_printf ("%s@%s",
662 /* Update the email address */
663 hildon_entry_set_text (HILDON_ENTRY (priv->entry_user_email), email_address);
665 g_free (email_address);
666 g_free (domain_name);
667 g_free (provider_id);
671 on_easysetup_changed(widget, self);
676 create_page_user_details (ModestEasysetupWizardDialog *self)
678 GtkSizeGroup* title_sizegroup;
679 GtkSizeGroup* value_sizegroup;
681 ModestEasysetupWizardDialogPrivate *priv;
683 const gchar *my_name;
686 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self);
688 /* Create a size group to be used by all captions.
689 * Note that HildonCaption does not create a default size group if we do not specify one.
690 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
691 box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE);
692 title_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
693 value_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
695 /* The name widgets: (use auto cap) */
696 priv->entry_user_name = GTK_WIDGET (modest_validating_entry_new ());
697 hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_user_name),
698 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_AUTOCAP);
700 /* Set max length as in the UI spec:
701 * The UI spec seems to want us to show a dialog if we hit the maximum. */
702 gtk_entry_set_max_length (GTK_ENTRY (priv->entry_user_name), 64);
703 modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (priv->entry_user_name),
705 GtkWidget *caption = create_captioned (self, title_sizegroup, value_sizegroup,
706 _("mcen_li_emailsetup_name"), FALSE, priv->entry_user_name);
708 /* Try to initialize the user name with my own contact */
709 my_name = modest_address_book_get_my_name ();
711 gtk_entry_set_text (GTK_ENTRY (priv->entry_user_name), my_name);
713 g_signal_connect(G_OBJECT(priv->entry_user_name), "changed",
714 G_CALLBACK(on_easysetup_changed), self);
715 gtk_widget_show (priv->entry_user_name);
716 gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, 0);
717 gtk_widget_show (caption);
719 /* Prevent the use of some characters in the name,
720 * as required by our UI specification: */
721 GList *list_prevent = NULL;
722 list_prevent = g_list_append (list_prevent, "<");
723 list_prevent = g_list_append (list_prevent, ">");
724 modest_validating_entry_set_unallowed_characters (
725 MODEST_VALIDATING_ENTRY (priv->entry_user_name), list_prevent);
726 modest_validating_entry_set_func(MODEST_VALIDATING_ENTRY(priv->entry_user_name),
727 modest_utils_on_entry_invalid_character, self);
728 g_list_free (list_prevent);
730 /* The username widgets: */
731 priv->entry_user_username = GTK_WIDGET (modest_validating_entry_new ());
732 /* Auto-capitalization is the default, so let's turn it off: */
733 hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_user_username),
734 HILDON_GTK_INPUT_MODE_FULL);
735 tmp_str = g_strconcat (_("mail_fi_username"), "*", NULL);
736 caption = create_captioned (self, title_sizegroup, value_sizegroup,
738 priv->entry_user_username);
740 gtk_widget_show (priv->entry_user_username);
741 gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, 0);
742 g_signal_connect(G_OBJECT(priv->entry_user_username), "changed",
743 G_CALLBACK(on_user_username_changed), self);
744 gtk_widget_show (caption);
746 /* Prevent the use of some characters in the username,
747 * as required by our UI specification: */
748 modest_validating_entry_set_func(MODEST_VALIDATING_ENTRY(priv->entry_user_username),
749 modest_utils_on_entry_invalid_character, self);
751 /* Set max length as in the UI spec:
752 * The UI spec seems to want us to show a dialog if we hit the maximum. */
753 gtk_entry_set_max_length (GTK_ENTRY (priv->entry_user_username), 64);
754 modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (priv->entry_user_username),
757 /* The password widgets: */
758 priv->entry_user_password = hildon_entry_new (MODEST_EDITABLE_SIZE);
759 /* Auto-capitalization is the default, so let's turn it off: */
760 hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_user_password),
761 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
762 gtk_entry_set_visibility (GTK_ENTRY (priv->entry_user_password), FALSE);
763 /* gtk_entry_set_invisible_char (GTK_ENTRY (priv->entry_user_password), '*'); */
764 caption = create_captioned (self, title_sizegroup, value_sizegroup,
765 _("mail_fi_password"), FALSE, priv->entry_user_password);
766 g_signal_connect(G_OBJECT(priv->entry_user_password), "changed",
767 G_CALLBACK(on_easysetup_changed), self);
768 gtk_widget_show (priv->entry_user_password);
769 gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, 0);
770 gtk_widget_show (caption);
772 /* The email address widgets: */
773 priv->entry_user_email = GTK_WIDGET (modest_validating_entry_new ());
774 /* Auto-capitalization is the default, so let's turn it off: */
775 hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_user_email), HILDON_GTK_INPUT_MODE_FULL);
776 tmp_str = g_strconcat (_("mcen_li_emailsetup_email_address"), "*", NULL);
777 caption = create_captioned (self, title_sizegroup, value_sizegroup,
778 tmp_str, FALSE, priv->entry_user_email);
780 update_user_email_from_provider (self);
781 gtk_widget_show (priv->entry_user_email);
782 gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, 0);
783 g_signal_connect(G_OBJECT(priv->entry_user_email), "changed",
784 G_CALLBACK(on_easysetup_changed), self);
785 gtk_widget_show (caption);
787 /* Set max length as in the UI spec:
788 * The UI spec seems to want us to show a dialog if we hit the maximum. */
789 gtk_entry_set_max_length (GTK_ENTRY (priv->entry_user_email), 64);
790 modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (priv->entry_user_email),
794 gtk_widget_show (GTK_WIDGET (box));
795 g_object_unref (title_sizegroup);
796 g_object_unref (value_sizegroup);
798 align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
799 gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE, 0);
800 gtk_widget_show (align);
801 gtk_container_add (GTK_CONTAINER (align), box);
803 return GTK_WIDGET (align);
807 create_page_complete_easysetup (ModestEasysetupWizardDialog *self)
810 GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE);
812 GtkWidget *label = gtk_label_new(_("mcen_ia_emailsetup_setup_complete"));
813 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
814 gtk_widget_set_size_request (label, LABELS_WIDTH, -1);
815 gtk_misc_set_padding (GTK_MISC (label), MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE);
816 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
818 gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
819 gtk_widget_show (label);
821 label = gtk_label_new (_("mcen_ia_easysetup_complete"));
822 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
823 gtk_widget_set_size_request (label, LABELS_WIDTH, -1);
825 gtk_misc_set_padding (GTK_MISC (label), MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE);
826 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 1.0);
827 gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
828 gtk_widget_show (label);
830 gtk_widget_show (GTK_WIDGET (box));
832 align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
833 gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE, 0);
834 gtk_widget_show (align);
835 gtk_container_add (GTK_CONTAINER (align), box);
837 return GTK_WIDGET (align);
840 /** Change the caption title for the incoming server,
841 * as specified in the UI spec:
844 update_incoming_server_title (ModestEasysetupWizardDialog *self)
846 ModestEasysetupWizardDialogPrivate* priv;
847 ModestProtocolType protocol_type;
848 ModestProtocolRegistry *protocol_registry;
850 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self);
851 protocol_registry = modest_runtime_get_protocol_registry ();
853 protocol_type = modest_servertype_picker_get_active_servertype (
854 MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker));
856 /* This could happen when the combo box has still no active iter */
857 if (protocol_type != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
858 gchar* incomingserver_title;
859 const gchar *protocol_display_name;
860 ModestProtocol *protocol;
862 protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry,
864 protocol_display_name = modest_protocol_get_display_name (protocol);
866 incomingserver_title = g_strconcat (_("mcen_li_emailsetup_servertype"), "*\n<small>(",
867 protocol_display_name, ")</small>", NULL);
869 modest_maemo_utils_captioned_set_label (priv->caption_incoming, incomingserver_title, TRUE);
871 g_free(incomingserver_title);
875 /** Change the caption title for the incoming server,
876 * as specified in the UI spec:
879 update_incoming_server_security_choices (ModestEasysetupWizardDialog *self)
881 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self);
882 ModestServertypePicker *server_type_picker;
883 ModestProtocolType protocol_type;
884 ModestSecurityOptionsView *view;
887 MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker);
889 modest_servertype_picker_get_active_servertype (server_type_picker);
891 /* Fill the combo with appropriately titled choices for all
893 view = MODEST_SECURITY_OPTIONS_VIEW (priv->incoming_security);
894 modest_security_options_view_set_server_type (view, protocol_type);
898 on_servertype_selector_changed(HildonTouchSelector *selector, gint column, gpointer user_data)
900 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data);
901 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self);
906 update_incoming_server_title (self);
908 /* Update security options if needed */
909 update_incoming_server_security_choices (self);
910 gtk_widget_show (priv->incoming_security);
912 set_default_custom_servernames (self);
916 on_entry_incoming_servername_changed(GtkEntry *entry, gpointer user_data)
918 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data);
919 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
921 priv->server_changes |= MODEST_EASYSETUP_WIZARD_DIALOG_INCOMING_CHANGED;
925 create_page_custom_incoming (ModestEasysetupWizardDialog *self)
927 ModestProtocolRegistry *protocol_registry;
928 ModestEasysetupWizardDialogPrivate* priv;
933 GtkSizeGroup *title_sizegroup;
934 GtkSizeGroup *value_sizegroup;
936 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self);
937 protocol_registry = modest_runtime_get_protocol_registry ();
939 box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE);
940 pannable = hildon_pannable_area_new ();
942 /* Show note that account type cannot be changed in future: */
943 label = gtk_label_new (_("mcen_ia_emailsetup_account_type"));
944 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
945 gtk_misc_set_padding (GTK_MISC (label), MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE);
946 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
947 gtk_widget_set_size_request (label, LABELS_WIDTH, -1);
948 gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
949 gtk_widget_show (label);
951 /* Create a size group to be used by all captions.
952 * Note that HildonCaption does not create a default size group if we do not specify one.
953 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
954 title_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
955 value_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
957 /* The incoming server widgets: */
958 priv->incoming_servertype_picker = GTK_WIDGET (modest_servertype_picker_new (MODEST_EDITABLE_SIZE,
959 HILDON_BUTTON_ARRANGEMENT_HORIZONTAL,
961 modest_maemo_utils_set_hbutton_layout (title_sizegroup, value_sizegroup,
962 _("mcen_li_emailsetup_type"),
963 priv->incoming_servertype_picker);
964 g_signal_connect (G_OBJECT (priv->incoming_servertype_picker), "value-changed",
965 G_CALLBACK (on_picker_button_value_changed), self);
966 gtk_box_pack_start (GTK_BOX (box), priv->incoming_servertype_picker, FALSE, FALSE, 0);
967 gtk_widget_show (priv->incoming_servertype_picker);
969 priv->entry_incomingserver = hildon_entry_new (MODEST_EDITABLE_SIZE);
971 /* Auto-capitalization is the default, so let's turn it off: */
972 hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_incomingserver), HILDON_GTK_INPUT_MODE_FULL);
973 set_default_custom_servernames (self);
975 /* The caption title will be updated in update_incoming_server_title().
976 * so this default text will never be seen: */
977 priv->caption_incoming = create_captioned (self, title_sizegroup, value_sizegroup,
978 "This will be removed",
979 FALSE, priv->entry_incomingserver);
980 update_incoming_server_title (self);
981 gtk_widget_show (priv->entry_incomingserver);
982 gtk_box_pack_start (GTK_BOX (box), priv->caption_incoming, FALSE, FALSE, 0);
983 gtk_widget_show (priv->caption_incoming);
985 /* Remember when the servername was changed manually: */
986 g_signal_connect (G_OBJECT (priv->entry_incomingserver), "changed",
987 G_CALLBACK (on_entry_incoming_servername_changed), self);
989 /* The secure connection widgets. These are only valid for
990 protocols with security */
991 priv->incoming_security =
992 modest_maemo_security_options_view_new (MODEST_SECURITY_OPTIONS_INCOMING,
993 FALSE, title_sizegroup, value_sizegroup);
994 gtk_box_pack_start (GTK_BOX (box), priv->incoming_security,
996 gtk_widget_show (priv->incoming_security);
998 /* Set default selection */
999 modest_servertype_picker_set_active_servertype (
1000 MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker),
1001 MODEST_PROTOCOLS_STORE_POP);
1002 update_incoming_server_title (self);
1003 update_incoming_server_security_choices (self);
1004 set_default_custom_servernames (self);
1006 /* Change the caption title when the servertype changes,
1007 * as in the UI spec: */
1008 g_signal_connect (G_OBJECT (hildon_picker_button_get_selector (HILDON_PICKER_BUTTON (priv->incoming_servertype_picker))),
1010 G_CALLBACK (on_servertype_selector_changed), self);
1012 align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
1013 gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, MODEST_MARGIN_DOUBLE, 0);
1014 gtk_widget_show (align);
1015 gtk_container_add (GTK_CONTAINER (align), box);
1017 hildon_pannable_area_add_with_viewport (HILDON_PANNABLE_AREA (pannable), align);
1018 gtk_widget_show (GTK_WIDGET (box));
1019 gtk_widget_show (pannable);
1021 g_object_unref (title_sizegroup);
1022 g_object_unref (value_sizegroup);
1024 /* Connect changed signals. We do it here after initializing everything */
1025 g_signal_connect (G_OBJECT(priv->entry_incomingserver), "changed",
1026 G_CALLBACK(on_easysetup_changed), self);
1029 return GTK_WIDGET (pannable);
1033 on_check_button_changed (HildonCheckButton *button, gpointer user_data)
1035 GtkWidget *widget = GTK_WIDGET (user_data);
1037 /* Enable the widget only if the check button is active: */
1038 const gboolean enable = hildon_check_button_get_active (button);
1039 gtk_widget_set_sensitive (widget, enable);
1042 /* Make the sensitivity of a widget depend on a check button.
1045 enable_widget_for_checkbutton (GtkWidget *widget, HildonCheckButton* button)
1047 g_signal_connect (G_OBJECT (button), "toggled",
1048 G_CALLBACK (on_check_button_changed), widget);
1050 /* Set the starting sensitivity: */
1051 on_check_button_changed (button, widget);
1055 on_button_outgoing_smtp_servers (GtkButton *button, gpointer user_data)
1057 ModestEasysetupWizardDialog * self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data);
1058 ModestEasysetupWizardDialogPrivate* priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self);
1059 GtkWidget *specific_window;
1061 /* We set dirty here because setting it depending on the connection specific dialog
1065 /* Create the window, if necessary: */
1066 specific_window = (GtkWidget *) modest_connection_specific_smtp_window_new ();
1067 modest_connection_specific_smtp_window_fill_with_connections (MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window), priv->account_manager);
1069 /* Show the window */
1070 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (specific_window), GTK_WINDOW (self));
1071 gtk_widget_show (specific_window);
1075 on_entry_outgoing_servername_changed (GtkEntry *entry, gpointer user_data)
1077 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data);
1078 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
1079 priv->server_changes |= MODEST_EASYSETUP_WIZARD_DIALOG_OUTGOING_CHANGED;
1083 create_page_custom_outgoing (ModestEasysetupWizardDialog *self)
1085 ModestEasysetupWizardDialogPrivate *priv;
1086 gchar *smtp_caption_label;
1087 GtkWidget *pannable;
1089 GtkWidget *box = gtk_vbox_new (FALSE, MODEST_MARGIN_NONE);
1091 pannable = hildon_pannable_area_new ();
1093 /* Create a size group to be used by all captions.
1094 * Note that HildonCaption does not create a default size group if we do not specify one.
1095 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
1096 GtkSizeGroup *title_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1097 GtkSizeGroup *value_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1099 /* The outgoing server widgets: */
1100 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
1101 priv->entry_outgoingserver = hildon_entry_new (MODEST_EDITABLE_SIZE);
1103 /* Auto-capitalization is the default, so let's turn it off: */
1104 hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry_outgoingserver), HILDON_GTK_INPUT_MODE_FULL);
1105 smtp_caption_label = g_strconcat (_("mcen_li_emailsetup_smtp"), "*\n<small>(SMTP)</small>", NULL);
1106 GtkWidget *caption = create_captioned (self, title_sizegroup, value_sizegroup,
1107 smtp_caption_label, TRUE, priv->entry_outgoingserver);
1108 g_free (smtp_caption_label);
1109 gtk_widget_show (priv->entry_outgoingserver);
1110 gtk_box_pack_start (GTK_BOX (box), caption, FALSE, FALSE, 0);
1111 gtk_widget_show (caption);
1112 set_default_custom_servernames (self);
1114 /* The secure connection widgets. These are only valid for
1115 protocols with security */
1116 priv->outgoing_security =
1117 modest_maemo_security_options_view_new (MODEST_SECURITY_OPTIONS_OUTGOING,
1118 FALSE, title_sizegroup, value_sizegroup);
1119 gtk_box_pack_start (GTK_BOX (box), priv->outgoing_security,
1121 gtk_widget_show (priv->outgoing_security);
1123 GtkWidget *separator = gtk_hseparator_new ();
1124 gtk_box_pack_start (GTK_BOX (box), separator, FALSE, FALSE, 0);
1125 gtk_widget_show (separator);
1127 /* connection-specific checkbox: */
1128 priv->checkbox_outgoing_smtp_specific = hildon_check_button_new (HILDON_SIZE_FINGER_HEIGHT);
1129 hildon_check_button_set_active (HILDON_CHECK_BUTTON (priv->checkbox_outgoing_smtp_specific),
1131 gtk_button_set_label (GTK_BUTTON (priv->checkbox_outgoing_smtp_specific),
1132 _("mcen_fi_advsetup_connection_smtp"));
1133 gtk_button_set_alignment (GTK_BUTTON (priv->checkbox_outgoing_smtp_specific),
1136 gtk_widget_show (priv->checkbox_outgoing_smtp_specific);
1137 gtk_box_pack_start (GTK_BOX (box), priv->checkbox_outgoing_smtp_specific,
1140 /* Connection-specific SMTP-Severs Edit button: */
1141 priv->button_outgoing_smtp_servers = gtk_button_new_with_label (_("mcen_bd_advsetup_optional_smtp"));
1142 hildon_gtk_widget_set_theme_size (priv->button_outgoing_smtp_servers,
1143 HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
1144 gtk_widget_show (priv->button_outgoing_smtp_servers);
1145 gtk_box_pack_start (GTK_BOX (box), priv->button_outgoing_smtp_servers,
1148 /* Only enable the button when the checkbox is checked: */
1149 enable_widget_for_checkbutton (priv->button_outgoing_smtp_servers,
1150 HILDON_CHECK_BUTTON (priv->checkbox_outgoing_smtp_specific));
1152 g_signal_connect (G_OBJECT (priv->button_outgoing_smtp_servers), "clicked",
1153 G_CALLBACK (on_button_outgoing_smtp_servers), self);
1155 g_signal_connect (G_OBJECT (priv->entry_outgoingserver), "changed",
1156 G_CALLBACK (on_entry_outgoing_servername_changed), self);
1159 align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
1160 gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, MODEST_MARGIN_DOUBLE, 0);
1161 gtk_widget_show (align);
1162 gtk_container_add (GTK_CONTAINER (align), box);
1164 hildon_pannable_area_add_with_viewport (HILDON_PANNABLE_AREA (pannable), align);
1165 gtk_widget_show (GTK_WIDGET (box));
1166 gtk_widget_show (pannable);
1168 g_object_unref (title_sizegroup);
1169 g_object_unref (value_sizegroup);
1171 /* Connect changed signals. We do it here after initializing everything */
1172 g_signal_connect (G_OBJECT (priv->entry_outgoingserver), "changed",
1173 G_CALLBACK (on_easysetup_changed), self);
1174 g_signal_connect (G_OBJECT (priv->checkbox_outgoing_smtp_specific), "toggled",
1175 G_CALLBACK (on_easysetup_changed), self);
1177 return GTK_WIDGET (pannable);
1181 show_advanced_edit(gpointer user_data)
1183 ModestEasysetupWizardDialog * self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data);
1184 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
1187 /* Show the Account Settings window: */
1188 ModestAccountSettingsDialog *dialog = modest_default_account_settings_dialog_new ();
1189 if (priv->pending_load_settings) {
1190 save_to_settings (self);
1191 priv->pending_load_settings = FALSE;
1193 modest_account_settings_dialog_load_settings (dialog, priv->settings);
1195 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog), GTK_WINDOW (self));
1197 response = gtk_dialog_run (GTK_DIALOG (dialog));
1199 gtk_widget_destroy (GTK_WIDGET (dialog));
1201 return FALSE; /* Do not call this timeout callback again. */
1205 on_button_edit_advanced_settings (GtkButton *button, gpointer user_data)
1207 ModestEasysetupWizardDialog * self = MODEST_EASYSETUP_WIZARD_DIALOG (user_data);
1209 /* Show the Account Settings window: */
1210 show_advanced_edit(self);
1213 create_page_complete_custom (ModestEasysetupWizardDialog *self)
1215 gchar *complete_string;
1219 GtkWidget *button_edit;
1221 box = gtk_vbox_new (FALSE, MODEST_MARGIN_DEFAULT);
1222 complete_string = g_strconcat (_("mcen_ia_emailsetup_setup_complete"), " ",
1223 _("mcen_ia_customsetup_complete"), NULL);
1224 label = gtk_label_new(complete_string);
1225 g_free (complete_string);
1226 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1227 gtk_widget_set_size_request (label, LABELS_WIDTH, -1);
1228 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
1229 gtk_misc_set_padding (GTK_MISC (label), MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE);
1230 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
1231 gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
1232 gtk_widget_show (label);
1234 button_edit = gtk_button_new_with_label (_("mcen_fi_advanced_settings"));
1235 hildon_gtk_widget_set_theme_size (button_edit, HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
1236 gtk_widget_show (button_edit);
1237 gtk_box_pack_start (GTK_BOX (box), button_edit, FALSE, FALSE, 0);
1239 g_signal_connect (G_OBJECT (button_edit), "clicked",
1240 G_CALLBACK (on_button_edit_advanced_settings), self);
1242 gtk_widget_show (GTK_WIDGET (box));
1244 align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
1245 gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE, 0);
1246 gtk_widget_show (align);
1247 gtk_container_add (GTK_CONTAINER (align), box);
1249 return GTK_WIDGET (align);
1256 on_response (ModestWizardDialog *wizard_dialog,
1260 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (wizard_dialog);
1262 invoke_enable_buttons_vfunc (self);
1266 on_response_before (ModestWizardDialog *wizard_dialog,
1270 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (wizard_dialog);
1271 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(wizard_dialog);
1272 if (response_id == GTK_RESPONSE_CANCEL) {
1273 /* This is mostly copied from
1274 * src/maemo/modest-account-settings-dialog.c */
1276 gint dialog_response;
1279 dialog = hildon_note_new_confirmation ((GtkWindow *) self,
1280 _("imum_nc_wizard_confirm_lose_changes"));
1282 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1283 (GtkWindow *) dialog,
1284 (GtkWindow *) wizard_dialog);
1286 dialog_response = gtk_dialog_run ((GtkDialog *) dialog);
1287 gtk_widget_destroy (GTK_WIDGET (dialog));
1289 if (dialog_response != GTK_RESPONSE_OK) {
1290 /* Don't let the dialog close */
1291 g_signal_stop_emission_by_name (wizard_dialog, "response");
1298 fill_providers (ModestEasysetupWizardDialog *self)
1300 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
1302 if (MODEST_IS_COUNTRY_PICKER (priv->account_country_picker)) {
1303 /* gint mcc = get_default_country_code(); */
1305 /* Fill the combo in an idle call, as it takes a lot of time */
1306 modest_country_picker_load_data(
1307 MODEST_COUNTRY_PICKER (priv->account_country_picker));
1308 /* connect to country picker's changed signal, so we can fill the provider picker: */
1309 g_signal_connect ((GObject *) priv->account_country_picker,
1311 G_CALLBACK (on_account_country_selector_changed), self);
1313 modest_country_picker_set_active_country_locale (
1314 MODEST_COUNTRY_PICKER (priv->account_country_picker));
1315 mcc = modest_country_picker_get_active_country_mcc (
1316 MODEST_COUNTRY_PICKER (priv->account_country_picker));
1317 if (priv->last_mcc != mcc) {
1318 modest_provider_picker_fill (
1319 MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker),
1320 priv->presets, mcc);
1322 modest_provider_picker_refresh (
1323 MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker));
1325 priv->last_mcc = mcc;
1326 /* connect to providers picker's changed signal, so we can fill the email address: */
1327 g_signal_connect (G_OBJECT (hildon_picker_button_get_selector
1328 (HILDON_PICKER_BUTTON (priv->account_serviceprovider_picker))),
1330 G_CALLBACK (on_account_serviceprovider_selector_changed), self);
1332 modest_provider_picker_set_others_provider (MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker));
1335 priv->dirty = FALSE;
1339 typedef struct IdleData {
1340 ModestEasysetupWizardDialog *dialog;
1341 ModestPresets *presets;
1345 presets_idle (gpointer userdata)
1347 IdleData *idle_data = (IdleData *) userdata;
1348 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (idle_data->dialog);
1349 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
1351 g_assert (idle_data->presets);
1353 gdk_threads_enter ();
1355 priv->presets = idle_data->presets;
1357 if (priv->check_support_done)
1358 fill_providers (self);
1360 g_object_unref (idle_data->dialog);
1363 gdk_threads_leave ();
1369 presets_loader (gpointer userdata)
1371 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (userdata);
1372 ModestPresets *presets = NULL;
1373 IdleData *idle_data;
1375 const gchar* path = NULL;
1376 const gchar* path1 = MODEST_PROVIDER_DATA_FILE;
1377 const gchar* path2 = MODEST_FALLBACK_PROVIDER_DATA_FILE;
1379 if (access(path1, R_OK) == 0)
1381 else if (access(path2, R_OK) == 0)
1384 g_warning ("%s: neither '%s' nor '%s' is a readable provider data file",
1385 __FUNCTION__, path1, path2);
1389 presets = modest_presets_new (path);
1391 g_warning ("%s: failed to parse '%s'", __FUNCTION__, path);
1395 idle_data = g_new0 (IdleData, 1);
1396 idle_data->dialog = self;
1397 idle_data->presets = presets;
1399 g_idle_add (presets_idle, idle_data);
1405 modest_easysetup_wizard_dialog_append_page (GtkNotebook *notebook,
1411 /* Append page and set attributes */
1412 index = gtk_notebook_append_page (notebook, page, gtk_label_new (label));
1413 gtk_container_child_set (GTK_CONTAINER (notebook), page,
1414 "tab-expand", TRUE, "tab-fill", TRUE,
1417 /* Give focus to page and show it */
1418 gtk_container_set_focus_child (GTK_CONTAINER (notebook), page);
1419 gtk_widget_show (page);
1423 init_user_page (ModestEasysetupWizardDialogPrivate *priv)
1425 priv->page_user_details = NULL;
1426 priv->entry_user_name = NULL;
1427 priv->entry_user_username = NULL;
1428 priv->entry_user_password = NULL;
1429 priv->entry_user_email = NULL;
1433 init_incoming_page (ModestEasysetupWizardDialogPrivate *priv)
1435 priv->page_custom_incoming = NULL;
1436 priv->incoming_servertype_picker = NULL;
1437 priv->caption_incoming = NULL;
1438 priv->entry_incomingserver = NULL;
1439 priv->entry_user_email = NULL;
1440 priv->incoming_security = NULL;
1444 init_outgoing_page (ModestEasysetupWizardDialogPrivate *priv)
1446 priv->page_custom_outgoing = NULL;
1447 priv->entry_outgoingserver = NULL;
1448 priv->checkbox_outgoing_smtp_specific = NULL;
1449 priv->button_outgoing_smtp_servers = NULL;
1450 priv->outgoing_security = NULL;
1454 modest_easysetup_wizard_dialog_init (ModestEasysetupWizardDialog *self)
1456 gtk_container_set_border_width (GTK_CONTAINER (self), MODEST_MARGIN_HALF);
1458 /* Create the notebook to be used by the ModestWizardDialog base class:
1459 * Each page of the notebook will be a page of the wizard: */
1460 GtkNotebook *notebook = GTK_NOTEBOOK (gtk_notebook_new());
1461 gtk_widget_set_size_request (GTK_WIDGET (notebook), -1, MODEST_DIALOG_WINDOW_MAX_HEIGHT);
1463 /* Set the notebook used by the ModestWizardDialog base class: */
1464 g_object_set (G_OBJECT(self), "wizard-notebook", notebook, NULL);
1466 /* Set the wizard title:
1467 * The actual window title will be a combination of this and the page's tab label title. */
1468 g_object_set (G_OBJECT(self), "wizard-name", _("mcen_ti_emailsetup"), NULL);
1470 /* Read in the information about known service providers: */
1471 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
1473 /* The server fields did not have been manually changed yet */
1474 priv->server_changes = 0;
1475 priv->pending_load_settings = TRUE;
1477 /* Get the account manager object,
1478 * so we can check for existing accounts,
1479 * and create new accounts: */
1480 priv->account_manager = modest_runtime_get_account_mgr ();
1481 g_object_ref (priv->account_manager);
1483 /* Initialize fields */
1484 priv->check_support_done = FALSE;
1485 priv->check_support_show_progress_id = 0;
1486 priv->check_support_progress_pulse_id = 0;
1487 priv->check_support_cancel_note = NULL;
1488 priv->check_support_progress = NULL;
1489 priv->pending_check_support = 0;
1490 priv->destroyed = FALSE;
1491 priv->page_welcome = create_page_welcome (self);
1492 gtk_widget_show (priv->page_welcome);
1493 priv->page_account_details = create_page_account_details (self);
1495 init_user_page (priv);
1496 init_incoming_page (priv);
1497 init_outgoing_page (priv);
1499 priv->page_complete_easysetup = NULL;
1500 priv->page_complete_customsetup = NULL;
1501 priv->last_plugin_protocol_selected = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID;
1502 priv->last_mcc = -1;
1503 priv->missing_data_signals = NULL;
1505 /* Add the common pages */
1506 modest_easysetup_wizard_dialog_append_page (notebook, priv->page_welcome,
1507 _("mcen_ti_emailsetup_welcome"));
1508 modest_easysetup_wizard_dialog_append_page (notebook, priv->page_account_details,
1509 _("mcen_ti_accountdetails"));
1511 /* Connect to the dialog's response signal so we can enable/disable buttons
1512 * for the newly-selected page, because the prev/next buttons cause response to be emitted.
1513 * Note that we use g_signal_connect_after() instead of g_signal_connect()
1514 * so that we can be enable/disable after ModestWizardDialog has done its own
1515 * enabling/disabling of buttons.
1517 * HOWEVER, this doesn't work because ModestWizardDialog's response signal handler
1518 * does g_signal_stop_emission_by_name(), stopping our signal handler from running.
1520 * It's not enough to connect to the notebook's switch-page signal, because
1521 * ModestWizardDialog's "response" signal handler enables the buttons itself,
1522 * _after_ switching the page (understandably).
1523 * (Note that if we had, if we used g_signal_connect() instead of g_signal_connect_after()
1524 * then gtk_notebook_get_current_page() would return an incorrect value.)
1526 g_signal_connect_after (G_OBJECT (self), "response",
1527 G_CALLBACK (on_response), self);
1529 /* This is to show a confirmation dialog when the user hits cancel */
1530 g_signal_connect (G_OBJECT (self), "response",
1531 G_CALLBACK (on_response_before), self);
1533 g_signal_connect (G_OBJECT (self), "delete-event",
1534 G_CALLBACK (on_delete_event), self);
1536 /* Reset dirty, because there was no user input until now */
1537 priv->dirty = FALSE;
1539 /* When this window is shown, hibernation should not be possible,
1540 * because there is no sensible way to save the state: */
1541 modest_window_mgr_prevent_hibernation_while_window_is_shown (
1542 modest_runtime_get_window_mgr (), GTK_WINDOW (self));
1544 /* Load provider presets */
1545 g_object_ref (self);
1546 g_thread_create (presets_loader, self, FALSE, NULL);
1548 priv->settings = modest_account_settings_new ();
1552 ModestEasysetupWizardDialog*
1553 modest_easysetup_wizard_dialog_new (void)
1556 return g_object_new (MODEST_TYPE_EASYSETUP_WIZARD_DIALOG, NULL);
1560 create_subsequent_customsetup_pages (ModestEasysetupWizardDialog *self)
1562 ModestEasysetupWizardDialogPrivate *priv;
1563 GtkNotebook *notebook = NULL;
1565 g_object_get (self, "wizard-notebook", ¬ebook, NULL);
1568 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
1570 if (!priv->page_user_details) {
1571 priv->page_user_details = create_page_user_details (self);
1574 /* Create the custom pages: */
1575 if(!(priv->page_custom_incoming)) {
1576 priv->page_custom_incoming = create_page_custom_incoming (self);
1579 /* TODO: only if needed */
1580 if(!(priv->page_custom_outgoing)) {
1581 priv->page_custom_outgoing = create_page_custom_outgoing (self);
1584 if(!(priv->page_complete_customsetup)) {
1585 priv->page_complete_customsetup = create_page_complete_custom (self);
1588 if (!gtk_widget_get_parent (GTK_WIDGET (priv->page_user_details)))
1589 modest_easysetup_wizard_dialog_append_page (notebook, priv->page_user_details,
1590 _("mcen_ti_emailsetup_userdetails"));
1592 if (!gtk_widget_get_parent (GTK_WIDGET (priv->page_custom_incoming)))
1593 modest_easysetup_wizard_dialog_append_page (notebook, priv->page_custom_incoming,
1594 _("mcen_ti_emailsetup_incomingdetails"));
1596 if (!gtk_widget_get_parent (GTK_WIDGET (priv->page_custom_outgoing)))
1597 modest_easysetup_wizard_dialog_append_page (notebook, priv->page_custom_outgoing,
1598 _("mcen_ti_emailsetup_outgoingdetails"));
1600 if (!gtk_widget_get_parent (GTK_WIDGET (priv->page_complete_customsetup)))
1601 modest_easysetup_wizard_dialog_append_page (notebook, priv->page_complete_customsetup,
1602 _("mcen_ti_emailsetup_complete"));
1604 /* This is unnecessary with GTK+ 2.10: */
1605 modest_wizard_dialog_force_title_update (MODEST_WIZARD_DIALOG(self));
1609 create_subsequent_easysetup_pages (ModestEasysetupWizardDialog *self)
1611 ModestEasysetupWizardDialogPrivate *priv;
1612 GtkNotebook *notebook = NULL;
1614 g_object_get (self, "wizard-notebook", ¬ebook, NULL);
1617 /* Create the easysetup-specific pages: */
1618 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
1619 if(!priv->page_complete_easysetup)
1620 priv->page_complete_easysetup = create_page_complete_easysetup (self);
1622 if (!gtk_widget_get_parent (GTK_WIDGET (priv->page_complete_easysetup)))
1623 modest_easysetup_wizard_dialog_append_page (notebook, priv->page_complete_easysetup,
1624 _("mcen_ti_emailsetup_complete"));
1626 /* This is unnecessary with GTK+ 2.10: */
1627 modest_wizard_dialog_force_title_update (MODEST_WIZARD_DIALOG(self));
1632 remove_non_common_tabs (ModestEasysetupWizardDialog *self,
1633 gboolean remove_user_details)
1636 GtkNotebook *notebook;
1637 ModestEasysetupWizardDialogPrivate *priv;
1639 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
1640 g_object_get (self, "wizard-notebook", ¬ebook, NULL);
1642 /* The first 2 tabs are the common ones (welcome tab and the
1643 providers tab), so we always remove starting from the
1645 starting_tab = (remove_user_details) ? 2 : 3;
1646 while (gtk_notebook_get_n_pages (notebook) > starting_tab) {
1647 /* Disconnect signal */
1648 GtkWidget *page = gtk_notebook_get_nth_page (notebook, -1);
1649 if (modest_signal_mgr_is_connected (priv->missing_data_signals, (GObject *) page, "missing-mandatory-data")) {
1650 priv->missing_data_signals = modest_signal_mgr_disconnect (priv->missing_data_signals,
1652 "missing-mandatory-data");
1654 /* Remove page from notebook */
1655 gtk_notebook_remove_page (notebook, -1);
1660 on_missing_mandatory_data (ModestAccountProtocol *protocol,
1664 real_enable_buttons (MODEST_WIZARD_DIALOG (user_data), !missing);
1667 /* After the user details page,
1668 * the following pages depend on whether "Other" was chosen
1669 * in the provider combobox on the account page
1672 create_subsequent_pages (ModestEasysetupWizardDialog *self)
1674 ModestEasysetupWizardDialogPrivate *priv;
1675 ModestProviderPicker *picker;
1676 ModestProviderPickerIdType id_type;
1677 GtkNotebook *notebook;
1679 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
1680 picker = MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker);
1681 id_type = modest_provider_picker_get_active_id_type (picker);
1682 g_object_get (self, "wizard-notebook", ¬ebook, NULL);
1684 /* Remove the response override handler for non-plugin
1685 protocols. For plugins it'll be overriden later */
1686 if (id_type != MODEST_PROVIDER_PICKER_ID_PLUGIN_PROTOCOL)
1687 modest_wizard_dialog_set_response_override_handler (MODEST_WIZARD_DIALOG (self),
1691 if (id_type == MODEST_PROVIDER_PICKER_ID_OTHER) {
1692 /* "Other..." was selected: */
1694 /* If we come from a rollbacked easysetup */
1695 if (priv->page_complete_easysetup) {
1696 remove_non_common_tabs (self, FALSE);
1697 priv->page_complete_easysetup = NULL;
1700 /* If we come from a rollbacked plugin protocol setup */
1701 if (priv->last_plugin_protocol_selected != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
1702 remove_non_common_tabs (self, TRUE);
1703 priv->last_plugin_protocol_selected = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID;
1704 modest_signal_mgr_disconnect_all_and_destroy (priv->missing_data_signals);
1705 priv->missing_data_signals = NULL;
1708 create_subsequent_customsetup_pages (self);
1710 /* If we come from a rollbacked custom setup */
1711 if (priv->page_custom_incoming) {
1712 remove_non_common_tabs (self, TRUE);
1713 init_user_page (priv);
1714 init_incoming_page (priv);
1715 init_outgoing_page (priv);
1716 init_user_page (priv);
1717 priv->page_complete_customsetup = NULL;
1720 /* It's a pluggable protocol and not a provider with presets */
1721 if (id_type == MODEST_PROVIDER_PICKER_ID_PLUGIN_PROTOCOL) {
1722 ModestProtocol *protocol;
1724 ModestProtocolType proto_type;
1725 ModestWizardDialogResponseOverrideFunc response_override;
1727 /* Get protocol data */
1728 proto_name = modest_provider_picker_get_active_provider_id (picker);
1729 protocol = modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (),
1730 MODEST_PROTOCOL_REGISTRY_PROVIDER_PROTOCOLS,
1732 proto_type = modest_protocol_get_type_id (protocol);
1735 /* If we come from a rollbacked easy setup */
1736 if (priv->last_plugin_protocol_selected != proto_type &&
1737 priv->page_complete_easysetup) {
1738 remove_non_common_tabs (self, TRUE);
1739 init_user_page (priv);
1740 priv->page_complete_easysetup = NULL;
1743 /* Ensure that the response override handler
1744 is set. It might happen that plugins clear
1746 response_override = modest_account_protocol_get_wizard_response_override
1747 (MODEST_ACCOUNT_PROTOCOL (protocol));
1748 modest_wizard_dialog_set_response_override_handler (MODEST_WIZARD_DIALOG (self),
1751 if (protocol && MODEST_IS_ACCOUNT_PROTOCOL (protocol) &&
1752 proto_type != priv->last_plugin_protocol_selected) {
1753 ModestPairList *tabs;
1755 gboolean first_page = TRUE;
1757 /* Remember the last selected plugin protocol */
1758 priv->last_plugin_protocol_selected = proto_type;
1761 tabs = modest_account_protocol_get_easysetupwizard_tabs (MODEST_ACCOUNT_PROTOCOL (protocol));
1762 tmp = (GSList *) tabs;
1764 ModestPair *pair = (ModestPair *) tmp->data;
1765 modest_easysetup_wizard_dialog_append_page (notebook,
1766 GTK_WIDGET (pair->second),
1767 (const gchar *) pair->first);
1769 gtk_container_set_focus_child (GTK_CONTAINER (notebook),
1770 GTK_WIDGET (pair->second));
1774 /* Connect signals */
1775 if (MODEST_IS_EASYSETUP_WIZARD_PAGE (pair->second)) {
1776 priv->missing_data_signals =
1777 modest_signal_mgr_connect (priv->missing_data_signals,
1778 G_OBJECT (pair->second),
1779 "missing-mandatory-data",
1780 G_CALLBACK (on_missing_mandatory_data),
1784 g_free (pair->first);
1785 tmp = g_slist_next (tmp);
1786 /* Critical: if you don't show the page then the dialog will ignore it */
1787 /* gtk_widget_show (GTK_WIDGET (pair->second)); */
1789 modest_pair_list_free (tabs);
1791 g_free (proto_name);
1793 if (priv->last_plugin_protocol_selected !=
1794 MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
1795 remove_non_common_tabs (self, TRUE);
1796 init_user_page (priv);
1797 priv->page_complete_easysetup = NULL;
1798 priv->last_plugin_protocol_selected = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID;
1799 modest_signal_mgr_disconnect_all_and_destroy (priv->missing_data_signals);
1800 priv->missing_data_signals = NULL;
1802 if (!priv->page_user_details) {
1803 priv->page_user_details = create_page_user_details (self);
1804 modest_easysetup_wizard_dialog_append_page (notebook,
1805 priv->page_user_details,
1806 _("mcen_ti_emailsetup_userdetails"));
1810 /* Create the easysetup pages: */
1811 create_subsequent_easysetup_pages (self);
1817 util_get_default_servername_from_email_address (const gchar* email_address, ModestProtocolType protocol_type)
1819 const gchar* hostname = NULL;
1822 ModestProtocolRegistry *protocol_registry;
1823 ModestProtocol *protocol;
1828 at = g_utf8_strchr (email_address, -1, '@');
1829 if (!at || (g_utf8_strlen (at, -1) < 2))
1832 domain = g_utf8_next_char (at);
1836 protocol_registry = modest_runtime_get_protocol_registry ();
1837 protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, protocol_type);
1839 if (modest_protocol_registry_protocol_type_has_tag (protocol_registry, protocol_type, MODEST_PROTOCOL_REGISTRY_REMOTE_STORE_PROTOCOLS) ||
1840 modest_protocol_registry_protocol_type_has_tag (protocol_registry, protocol_type, MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS)) {
1841 hostname = modest_protocol_get_name (protocol);
1847 return g_strdup_printf ("%s.%s", hostname, domain);
1851 set_default_custom_servernames (ModestEasysetupWizardDialog *self)
1853 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self);
1855 if (!priv->entry_incomingserver)
1858 /* Set a default domain for the server, based on the email address,
1859 * if no server name was already specified.
1861 if (priv->entry_user_email
1862 && ((priv->server_changes & MODEST_EASYSETUP_WIZARD_DIALOG_INCOMING_CHANGED) == 0)) {
1863 const ModestProtocolType protocol_type = modest_servertype_picker_get_active_servertype (
1864 MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker));
1866 /* This could happen when the combo box has still no active iter */
1867 if (protocol_type != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
1868 const gchar* email_address = hildon_entry_get_text (HILDON_ENTRY(priv->entry_user_email));
1869 gchar* servername = util_get_default_servername_from_email_address (email_address,
1872 /* Do not set the INCOMING_CHANGED flag because of this edit */
1873 g_signal_handlers_block_by_func (G_OBJECT (priv->entry_incomingserver), G_CALLBACK (on_entry_incoming_servername_changed), self);
1874 hildon_entry_set_text (HILDON_ENTRY (priv->entry_incomingserver), servername);
1875 g_signal_handlers_unblock_by_func (G_OBJECT (priv->entry_incomingserver), G_CALLBACK (on_entry_incoming_servername_changed), self);
1877 g_free (servername);
1881 /* Set a default domain for the server, based on the email address,
1882 * if no server name was already specified.
1884 if (!priv->entry_outgoingserver)
1887 if (priv->entry_user_email
1888 && ((priv->server_changes & MODEST_EASYSETUP_WIZARD_DIALOG_OUTGOING_CHANGED) == 0)) {
1889 const gchar* email_address = hildon_entry_get_text (HILDON_ENTRY(priv->entry_user_email));
1891 gchar* servername = util_get_default_servername_from_email_address (email_address, MODEST_PROTOCOLS_TRANSPORT_SMTP);
1893 /* Do not set the OUTGOING_CHANGED flag because of this edit */
1894 g_signal_handlers_block_by_func (G_OBJECT (priv->entry_outgoingserver), G_CALLBACK (on_entry_outgoing_servername_changed), self);
1895 hildon_entry_set_text (HILDON_ENTRY (priv->entry_outgoingserver), servername);
1896 g_signal_handlers_unblock_by_func (G_OBJECT (priv->entry_outgoingserver), G_CALLBACK (on_entry_outgoing_servername_changed), self);
1898 g_free (servername);
1903 get_entered_account_title (ModestEasysetupWizardDialog *self)
1905 ModestEasysetupWizardDialogPrivate *priv;
1906 const gchar* account_title;
1908 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE(self);
1909 account_title = hildon_entry_get_text (HILDON_ENTRY (priv->entry_account_title));
1911 if (!account_title || (g_utf8_strlen (account_title, -1) == 0)) {
1914 /* Strip it of whitespace at the start and end: */
1915 gchar *result = g_strdup (account_title);
1916 result = g_strstrip (result);
1921 if (g_utf8_strlen (result, -1) == 0) {
1931 on_before_next (ModestWizardDialog *dialog, GtkWidget *current_page, GtkWidget *next_page)
1933 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (dialog);
1934 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
1935 ModestProtocolRegistry *protocol_registry;
1937 protocol_registry = modest_runtime_get_protocol_registry ();
1939 /* if are browsing pages previous to the last one, then we have pending settings in
1941 if (next_page != NULL)
1942 priv->pending_load_settings = TRUE;
1944 /* Do extra validation that couldn't be done for every key press,
1945 * either because it was too slow,
1946 * or because it requires interaction:
1948 if (current_page == priv->page_welcome) {
1949 if (!priv->check_support_done) {
1950 check_support_of_protocols (self);
1951 return priv->check_support_done;
1953 } else if (current_page == priv->page_account_details) {
1954 /* Check that the title is not already in use: */
1955 gchar* account_title = get_entered_account_title (self);
1959 /* Aavoid a clash with an existing display name: */
1960 const gboolean name_in_use = modest_account_mgr_account_with_display_name_exists (
1961 priv->account_manager, account_title);
1962 g_free (account_title);
1965 /* Warn the user via a dialog: */
1966 hildon_banner_show_information(NULL, NULL, _("mail_ib_account_name_already_existing"));
1971 /* Make sure that the subsequent pages are appropriate for the provider choice. */
1972 create_subsequent_pages (self);
1974 } else if (current_page == priv->page_user_details) {
1975 /* Check that the email address is valud: */
1976 const gchar* email_address = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_email));
1977 if ((!email_address) || (g_utf8_strlen (email_address, -1) == 0))
1980 if (!modest_text_utils_validate_email_address (email_address, NULL)) {
1981 /* Warn the user via a dialog: */
1982 hildon_banner_show_information (NULL, NULL, _("mcen_ib_invalid_email"));
1984 /* Return focus to the email address entry: */
1985 gtk_widget_grab_focus (priv->entry_user_email);
1986 gtk_editable_select_region (GTK_EDITABLE (priv->entry_user_email), 0, -1);
1990 } else if (current_page == priv->page_custom_incoming ||
1991 current_page == priv->page_custom_outgoing) {
1993 const gchar *hostname;
1994 GtkWidget *entry = (current_page == priv->page_custom_incoming) ?
1995 priv->entry_incomingserver :
1996 priv->entry_outgoingserver;
1998 hostname = gtk_entry_get_text (GTK_ENTRY (entry));
1999 if (!modest_text_utils_validate_domain_name (hostname)) {
2001 modest_platform_information_banner (NULL, NULL, _("mcen_ib_invalid_servername"));
2003 /* Return focus to the email address entry: */
2004 gtk_widget_grab_focus (entry);
2005 gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
2011 if (next_page == priv->page_custom_incoming) {
2012 set_default_custom_servernames (self);
2013 } else if (next_page == priv->page_custom_outgoing) {
2014 set_default_custom_servernames (self);
2016 /* Check if the server supports secure authentication */
2017 if (modest_security_options_view_auth_check (MODEST_SECURITY_OPTIONS_VIEW (priv->incoming_security)))
2018 if (!check_has_supported_auth_methods (self))
2020 gtk_widget_show (priv->outgoing_security);
2023 /* If this is the last page, and this is a click on Finish,
2024 * then attempt to create the dialog.
2027 current_page != priv->page_account_details) /* This is NULL when this is a click on Finish. */
2029 if (priv->pending_load_settings) {
2030 save_to_settings (self);
2033 /* We check if there's already another account with the same configuration */
2034 if (modest_account_mgr_check_already_configured_account (priv->account_manager, priv->settings)) {
2035 modest_platform_information_banner (NULL, NULL, _("mail_ib_setting_failed"));
2039 modest_account_mgr_add_account_from_settings (priv->account_manager, priv->settings);
2040 hildon_gtk_window_take_screenshot ((GtkWindow *) dialog, FALSE);
2047 static gboolean entry_is_empty (GtkWidget *entry)
2052 const gchar* text = hildon_entry_get_text (HILDON_ENTRY (entry));
2053 if ((!text) || (g_utf8_strlen (text, -1) == 0))
2056 /* Strip it of whitespace at the start and end: */
2057 gchar *stripped = g_strdup (text);
2058 stripped = g_strstrip (stripped);
2063 const gboolean result = (g_utf8_strlen (stripped, -1) == 0);
2071 real_enable_buttons (ModestWizardDialog *dialog, gboolean enable_next)
2073 GtkNotebook *notebook = NULL;
2074 gboolean is_finish_tab;
2076 ModestEasysetupWizardDialogPrivate *priv;
2079 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (dialog);
2080 g_object_get (dialog, "wizard-notebook", ¬ebook, NULL);
2082 /* Disable the Finish button until we are on the last page,
2083 * because HildonWizardDialog enables this for all but the
2085 current = gtk_notebook_get_nth_page (notebook, gtk_notebook_get_current_page (notebook));
2086 is_finish_tab = ((current == priv->page_complete_easysetup) ||
2087 (current == priv->page_complete_customsetup));
2089 if (is_finish_tab) {
2090 /* Disable Next on the last page no matter what the
2092 enable_next = FALSE;
2094 /* Not the last one */
2095 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
2096 MODEST_WIZARD_DIALOG_FINISH,
2099 /* If the check support is not done then do not enable
2100 the wizard to continue */
2101 enable_next = enable_next && priv->pending_check_support == 0;
2104 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
2105 MODEST_WIZARD_DIALOG_NEXT,
2110 on_enable_buttons (ModestWizardDialog *dialog, GtkWidget *current_page)
2112 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (dialog);
2113 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
2115 gboolean enable_next = TRUE;
2116 if (current_page == priv->page_welcome) {
2118 } else if (current_page == priv->page_account_details) {
2119 /* The account details title is mandatory: */
2120 if (entry_is_empty(priv->entry_account_title))
2121 enable_next = FALSE;
2122 } else if (current_page == priv->page_user_details) {
2123 /* The user details username is mandatory: */
2124 if (entry_is_empty(priv->entry_user_username))
2125 enable_next = FALSE;
2127 /* The user details email address is mandatory: */
2128 if (enable_next && entry_is_empty (priv->entry_user_email))
2129 enable_next = FALSE;
2130 } else if (current_page == priv->page_custom_incoming) {
2131 /* The custom incoming server is mandatory: */
2132 if (entry_is_empty(priv->entry_incomingserver))
2133 enable_next = FALSE;
2134 } else if (MODEST_IS_EASYSETUP_WIZARD_PAGE (current_page)) {
2135 enable_next = !modest_easysetup_wizard_page_validate (
2136 MODEST_EASYSETUP_WIZARD_PAGE (current_page));
2139 /* Enable/disable buttons */
2140 real_enable_buttons (dialog, enable_next);
2144 modest_easysetup_wizard_dialog_class_init (ModestEasysetupWizardDialogClass *klass)
2146 GObjectClass *object_class = G_OBJECT_CLASS (klass);
2147 g_type_class_add_private (klass, sizeof (ModestEasysetupWizardDialogPrivate));
2150 object_class->dispose = modest_easysetup_wizard_dialog_dispose;
2151 object_class->finalize = modest_easysetup_wizard_dialog_finalize;
2153 /* Provide a vfunc implementation so we can decide
2154 * when to enable/disable the prev/next buttons.
2156 ModestWizardDialogClass *base_klass = (ModestWizardDialogClass*)(klass);
2157 base_klass->before_next = on_before_next;
2158 base_klass->enable_buttons = on_enable_buttons;
2159 base_klass->update_model = on_update_model;
2160 base_klass->save = on_save;
2164 check_username_for_provider (const gchar *provider_id,
2165 const gchar *domain,
2168 gchar *providers_to_check[] = { "ovi.com", "yahoomailplus.com", "hotmail.com" };
2170 gboolean found = FALSE;
2173 /* Check if the username contains the @hostname, if not then add it */
2174 if (strchr (*username, '@'))
2177 /* Check if it's one of the providers to check */
2178 for (i = 0; i < G_N_ELEMENTS (providers_to_check) && !found; i++) {
2179 if (!g_ascii_strncasecmp (providers_to_check[i], provider_id, strlen (providers_to_check[i])))
2186 /* Replace the username */
2188 *username = g_strconcat (*username, "@", domain, NULL);
2194 * @self: a #ModestEasysetupWizardDialog
2196 * takes information from all the wizard and stores it in settings
2199 save_to_settings (ModestEasysetupWizardDialog *self)
2201 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
2203 gchar *provider_id = NULL;
2204 gchar *alternate_username = NULL;
2205 gchar *display_name;
2206 const gchar *username, *password;
2207 gchar *store_hostname, *transport_hostname;
2208 guint store_port, transport_port;
2209 ModestProtocolRegistry *protocol_registry;
2210 ModestProtocolType store_protocol, transport_protocol;
2211 ModestProtocolType store_security, transport_security;
2212 ModestProtocolType store_auth_protocol, transport_auth_protocol;
2213 ModestServerAccountSettings *store_settings, *transport_settings;
2214 const gchar *fullname, *email_address;
2215 ModestProviderPicker *picker;
2216 ModestProviderPickerIdType id_type;
2218 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
2219 picker = MODEST_PROVIDER_PICKER (priv->account_serviceprovider_picker);
2220 protocol_registry = modest_runtime_get_protocol_registry ();
2222 /* Get details from the specified presets: */
2223 id_type = modest_provider_picker_get_active_id_type (picker);
2224 provider_id = modest_provider_picker_get_active_provider_id (picker);
2226 /* Let the plugin save the settings. We do a return in order
2227 to save an indentation level */
2228 if (id_type == MODEST_PROVIDER_PICKER_ID_PLUGIN_PROTOCOL) {
2229 ModestProtocol *protocol;
2231 protocol = modest_protocol_registry_get_protocol_by_name (
2232 modest_runtime_get_protocol_registry (),
2233 MODEST_PROTOCOL_REGISTRY_PROVIDER_PROTOCOLS,
2236 if (protocol && MODEST_IS_ACCOUNT_PROTOCOL (protocol)) {
2237 gint n_pages, i = 0;
2238 GtkNotebook *notebook;
2239 GList *wizard_pages = NULL;
2241 g_object_get (self, "wizard-notebook", ¬ebook, NULL);
2242 n_pages = gtk_notebook_get_n_pages (notebook);
2243 for (i = 0; i < n_pages; i++) {
2244 GtkWidget *page = gtk_notebook_get_nth_page (notebook, i);
2245 if (MODEST_IS_EASYSETUP_WIZARD_PAGE (page))
2246 wizard_pages = g_list_append (wizard_pages, page);
2248 modest_account_protocol_save_wizard_settings (MODEST_ACCOUNT_PROTOCOL (protocol),
2251 g_list_free (wizard_pages);
2253 g_debug ("The selected protocol is a plugin protocol "//
2254 "but it's not a ModestAccountProtocol");
2257 g_free (provider_id);
2261 /* username and password (for both incoming and outgoing): */
2262 username = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_username));
2263 password = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_password));
2265 store_settings = modest_account_settings_get_store_settings (priv->settings);
2266 transport_settings = modest_account_settings_get_transport_settings (priv->settings);
2268 /* Incoming server: */
2269 /* Note: We need something as default for the transport store protocol values,
2270 * or modest_account_mgr_add_server_account will fail. */
2272 store_protocol = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID;
2273 store_security = MODEST_PROTOCOLS_CONNECTION_NONE;
2274 store_auth_protocol = MODEST_PROTOCOLS_AUTH_NONE;
2277 ModestProtocolType store_provider_server_type;
2278 gboolean store_provider_use_alternate_port;
2279 gchar *domain = NULL;
2282 store_hostname = modest_presets_get_server (priv->presets, provider_id,
2285 store_provider_server_type = modest_presets_get_info_server_type (priv->presets,
2288 store_security = modest_presets_get_info_server_security (priv->presets,
2291 store_auth_protocol = modest_presets_get_info_server_auth (priv->presets,
2294 store_provider_use_alternate_port = modest_presets_get_info_server_use_alternate_port (priv->presets,
2299 /* This is HORRIBLE, but it seems that somehow it helps users
2300 that do not like to read the user instructions for their
2302 domain = modest_presets_get_domain (priv->presets, provider_id);
2304 alternate_username = g_strdup (username);
2305 check_username_for_provider (provider_id, domain, &alternate_username);
2309 /* We don't check for SMTP here as that is impossible for an incoming server. */
2310 if (store_provider_server_type == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID)
2311 store_protocol = MODEST_PROTOCOLS_STORE_POP;
2313 store_protocol = store_provider_server_type;
2315 /* we check if there is a *special* port */
2316 special_port = modest_presets_get_port (priv->presets, provider_id, TRUE /* incoming */);
2317 if (special_port != 0) {
2318 store_port = special_port;
2320 gboolean use_alternate_port = FALSE;
2321 if (modest_protocol_registry_protocol_type_is_secure (modest_runtime_get_protocol_registry (),
2323 use_alternate_port = TRUE;
2324 store_port = get_port_from_protocol(store_provider_server_type, use_alternate_port);
2327 modest_server_account_settings_set_security_protocol (store_settings,
2329 modest_server_account_settings_set_auth_protocol (store_settings,
2330 store_auth_protocol);
2331 if (store_port != 0)
2332 modest_server_account_settings_set_port (store_settings, store_port);
2334 /* Use custom pages because no preset was specified: */
2335 store_hostname = g_strdup (hildon_entry_get_text (HILDON_ENTRY (priv->entry_incomingserver) ));
2336 store_protocol = modest_servertype_picker_get_active_servertype (
2337 MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker));
2339 modest_security_options_view_save_settings (
2340 MODEST_SECURITY_OPTIONS_VIEW (priv->incoming_security),
2344 /* now we store the common store account settings */
2345 modest_server_account_settings_set_hostname (store_settings, store_hostname);
2346 modest_server_account_settings_set_username (store_settings, (alternate_username) ? alternate_username : username);
2347 modest_server_account_settings_set_password (store_settings, password);
2348 modest_server_account_settings_set_protocol (store_settings, store_protocol);
2350 g_object_unref (store_settings);
2351 g_free (store_hostname);
2353 /* Outgoing server: */
2354 transport_hostname = NULL;
2355 transport_protocol = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID;
2356 transport_security = MODEST_PROTOCOLS_CONNECTION_NONE;
2357 transport_auth_protocol = MODEST_PROTOCOLS_AUTH_NONE;
2361 ModestProtocolType transport_provider_server_type;
2362 ModestProtocolType transport_provider_security;
2366 transport_hostname = modest_presets_get_server (priv->presets, provider_id,
2367 FALSE /* transport */);
2369 transport_provider_server_type = modest_presets_get_info_server_type (priv->presets,
2371 FALSE /* transport */);
2372 transport_provider_security = modest_presets_get_info_server_security (priv->presets,
2374 FALSE /* transport */);
2376 /* Note: We need something as default, or modest_account_mgr_add_server_account will fail. */
2377 transport_protocol = transport_provider_server_type;
2378 transport_security = transport_provider_security;
2379 is_secure = modest_protocol_registry_protocol_type_is_secure (modest_runtime_get_protocol_registry (),
2380 transport_security);
2382 /* we check if there is a *special* port */
2383 special_port = modest_presets_get_port (priv->presets, provider_id,
2384 FALSE /* transport */);
2385 if (special_port != 0) {
2386 transport_port = special_port;
2388 gboolean use_alternate_port = FALSE;
2389 if (transport_security == MODEST_PROTOCOLS_CONNECTION_SSL)
2390 use_alternate_port = TRUE;
2391 transport_port = get_port_from_protocol(transport_provider_server_type, use_alternate_port);
2395 transport_auth_protocol = MODEST_PROTOCOLS_AUTH_PASSWORD;
2397 transport_auth_protocol = MODEST_PROTOCOLS_AUTH_NONE;
2399 modest_server_account_settings_set_security_protocol (transport_settings,
2400 transport_security);
2401 modest_server_account_settings_set_auth_protocol (transport_settings,
2402 transport_auth_protocol);
2403 if (transport_port != 0)
2404 modest_server_account_settings_set_port (transport_settings,
2407 ModestProtocolRegistry *registry;
2408 ModestProtocol *store_proto;
2410 registry = modest_runtime_get_protocol_registry ();
2411 /* Use custom pages because no preset was specified: */
2412 transport_hostname = g_strdup (hildon_entry_get_text (HILDON_ENTRY (priv->entry_outgoingserver) ));
2414 store_proto = modest_protocol_registry_get_protocol_by_type (registry,
2417 if (transport_protocol == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
2418 /* fallback to SMTP if none was specified */
2419 g_warning ("No transport protocol was specified for store %d (%s)",
2420 modest_protocol_get_type_id (store_proto),
2421 modest_protocol_get_display_name (store_proto));
2422 transport_protocol = MODEST_PROTOCOLS_TRANSPORT_SMTP;
2425 modest_security_options_view_save_settings (
2426 MODEST_SECURITY_OPTIONS_VIEW (priv->outgoing_security),
2430 /* now we store the common transport account settings */
2431 modest_server_account_settings_set_hostname (transport_settings, transport_hostname);
2432 modest_server_account_settings_set_username (transport_settings, (alternate_username) ? alternate_username : username);
2433 modest_server_account_settings_set_password (transport_settings, password);
2434 modest_server_account_settings_set_protocol (transport_settings, transport_protocol);
2436 g_object_unref (transport_settings);
2437 g_free (transport_hostname);
2438 if (alternate_username)
2439 g_free (alternate_username);
2441 fullname = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_name));
2442 email_address = hildon_entry_get_text (HILDON_ENTRY (priv->entry_user_email));
2443 modest_account_settings_set_fullname (priv->settings, fullname);
2444 modest_account_settings_set_email_address (priv->settings, email_address);
2445 /* we don't set retrieve type to preserve advanced settings if
2446 any. By default account settings are set to headers only */
2448 /* Save the connection-specific SMTP server accounts. */
2449 if (priv->checkbox_outgoing_smtp_specific) {
2450 modest_account_settings_set_use_connection_specific_smtp
2452 hildon_check_button_get_active(HILDON_CHECK_BUTTON(priv->checkbox_outgoing_smtp_specific)));
2455 display_name = get_entered_account_title (self);
2456 modest_account_settings_set_display_name (priv->settings, display_name);
2457 g_free (display_name);
2458 g_free (provider_id);
2460 /* This values are hardcoded for Fremantle */
2461 modest_account_settings_set_retrieve_type (priv->settings,
2462 MODEST_ACCOUNT_RETRIEVE_MESSAGES_AND_ATTACHMENTS);
2463 modest_account_settings_set_retrieve_limit (priv->settings, 20);
2468 on_update_model (ModestWizardDialog *dialog)
2470 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (dialog);
2471 save_to_settings (self);
2476 on_save (ModestWizardDialog *dialog)
2478 ModestEasysetupWizardDialog *self = MODEST_EASYSETUP_WIZARD_DIALOG (dialog);
2479 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
2482 save_to_settings (self);
2484 if (modest_account_mgr_check_already_configured_account (priv->account_manager, priv->settings)) {
2485 modest_platform_information_banner (NULL, NULL, _("mail_ib_setting_failed"));
2490 result = modest_account_mgr_add_account_from_settings (priv->account_manager, priv->settings);
2492 hildon_gtk_window_take_screenshot ((GtkWindow *) dialog, FALSE);
2500 check_for_supported_auth_methods (ModestEasysetupWizardDialog* self)
2502 GError *error = NULL;
2503 ModestProtocolType protocol_type;
2504 const gchar* hostname;
2505 const gchar* username;
2506 ModestProtocolType security_protocol_incoming_type;
2507 ModestProtocolRegistry *registry;
2509 GList *list_auth_methods;
2510 ModestEasysetupWizardDialogPrivate *priv;
2512 priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
2513 registry = modest_runtime_get_protocol_registry ();
2514 protocol_type = modest_servertype_picker_get_active_servertype (
2515 MODEST_SERVERTYPE_PICKER (priv->incoming_servertype_picker));
2516 hostname = gtk_entry_get_text(GTK_ENTRY(priv->entry_incomingserver));
2517 username = gtk_entry_get_text(GTK_ENTRY(priv->entry_user_username));
2518 security_protocol_incoming_type = modest_security_options_view_get_connection_protocol
2519 (MODEST_SECURITY_OPTIONS_VIEW (priv->incoming_security));
2520 port_num = get_port_from_protocol(protocol_type, FALSE);
2521 list_auth_methods = modest_utils_get_supported_secure_authentication_methods (protocol_type, hostname, port_num,
2522 username, GTK_WINDOW (self), &error);
2524 if (list_auth_methods) {
2525 /* TODO: Select the correct method */
2528 for (method = list_auth_methods; method != NULL; method = g_list_next(method)) {
2529 ModestProtocolType auth_protocol_type = (ModestProtocolType) (GPOINTER_TO_INT(method->data));
2530 if (modest_protocol_registry_protocol_type_has_tag (registry, auth_protocol_type,
2531 MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS)) {
2532 list = g_list_append(list, GINT_TO_POINTER(auth_protocol_type));
2536 g_list_free(list_auth_methods);
2542 if(error == NULL || error->domain != modest_utils_get_supported_secure_authentication_error_quark() ||
2543 error->code != MODEST_UTILS_GET_SUPPORTED_SECURE_AUTHENTICATION_ERROR_CANCELED)
2545 modest_platform_information_banner (GTK_WIDGET(self), NULL,
2546 _("mcen_ib_unableto_discover_auth_methods"));
2550 g_error_free(error);
2556 check_has_supported_auth_methods(ModestEasysetupWizardDialog* self)
2558 GList* methods = check_for_supported_auth_methods(self);
2564 g_list_free(methods);
2569 check_support_show_progress (gpointer userdata)
2571 ModestEasysetupWizardDialog *self = (ModestEasysetupWizardDialog *) userdata;
2572 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
2574 priv->check_support_show_progress_id = 0;
2576 if (priv->destroyed)
2579 hildon_gtk_window_set_progress_indicator (GTK_WINDOW (self), TRUE);
2585 check_support_progress_pulse (gpointer userdata)
2587 ModestEasysetupWizardDialog *self = (ModestEasysetupWizardDialog *) userdata;
2588 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
2590 if (priv->destroyed || priv->check_support_progress == NULL) {
2591 priv->check_support_progress_pulse_id = 0;
2595 gtk_progress_bar_pulse (GTK_PROGRESS_BAR (priv->check_support_progress));
2601 check_support_callback (ModestAccountProtocol *protocol,
2605 ModestEasysetupWizardDialog *self = (ModestEasysetupWizardDialog *) userdata;
2606 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
2608 priv->pending_check_support --;
2610 if (priv->check_support_show_progress_id > 0) {
2611 g_source_remove (priv->check_support_show_progress_id);
2612 priv->check_support_show_progress_id = 0;
2615 if (priv->pending_check_support == 0) {
2616 priv->check_support_done = TRUE;
2618 if (priv->check_support_cancel_note) {
2619 gtk_widget_destroy (priv->check_support_cancel_note);
2620 priv->check_support_cancel_note = NULL;
2621 priv->check_support_progress = NULL;
2624 if (!priv->destroyed) {
2626 fill_providers (self);
2627 hildon_gtk_window_set_progress_indicator (GTK_WINDOW (self), FALSE);
2628 invoke_enable_buttons_vfunc (self);
2629 gtk_dialog_response (GTK_DIALOG (self), MODEST_WIZARD_DIALOG_NEXT);
2632 g_object_unref (self);
2636 on_check_support_cancel (GtkDialog *cancel_note,
2638 ModestEasysetupWizardDialog *self)
2640 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
2641 ModestProtocolRegistry *registry;
2642 GSList *provider_protos, *node;
2644 registry = modest_runtime_get_protocol_registry ();
2645 provider_protos = modest_protocol_registry_get_by_tag (registry,
2646 MODEST_PROTOCOL_REGISTRY_PROVIDER_PROTOCOLS);
2648 for (node = provider_protos; node != NULL; node = g_slist_next (node)) {
2649 ModestProtocol *proto = MODEST_PROTOCOL (node->data);
2651 if (!modest_protocol_registry_protocol_type_has_tag (registry,
2652 modest_protocol_get_type_id (proto),
2653 MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS))
2656 if (modest_protocol_registry_protocol_type_has_tag
2658 modest_protocol_get_type_id (proto),
2659 MODEST_PROTOCOL_REGISTRY_SINGLETON_PROVIDER_PROTOCOLS)) {
2660 /* Check if there's already an account configured with this account type */
2661 if (modest_account_mgr_singleton_protocol_exists (modest_runtime_get_account_mgr (),
2662 modest_protocol_get_type_id (proto)))
2666 if (MODEST_ACCOUNT_PROTOCOL (proto)) {
2667 modest_account_protocol_cancel_check_support (MODEST_ACCOUNT_PROTOCOL (proto));
2670 g_slist_free (provider_protos);
2672 gtk_widget_destroy (GTK_WIDGET (cancel_note));
2673 priv->check_support_cancel_note = NULL;
2674 priv->check_support_progress = NULL;
2678 check_support_of_protocols (ModestEasysetupWizardDialog *self)
2680 ModestProtocolRegistry *registry;
2681 GSList *provider_protos, *node, *check_support_providers;
2682 ModestEasysetupWizardDialogPrivate *priv = MODEST_EASYSETUP_WIZARD_DIALOG_GET_PRIVATE (self);
2684 registry = modest_runtime_get_protocol_registry ();
2685 provider_protos = modest_protocol_registry_get_by_tag (registry,
2686 MODEST_PROTOCOL_REGISTRY_PROVIDER_PROTOCOLS);
2688 check_support_providers = NULL;
2689 for (node = provider_protos; node != NULL; node = g_slist_next (node)) {
2690 ModestProtocol *proto = MODEST_PROTOCOL (node->data);
2692 if (!modest_protocol_registry_protocol_type_has_tag (registry,
2693 modest_protocol_get_type_id (proto),
2694 MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS))
2697 if (modest_protocol_registry_protocol_type_has_tag
2699 modest_protocol_get_type_id (proto),
2700 MODEST_PROTOCOL_REGISTRY_SINGLETON_PROVIDER_PROTOCOLS)) {
2701 /* Check if there's already an account configured with this account type */
2702 if (modest_account_mgr_singleton_protocol_exists (modest_runtime_get_account_mgr (),
2703 modest_protocol_get_type_id (proto)))
2707 if (MODEST_ACCOUNT_PROTOCOL (proto)) {
2708 priv->pending_check_support ++;
2709 check_support_providers = g_slist_prepend (check_support_providers, proto);
2712 g_slist_free (provider_protos);
2714 for (node = check_support_providers; node != NULL; node = g_slist_next (node)) {
2715 ModestProtocol *proto = MODEST_PROTOCOL (node->data);
2717 modest_account_protocol_check_support (MODEST_ACCOUNT_PROTOCOL (proto),
2718 check_support_callback,
2719 g_object_ref (self));
2721 g_slist_free (check_support_providers);
2723 if (priv->pending_check_support > 0) {
2724 priv->check_support_show_progress_id = g_timeout_add_full (G_PRIORITY_DEFAULT, 1000,
2725 check_support_show_progress,
2726 g_object_ref (self), g_object_unref);
2727 priv->check_support_progress_pulse_id = g_timeout_add_full (G_PRIORITY_DEFAULT, 200,
2728 check_support_progress_pulse,
2729 g_object_ref (self), g_object_unref);
2730 priv->check_support_progress = gtk_progress_bar_new ();
2731 priv->check_support_cancel_note = hildon_note_new_cancel_with_progress_bar (GTK_WINDOW (self),
2732 _("mcen_cn_availability_check"),
2733 GTK_PROGRESS_BAR (priv->check_support_progress));
2734 gtk_widget_show (priv->check_support_cancel_note);
2735 g_signal_connect (priv->check_support_cancel_note, "response", G_CALLBACK (on_check_support_cancel), self);
2737 priv->check_support_done = TRUE;
2739 invoke_enable_buttons_vfunc (self);