96b81e5ad51391f62cef11f3d0aee2bb54a7beef
[modest] / src / hildon2 / modest-maemo-security-options-view.c
1 /* Copyright (c) 2008, Nokia Corporation
2  * All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  * * Redistributions of source code must retain the above copyright
9  *   notice, this list of conditions and the following disclaimer.
10  * * Redistributions in binary form must reproduce the above copyright
11  *   notice, this list of conditions and the following disclaimer in the
12  *   documentation and/or other materials provided with the distribution.
13  * * Neither the name of the Nokia Corporation nor the names of its
14  *   contributors may be used to endorse or promote products derived from
15  *   this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "modest-runtime.h"
31 #include "modest-security-options-view-priv.h"
32 #include "modest-maemo-security-options-view.h"
33 #include "modest-text-utils.h"
34 #include "modest-platform.h"
35 #include "modest-account-protocol.h"
36 #include "widgets/modest-ui-constants.h"
37 #include "widgets/modest-validating-entry.h"
38 #include "modest-serversecurity-picker.h"
39 #include "modest-secureauth-picker.h"
40 #include "modest-maemo-utils.h"
41 #include <hildon/hildon-number-editor.h>
42 #include <hildon/hildon-check-button.h>
43 #include "modest-hildon-includes.h"
44
45 #define PORT_MIN 1
46 #define PORT_MAX 65535
47
48 static void modest_maemo_security_options_view_init (ModestMaemoSecurityOptionsView *obj);
49 static void modest_maemo_security_options_view_finalize (GObject *obj);
50 static void modest_maemo_security_options_view_class_init (ModestMaemoSecurityOptionsViewClass *klass);
51
52 G_DEFINE_TYPE (ModestMaemoSecurityOptionsView, 
53                modest_maemo_security_options_view, 
54                MODEST_TYPE_SECURITY_OPTIONS_VIEW);
55
56 static void on_entry_changed (GtkEditable *editable, gpointer user_data);
57
58 /* Tracks changes in the incoming security picker */
59 static void
60 on_security_changed (GtkWidget *widget, 
61                      ModestMaemoSecurityOptionsView *self)
62 {
63         ModestSecurityOptionsViewPrivate* ppriv;
64         ModestServersecurityPicker *picker;
65         ModestProtocolType proto_type;
66         ModestProtocolRegistry *proto_registry;
67         gboolean is_secure;
68
69         ppriv = MODEST_SECURITY_OPTIONS_VIEW_GET_PRIVATE (self);
70
71         proto_registry = modest_runtime_get_protocol_registry ();
72         picker = MODEST_SERVERSECURITY_PICKER (ppriv->security_view);
73         proto_type = modest_serversecurity_picker_get_active_serversecurity (picker);
74
75         is_secure = modest_protocol_registry_protocol_type_has_tag (proto_registry, proto_type, 
76                                                                     MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS);
77
78         if (MODEST_SECURITY_OPTIONS_VIEW (self)->type == MODEST_SECURITY_OPTIONS_INCOMING) {
79                 /* Activate and dim checkbutton if it's secure */
80                 hildon_check_button_set_active (HILDON_CHECK_BUTTON (ppriv->auth_view), 
81                                                 is_secure);
82                 gtk_widget_set_sensitive (ppriv->auth_view, !is_secure);
83         } else {
84
85         }
86
87         if (ppriv->full) {
88                 gint port_number = 
89                         modest_serversecurity_picker_get_active_serversecurity_port (MODEST_SERVERSECURITY_PICKER (ppriv->security_view));
90                 
91                 if(port_number) {
92                         hildon_number_editor_set_value (HILDON_NUMBER_EDITOR (ppriv->port_view), 
93                                                         port_number);
94                 }
95         }
96 }
97
98 static void
99 on_auth_changed (GtkWidget *widget, 
100                  ModestMaemoSecurityOptionsView *self)
101 {
102         ModestSecurityOptionsViewPrivate* ppriv;
103         ModestSecureauthPicker *picker;
104         ModestProtocolRegistry *protocol_registry;
105         ModestProtocolType auth_proto;
106         gboolean secureauth_used;
107         GtkWidget *user_caption, *pwd_caption;
108
109         ppriv = MODEST_SECURITY_OPTIONS_VIEW_GET_PRIVATE (self);
110         protocol_registry = modest_runtime_get_protocol_registry ();
111         picker = MODEST_SECUREAUTH_PICKER (ppriv->auth_view);
112
113         auth_proto = modest_secureauth_picker_get_active_secureauth (picker);
114         secureauth_used = modest_protocol_registry_protocol_type_is_secure (protocol_registry, 
115                                                                             auth_proto);
116
117         /* Get captions, well dimm the whole widget */
118         user_caption = gtk_widget_get_parent (ppriv->user_entry);
119         pwd_caption = gtk_widget_get_parent (ppriv->pwd_entry);
120         
121         /* Enable / disable */
122         gtk_widget_set_sensitive (user_caption, secureauth_used);
123         gtk_widget_set_sensitive (pwd_caption, secureauth_used);
124
125         /* Check if mandatory data is missing */
126         on_entry_changed (GTK_EDITABLE (ppriv->user_entry), (gpointer) self);
127 }
128
129 static void
130 create_incoming_security (ModestSecurityOptionsView* self,
131                           GtkSizeGroup *size_group)
132 {
133         ModestSecurityOptionsViewPrivate *ppriv;
134         GtkWidget *entry_caption = NULL;
135
136         ppriv = MODEST_SECURITY_OPTIONS_VIEW_GET_PRIVATE (self);
137
138         /* Create widgets for incoming security */
139         ppriv->security_view = GTK_WIDGET (modest_serversecurity_picker_new (MODEST_EDITABLE_SIZE,
140                                                                              MODEST_EDITABLE_ARRANGEMENT));
141         modest_maemo_utils_create_picker_layout (size_group, 
142                                                  _("mcen_li_emailsetup_secure_connection"), 
143                                                  ppriv->security_view);
144
145         if (ppriv->full) {              
146                 ppriv->port_view = GTK_WIDGET (hildon_number_editor_new (PORT_MIN, PORT_MAX));
147                 entry_caption = modest_maemo_utils_create_captioned (size_group, _("mcen_fi_emailsetup_port"), 
148                                                                      ppriv->port_view);
149         }
150
151         ppriv->auth_view = hildon_check_button_new (MODEST_EDITABLE_SIZE);
152         gtk_button_set_label (GTK_BUTTON (ppriv->auth_view), _("mcen_li_emailsetup_secure_authentication"));
153         gtk_size_group_add_widget (size_group, ppriv->auth_view);
154
155         /* Track changes in UI */       
156         g_signal_connect (G_OBJECT (ppriv->security_view), "value-changed",
157                           G_CALLBACK (on_security_changed), self);
158
159         /* Pack into container */
160         gtk_box_pack_start (GTK_BOX (self), ppriv->security_view,
161                             FALSE, FALSE, MODEST_MARGIN_HALF);
162         if (ppriv->full)
163                 gtk_box_pack_start (GTK_BOX (self), entry_caption, 
164                                     FALSE, FALSE, MODEST_MARGIN_HALF);
165         gtk_box_pack_start (GTK_BOX (self), ppriv->auth_view,
166                             FALSE, FALSE, MODEST_MARGIN_HALF);
167
168         /* Show widgets */
169         if (ppriv->full) {
170                 gtk_widget_show (ppriv->port_view);
171                 gtk_widget_show (entry_caption);
172         }
173         gtk_widget_show (ppriv->security_view);
174         gtk_widget_show (ppriv->auth_view);
175 }
176
177 static void
178 on_entry_max (ModestValidatingEntry *self, 
179               gpointer user_data)
180 {
181         modest_platform_information_banner (GTK_WIDGET (self), NULL, 
182                                             _CS("ckdg_ib_maximum_characters_reached"));
183 }
184
185 /*
186  * TODO: call this whenever the auth picker changes. If we set it
187  * explicitely at the beggining to a value then there is no need to
188  * call this handler directly at the beginning
189  */
190 static void
191 on_entry_changed (GtkEditable *editable, 
192                   gpointer user_data)
193 {
194         ModestSecurityOptionsView* self;
195         ModestSecurityOptionsViewPrivate *ppriv;
196         ModestProtocolType auth_proto;
197         ModestSecureauthPicker *picker;
198         gboolean is_secure, missing;
199         ModestProtocolRegistry *protocol_registry;
200
201         self = MODEST_SECURITY_OPTIONS_VIEW (user_data);
202         ppriv = MODEST_SECURITY_OPTIONS_VIEW_GET_PRIVATE (self);
203         protocol_registry = modest_runtime_get_protocol_registry ();
204
205         /* Outgoing username is mandatory if outgoing auth is secure */
206         picker = MODEST_SECUREAUTH_PICKER (ppriv->auth_view);
207         auth_proto = modest_secureauth_picker_get_active_secureauth (picker);
208         is_secure = modest_protocol_registry_protocol_type_is_secure (protocol_registry, 
209                                                                       auth_proto);
210
211         if (is_secure && 
212             !g_ascii_strcasecmp (gtk_entry_get_text (GTK_ENTRY (ppriv->user_entry)), "")) {
213                 missing = TRUE;
214         } else {
215                 missing = FALSE;
216         }
217         
218         /* Emit a signal to notify if mandatory data is missing */
219         g_signal_emit_by_name (G_OBJECT (self), "missing_mandatory_data", 
220                                missing, NULL);
221 }
222
223 static void
224 create_outgoing_security (ModestSecurityOptionsView* self,
225                           GtkSizeGroup *size_group)
226 {
227         ModestSecurityOptionsViewPrivate *ppriv;
228         GtkWidget *user_caption = NULL;
229         GtkWidget *pwd_caption = NULL, *port_caption = NULL;
230
231         ppriv = MODEST_SECURITY_OPTIONS_VIEW_GET_PRIVATE (self);
232         
233         /* The secure connection widgets */
234         ppriv->security_view = GTK_WIDGET (modest_serversecurity_picker_new (MODEST_EDITABLE_SIZE,
235                                                                              MODEST_EDITABLE_ARRANGEMENT));
236         modest_serversecurity_picker_fill (MODEST_SERVERSECURITY_PICKER (ppriv->security_view), 
237                                               MODEST_PROTOCOLS_TRANSPORT_SMTP);
238         modest_maemo_utils_create_picker_layout (size_group, _("mcen_li_emailsetup_secure_connection"), 
239                                                  ppriv->security_view);
240         
241         /* The secure authentication widgets */
242         ppriv->auth_view = GTK_WIDGET (modest_secureauth_picker_new (MODEST_EDITABLE_SIZE,
243                                                                      MODEST_EDITABLE_ARRANGEMENT));
244         modest_maemo_utils_create_picker_layout (size_group, _("mcen_li_emailsetup_secure_authentication"), 
245                                                  ppriv->auth_view);
246
247         if (ppriv->full) {
248                 gchar *user_label;
249
250                 /* Username widgets */
251                 ppriv->user_entry = GTK_WIDGET (modest_validating_entry_new ());
252
253                 /* Auto-capitalization is the default, so let's turn it off: */
254                 hildon_gtk_entry_set_input_mode (GTK_ENTRY (ppriv->user_entry), 
255                                                  HILDON_GTK_INPUT_MODE_FULL);
256
257                 user_label = g_strdup_printf("%s*", _("mail_fi_username"));
258                 user_caption = modest_maemo_utils_create_captioned (size_group, user_label, 
259                                                                     ppriv->user_entry);
260                 g_free (user_label);
261         
262                 /* Prevent the use of some characters. Limit the max
263                    length as well */
264                 modest_validating_entry_set_unallowed_characters_whitespace (
265                      MODEST_VALIDATING_ENTRY (ppriv->user_entry));      
266                 gtk_entry_set_max_length (GTK_ENTRY (ppriv->user_entry), 64);
267                 modest_validating_entry_set_max_func (MODEST_VALIDATING_ENTRY (ppriv->user_entry),
268                                                       on_entry_max, self);
269                 
270                 /* Password widgets */
271                 ppriv->pwd_entry = gtk_entry_new ();
272
273                 /* Auto-capitalization is the default, so let's turn it off */
274                 hildon_gtk_entry_set_input_mode (GTK_ENTRY (ppriv->pwd_entry),
275                                                  HILDON_GTK_INPUT_MODE_FULL | 
276                                                  HILDON_GTK_INPUT_MODE_INVISIBLE);
277                 gtk_entry_set_visibility (GTK_ENTRY (ppriv->pwd_entry), FALSE);
278
279                 pwd_caption = modest_maemo_utils_create_captioned (size_group, _("mail_fi_password"), 
280                                                                    ppriv->pwd_entry);
281
282                 ppriv->port_view = GTK_WIDGET (hildon_number_editor_new (PORT_MIN, PORT_MAX));
283                 port_caption = modest_maemo_utils_create_captioned (size_group, _("mcen_fi_emailsetup_port"), 
284                                                                     ppriv->port_view);
285         }
286
287         /* Track changes in UI */       
288         g_signal_connect (G_OBJECT (ppriv->security_view), "value-changed",
289                           G_CALLBACK (on_security_changed), self);
290         if (ppriv->full) {
291                 g_signal_connect (G_OBJECT (ppriv->auth_view), "value-changed",
292                                   G_CALLBACK (on_auth_changed), self);
293                 g_signal_connect (G_OBJECT (ppriv->user_entry), "changed",
294                                   G_CALLBACK (on_entry_changed), self);
295         }
296
297         /* Initialize widgets */
298         modest_serversecurity_picker_set_active_serversecurity (
299                 MODEST_SERVERSECURITY_PICKER (ppriv->security_view), 
300                 MODEST_PROTOCOLS_CONNECTION_NONE);
301         modest_secureauth_picker_set_active_secureauth (
302            MODEST_SECUREAUTH_PICKER (ppriv->auth_view),
303            MODEST_PROTOCOLS_AUTH_NONE);
304
305         /* Pack into container */
306         if (ppriv->full) {
307                 gtk_box_pack_start (GTK_BOX (self), ppriv->auth_view, FALSE, FALSE, MODEST_MARGIN_HALF);
308                 gtk_box_pack_start (GTK_BOX (self), user_caption, FALSE, FALSE, MODEST_MARGIN_HALF);
309                 gtk_box_pack_start (GTK_BOX (self), pwd_caption, FALSE, FALSE, MODEST_MARGIN_HALF);
310                 gtk_box_pack_start (GTK_BOX (self), ppriv->security_view, FALSE, FALSE, MODEST_MARGIN_HALF);
311                 gtk_box_pack_start (GTK_BOX (self), port_caption, FALSE, FALSE, MODEST_MARGIN_HALF);
312         } else {
313                 /* The order is different */
314                 gtk_box_pack_start (GTK_BOX (self), ppriv->security_view, FALSE, FALSE, MODEST_MARGIN_HALF);
315                 gtk_box_pack_start (GTK_BOX (self), ppriv->auth_view, FALSE, FALSE, MODEST_MARGIN_HALF);
316         }
317
318         /* Show widgets */
319         if (ppriv->full) {
320                 gtk_widget_show (ppriv->pwd_entry);
321                 gtk_widget_show (ppriv->user_entry);
322                 gtk_widget_show (ppriv->port_view);
323                 gtk_widget_show (pwd_caption);
324                 gtk_widget_show (user_caption);
325                 gtk_widget_show (port_caption);
326         }
327         gtk_widget_show (ppriv->security_view);
328         gtk_widget_show (ppriv->auth_view);
329 }
330
331 GtkWidget *    
332 modest_maemo_security_options_view_new  (ModestSecurityOptionsType type,
333                                          gboolean full,
334                                          GtkSizeGroup *size_group)
335 {
336         ModestSecurityOptionsView* self;
337         ModestSecurityOptionsViewPrivate *ppriv;
338
339         self = (ModestSecurityOptionsView *)
340                 g_object_new (MODEST_TYPE_MAEMO_SECURITY_OPTIONS_VIEW, NULL);
341         ppriv = MODEST_SECURITY_OPTIONS_VIEW_GET_PRIVATE (self);
342
343         ppriv->full = full;
344         self->type = type;
345         if (self->type == MODEST_SECURITY_OPTIONS_INCOMING)
346                 create_incoming_security (self, size_group);
347         else
348                 create_outgoing_security (self, size_group);
349
350         return (GtkWidget *) self;
351 }
352
353 static void 
354 modest_maemo_security_options_view_load_settings (ModestSecurityOptionsView* self, 
355                                                   ModestAccountSettings *settings)
356 {
357         ModestSecurityOptionsViewPrivate *ppriv;
358         ModestServerAccountSettings *server_settings;
359         gint port_number;
360
361         ppriv = MODEST_SECURITY_OPTIONS_VIEW_GET_PRIVATE (self);
362
363         if (self->type == MODEST_SECURITY_OPTIONS_INCOMING)
364                 server_settings = modest_account_settings_get_store_settings (settings);
365         else
366                 server_settings = modest_account_settings_get_transport_settings (settings);
367         port_number = modest_server_account_settings_get_port (server_settings);
368
369         if (port_number == 0) {
370                 /* Show the appropriate port number */
371                 on_security_changed (ppriv->security_view, 
372                                      MODEST_MAEMO_SECURITY_OPTIONS_VIEW (self));
373         } else if (ppriv->full) {
374                 /* Keep the user-entered port-number, or the
375                  * already-appropriate automatic port number */
376                 hildon_number_editor_set_value (HILDON_NUMBER_EDITOR (ppriv->port_view), 
377                                                 port_number);
378         }
379         /* Frees */
380         g_object_unref (server_settings);
381 }
382
383 static void
384 modest_maemo_security_options_view_save_settings (ModestSecurityOptionsView* self, 
385                                                   ModestAccountSettings *settings)
386 {
387         ModestServerAccountSettings *server_settings;
388         ModestSecurityOptionsViewPrivate *ppriv;
389         gint server_port;
390
391         ppriv = MODEST_SECURITY_OPTIONS_VIEW_GET_PRIVATE (self);
392
393         if (self->type == MODEST_SECURITY_OPTIONS_INCOMING)
394                 server_settings = modest_account_settings_get_store_settings (settings);
395         else
396                 server_settings = modest_account_settings_get_transport_settings (settings);
397
398         if (ppriv->full) {
399                 server_port = hildon_number_editor_get_value (HILDON_NUMBER_EDITOR (ppriv->port_view));
400         } else {
401                 server_port = modest_serversecurity_picker_get_active_serversecurity_port (MODEST_SERVERSECURITY_PICKER (ppriv->security_view));
402         }
403
404         modest_server_account_settings_set_port (server_settings, server_port);
405
406         /* Frees */
407         g_object_unref (server_settings);
408 }
409
410 static gboolean 
411 modest_maemo_security_options_view_changed (ModestSecurityOptionsView* self,
412                                             ModestAccountSettings *settings)
413 {
414         ModestServerAccountSettings *server_settings;
415         ModestSecurityOptionsViewPrivate *ppriv;
416         gint server_port;
417
418         ppriv = MODEST_SECURITY_OPTIONS_VIEW_GET_PRIVATE (self);
419         
420         /* If we're not showing the port number then it never changes */
421         if (!ppriv->full)
422                 return FALSE;
423
424         if (self->type == MODEST_SECURITY_OPTIONS_INCOMING)
425                 server_settings = modest_account_settings_get_store_settings (settings);
426         else
427                 server_settings = modest_account_settings_get_transport_settings (settings);
428         
429         server_port = 
430                 hildon_number_editor_get_value (HILDON_NUMBER_EDITOR (ppriv->port_view));
431
432         /* Frees */
433         g_object_unref (server_settings);
434
435         if (server_port != ppriv->initial_state.port)
436                 return TRUE;
437         else
438                 return FALSE;
439 }
440
441 static void
442 modest_maemo_security_options_view_init (ModestMaemoSecurityOptionsView *obj)
443 {
444 }
445
446 static void
447 modest_maemo_security_options_view_finalize (GObject *obj)
448 {
449         G_OBJECT_CLASS (modest_maemo_security_options_view_parent_class)->finalize (obj);
450 }
451
452
453 static void     
454 modest_maemo_security_options_view_class_init (ModestMaemoSecurityOptionsViewClass *klass)
455 {
456         GObjectClass *gobject_class = (GObjectClass*) klass;
457
458         modest_maemo_security_options_view_parent_class = g_type_class_peek_parent (klass);
459
460         gobject_class->finalize = modest_maemo_security_options_view_finalize;
461
462         MODEST_SECURITY_OPTIONS_VIEW_CLASS (klass)->load_settings = 
463                 modest_maemo_security_options_view_load_settings;
464         MODEST_SECURITY_OPTIONS_VIEW_CLASS (klass)->save_settings = 
465                 modest_maemo_security_options_view_save_settings;
466         MODEST_SECURITY_OPTIONS_VIEW_CLASS (klass)->changed = 
467                 modest_maemo_security_options_view_changed;
468 }