vcs.maemo.org Git - hildon/blob - hildon/hildon-set-password-dialog.c

   1 /*
   2  * This file is a part of hildon
   3  *
   4  * Copyright (C) 2005, 2006, 2009 Nokia Corporation, all rights reserved.
   5  *
   6  * Contact: Rodrigo Novo <rodrigo.novo@nokia.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; version 2.1 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  */
  24
  25 /**
  26  * SECTION:hildon-set-password-dialog
  27  * @short_description: A dialog used to set, change or remove a password.
  28  * @see_also: #HildonGetPasswordDialog
  29  *
  30  * HildonSetPasswordDialog allows setting and changing a password.
  31  *
  32  * In Change mode: Dialog is used to change or remove an existing
  33  * password. Unselecting the check box dims the password fields below
  34  * it. If the dialog is accepted with 'OK' while the check box is
  35  * unselected, a Confirmation Note is shown.  If the Confirmation Note
  36  * Dialog is accepted with 'Remove', the password protection is removed.
  37  *
  38  * In Set mode: Set Password Dialog is used to define a password, or
  39  * change a password that cannot be removed.
  40  */
  41
  42 #undef                                          HILDON_DISABLE_DEPRECATED
  43
  44 #ifdef                                          HAVE_CONFIG_H
  45 #include                                        <config.h>
  46 #endif
  47
  48 #include                                        <errno.h>
  49 #include                                        <string.h>
  50 #include                                        <strings.h>
  51 #include                                        <unistd.h>
  52 #include                                        <stdio.h>
  53 #include                                        <libintl.h>
  54 #include                                        <glib.h>
  55 #include                                        <gdk/gdkkeysyms.h>
  56
  57 #include                                        "hildon-set-password-dialog.h"
  58 #include                                        "hildon-caption.h"
  59 #include                                        "hildon-note.h"
  60 #include                                        "hildon-defines.h"
  61 #include                                        "hildon-banner.h"
  62 #include                                        "hildon-set-password-dialog-private.h"
  63 #include                                        "hildon-entry.h"
  64 #include                                        "hildon-check-button.h"
  65
  66 #define                                         HILDON_SET_PASSWORD_DIALOG_TITLE "ecdg_ti_set_password"
  67
  68 #define                                         HILDON_SET_PASSWORD_DIALOG_PASSWORD "ecdg_fi_set_passwd_enter_pwd"
  69
  70 #define                                         HILDON_SET_PASSWORD_DIALOG_VERIFY_PASSWORD "ecdg_fi_set_passwd_confirm"
  71
  72 #define                                         HILDON_SET_PASSWORD_DIALOG_OK "wdgt_bd_done"
  73
  74 #define                                         HILDON_SET_PASSWORD_DIALOG_CANCEL "ecdg_bd_set_password_dialog_cancel"
  75
  76 #define                                         HILDON_SET_MODIFY_PASSWORD_DIALOG_TITLE "ckdg_ti_dialog_c_passwd_change_password"
  77
  78 #define                                         HILDON_SET_MODIFY_PASSWORD_DIALOG_LABEL "ckdg_fi_dialog_c_passwd_pwd_protect"
  79
  80 #define                                         HILDON_SET_MODIFY_PASSWORD_DIALOG_PASSWORD "ckdg_fi_dialog_c_passwd_new_pwd"
  81
  82 #define                                         HILDON_SET_MODIFY_PASSWORD_DIALOG_VERIFY_PASSWORD "ckdg_fi_dialog_c_passwd_ver_pwd"
  83
  84 #define                                         HILDON_SET_MODIFY_PASSWORD_DIALOG_OK "wdgt_bd_done"
  85
  86 #define                                         HILDON_SET_MODIFY_PASSWORD_DIALOG_CANCEL "ckdg_bd_change_password_dialog_cancel"
  87
  88 #define                                         HILDON_SET_PASSWORD_DIALOG_MISMATCH "ecdg_ib_passwords_do_not_match"
  89
  90 #define                                         HILDON_SET_PASSWORD_DIALOG_EMPTY "ecdg_ib_password_is_empty"
  91
  92 #define                                         HILDON_SET_PASSWORD_DIALOG_REMOVE_PROTECTION "ckdg_nc_dialog_c_passwd_remove_pwd"
  93
  94 #define                                         HILDON_REMOVE_PROTECTION_CONFIRMATION_REMOVE "ckdg_bd_dialog_c_passwd_remove_button"
  95
  96 #define                                         HILDON_REMOVE_PROTECTION_CONFIRMATION_CANCEL "ckdg_bd_dialog_c_passwd_cancel_button"
  97
  98 #define                                         _(String) dgettext("hildon-libs", String)
  99
 100 #define                                         c_(String) dgettext("hildon-common-strings", String)
 101
 102 static GtkDialogClass*                          parent_class;
 103
 104 static void
 105 hildon_set_password_dialog_class_init           (HildonSetPasswordDialogClass *class);
 106
 107 static void
 108 hildon_set_password_dialog_init                 (HildonSetPasswordDialog *dialog);
 109
 110 static void
 111 hildon_checkbox_toggled                         (GtkWidget *widget,
 112                                                  gpointer dialog);
 113
 114 static void
 115 hildon_set_password_response_change             (GtkDialog *d,
 116                                                  gint arg1,
 117                                                  gpointer unused);
 118
 119 static void
 120 hildon_set_password_response_set                (GtkDialog * d,
 121                                                  gint arg1,
 122                                                  gpointer unused);
 123
 124 static void
 125 create_contents                                 (HildonSetPasswordDialog *dialog);
 126
 127 static void
 128 hildon_set_password_set_property                (GObject *object,
 129                                                  guint prop_id,
 130                                                  const GValue *value,
 131                                                  GParamSpec *pspec);
 132
 133 static void
 134 hildon_set_password_get_property                (GObject *object,
 135                                                  guint prop_id,
 136                                                  GValue *value,
 137                                                  GParamSpec *pspec);
 138
 139 enum
 140 {
 141     PROP_0,
 142     PROP_MESSAGE,
 143     PROP_PASSWORD,
 144     PROP_HILDON_PASSWORD_DIALOG
 145 };
 146
 147 static void
 148 hildon_set_password_set_property                (GObject *object,
 149                                                  guint prop_id,
 150                                                  const GValue *value,
 151                                                  GParamSpec *pspec)
 152 {
 153     HildonSetPasswordDialog *dialog = HILDON_SET_PASSWORD_DIALOG (object);
 154     HildonSetPasswordDialogPrivate *priv;
 155
 156     priv = HILDON_SET_PASSWORD_DIALOG_GET_PRIVATE (dialog);
 157     g_assert (priv);
 158
 159     switch (prop_id) {
 160
 161         case PROP_MESSAGE:
 162             /* Update domain label to display new value */
 163             gtk_label_set_text (priv->message_label, g_value_get_string (value));
 164             break;
 165
 166         case PROP_PASSWORD:
 167             /* Update password entry to display new value */
 168             gtk_entry_set_text (GTK_ENTRY (priv->pwd1st_entry), g_value_get_string (value));
 169             break;
 170
 171         case PROP_HILDON_PASSWORD_DIALOG:
 172             /* Note this is a G_PARAM_CONSTRUCT_ONLY type property */
 173             priv->protection = g_value_get_boolean (value);
 174
 175             /* We now have the necessary information to populate the dialog */
 176             /* FIXME It looks kinda extremally bad that this is here...
 177              * what about situations where this prop is NOT set during
 178              * constructing? */
 179             create_contents (dialog);
 180             break;
 181
 182         default:
 183             G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 184             break;
 185     }
 186 }
 187
 188 static void
 189 hildon_set_password_get_property                (GObject *object,
 190                                                  guint prop_id,
 191                                                  GValue *value,
 192                                                  GParamSpec *pspec)
 193 {
 194     HildonSetPasswordDialogPrivate *priv = NULL;
 195
 196     priv = HILDON_SET_PASSWORD_DIALOG_GET_PRIVATE (object);
 197     g_assert (priv);
 198
 199     switch (prop_id) {
 200
 201         case PROP_MESSAGE:
 202             g_value_set_string (value, gtk_label_get_text (priv->message_label));
 203             break;
 204
 205         case PROP_PASSWORD:
 206             g_value_set_string (value,
 207                     gtk_entry_get_text (GTK_ENTRY (priv->pwd1st_entry)));
 208             break;
 209
 210         case PROP_HILDON_PASSWORD_DIALOG:
 211             g_value_set_boolean (value, priv->protection);
 212             break;
 213
 214         default:
 215             G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 216             break;
 217     }
 218 }
 219
 220
 221 static void
 222 create_contents                                 (HildonSetPasswordDialog *dialog)
 223 {
 224     HildonSetPasswordDialogPrivate *priv = NULL;
 225     AtkObject *atk_aux = NULL;
 226
 227     GtkSizeGroup *group;
 228
 229     priv = HILDON_SET_PASSWORD_DIALOG_GET_PRIVATE (dialog);
 230     g_assert (priv);
 231     priv->checkbox = NULL;
 232
 233     /* Size group for labels */
 234     group = GTK_SIZE_GROUP (gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL));
 235
 236     gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
 237
 238     /* Setup and pack domain label */
 239     priv->message_label = GTK_LABEL (gtk_label_new (NULL));
 240     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
 241             GTK_WIDGET(priv->message_label), FALSE, FALSE, 0);
 242     gtk_widget_show (GTK_WIDGET (priv->message_label));
 243
 244     if (priv->protection == TRUE) {
 245         /* Use Change Password Dialog strings */
 246         priv->pwd1st_caption_string = _(HILDON_SET_MODIFY_PASSWORD_DIALOG_PASSWORD);
 247         priv->pwd2nd_caption_string = _(HILDON_SET_MODIFY_PASSWORD_DIALOG_VERIFY_PASSWORD);
 248
 249         /* Setup checkbox to enable/disable password protection */
 250         priv->checkbox = hildon_check_button_new (HILDON_SIZE_AUTO_WIDTH | HILDON_SIZE_FINGER_HEIGHT);
 251         gtk_button_set_label (GTK_BUTTON (priv->checkbox), _(HILDON_SET_MODIFY_PASSWORD_DIALOG_LABEL));
 252         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
 253                 priv->checkbox, TRUE, TRUE, 0);
 254         gtk_widget_show (priv->checkbox);
 255         hildon_check_button_set_active (HILDON_CHECK_BUTTON (priv->checkbox),
 256                 TRUE);
 257         gtk_signal_connect (GTK_OBJECT (priv->checkbox), "toggled",
 258                 G_CALLBACK (hildon_checkbox_toggled), dialog);
 259
 260         /* Setup appropriate response handler */
 261         g_signal_connect (G_OBJECT (dialog), "response",
 262                 G_CALLBACK (hildon_set_password_response_change),
 263                 NULL);
 264     } else {
 265         /* Use Set Password Dialog strings */
 266         priv->pwd1st_caption_string = _(HILDON_SET_PASSWORD_DIALOG_PASSWORD);
 267         priv->pwd2nd_caption_string = _(HILDON_SET_PASSWORD_DIALOG_VERIFY_PASSWORD);
 268
 269         /* Setup appropriate response handler */
 270         g_signal_connect (G_OBJECT (dialog), "response",
 271                 G_CALLBACK(hildon_set_password_response_set),
 272                 NULL);
 273     }
 274
 275     /* Create the password field */
 276     priv->pwd1st_entry = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
 277     if ((atk_aux = gtk_widget_get_accessible(priv->pwd1st_entry)))
 278       {
 279         atk_object_set_name(atk_aux, "Old Passwd");
 280       }
 281
 282
 283 #ifdef MAEMO_GTK
 284     g_object_set (priv->pwd1st_entry, "hildon-input-mode", HILDON_GTK_INPUT_MODE_FULL, NULL);
 285 #endif
 286
 287     gtk_entry_set_visibility (GTK_ENTRY(priv->pwd1st_entry), FALSE);
 288     gtk_widget_show (priv->pwd1st_entry);
 289     priv->pwd1st_caption = hildon_caption_new (group,
 290             priv->pwd1st_caption_string,
 291             priv->pwd1st_entry,
 292             NULL, HILDON_CAPTION_OPTIONAL);
 293
 294     hildon_caption_set_separator (HILDON_CAPTION(priv->pwd1st_caption), "");
 295     gtk_entry_set_visibility (GTK_ENTRY (priv->pwd1st_entry), FALSE);
 296     gtk_box_pack_start (GTK_BOX(GTK_DIALOG (dialog)->vbox),
 297             priv->pwd1st_caption, TRUE, TRUE, 0);
 298     gtk_widget_show (priv->pwd1st_caption);
 299
 300     /* Create the password verify field */
 301     priv->pwd2nd_entry = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
 302     if ((atk_aux = gtk_widget_get_accessible(priv->pwd2nd_entry)))
 303       {
 304         atk_object_set_name(atk_aux, "New Passwd");
 305       }
 306
 307
 308 #ifdef MAEMO_GTK
 309     g_object_set (priv->pwd2nd_entry, "hildon-input-mode", HILDON_GTK_INPUT_MODE_FULL, NULL);
 310 #endif
 311
 312     gtk_widget_show (priv->pwd2nd_entry);
 313     priv->pwd2nd_caption = hildon_caption_new (group,
 314             priv->pwd2nd_caption_string,
 315             priv->pwd2nd_entry,
 316             NULL, HILDON_CAPTION_OPTIONAL);
 317     hildon_caption_set_separator (HILDON_CAPTION (priv->pwd2nd_caption), "");
 318     gtk_entry_set_visibility (GTK_ENTRY (priv->pwd2nd_entry), FALSE);
 319     gtk_box_pack_start (GTK_BOX(GTK_DIALOG (dialog)->vbox),
 320             priv->pwd2nd_caption, TRUE, TRUE, 0);
 321     gtk_widget_show (priv->pwd2nd_caption);
 322
 323     /* Set dialog title */
 324     gtk_window_set_title (GTK_WINDOW (dialog),
 325             _(priv->protection
 326                 ? HILDON_SET_MODIFY_PASSWORD_DIALOG_TITLE
 327                 : HILDON_SET_PASSWORD_DIALOG_TITLE));
 328
 329     /* Create the OK/CANCEL buttons */
 330     gtk_dialog_add_button (GTK_DIALOG (dialog),  _(priv->protection
 331                                 ? HILDON_SET_MODIFY_PASSWORD_DIALOG_OK
 332                                 : HILDON_SET_PASSWORD_DIALOG_OK), GTK_RESPONSE_OK);
 333
 334     gtk_widget_show_all (GTK_DIALOG (dialog)->vbox);
 335     gtk_widget_show_all (GTK_DIALOG (dialog)->action_area);
 336
 337     /* Ensure group is freed when all its contents have been removed */
 338     g_object_unref (group);
 339 }
 340
 341 static void
 342 hildon_set_password_dialog_class_init           (HildonSetPasswordDialogClass *class)
 343 {
 344     GObjectClass *object_class = G_OBJECT_CLASS (class);
 345
 346     parent_class = g_type_class_peek_parent (class);
 347
 348     /* Override virtual methods */
 349     object_class->set_property = hildon_set_password_set_property;
 350     object_class->get_property = hildon_set_password_get_property;
 351
 352     /* Install new properties */
 353     g_object_class_install_property (object_class,
 354             PROP_MESSAGE,
 355             g_param_spec_string ("message",
 356                 "Message",
 357                 "A message to display to the user",
 358                 NULL,
 359                 G_PARAM_READWRITE));
 360
 361     /**
 362      * HildonSetPasswordDialog:modify-protection:
 363      *
 364      * Password type.
 365      */
 366     g_object_class_install_property (object_class,
 367             PROP_HILDON_PASSWORD_DIALOG,
 368             g_param_spec_boolean ("modify-protection",
 369                 "Password type",
 370                 "Set type to dialog",
 371                 TRUE,
 372                 G_PARAM_CONSTRUCT_ONLY |
 373                 G_PARAM_READWRITE));
 374
 375     /**
 376      * HildonSetPasswordDialog:password:
 377      *
 378      * Content of the password field.
 379      */
 380     g_object_class_install_property (object_class,
 381             PROP_PASSWORD,
 382             g_param_spec_string ("password",
 383                 "Password content",
 384                 "Set content to dialog",
 385                 "DEFAULT",
 386                 G_PARAM_READWRITE));
 387
 388     /* Install private structure */
 389     g_type_class_add_private (class,
 390             sizeof (HildonSetPasswordDialogPrivate));
 391 }
 392
 393 static void
 394 hildon_set_password_dialog_init                 (HildonSetPasswordDialog *dialog)
 395 {
 396     /* Most of the initializations are done in create_contents()
 397        after the 'modify_protection' property has been set */
 398
 399     gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
 400 }
 401
 402
 403 /* We come here when response button is clicked and dialog
 404    is used to change existing password. */
 405 static void
 406 hildon_set_password_response_change             (GtkDialog *dialog,
 407                                                  gint arg1,
 408                                                  gpointer unused)
 409 {
 410     GtkEntry *pwd1st_entry;
 411     GtkEntry *pwd2nd_entry;
 412     gchar *text1;
 413     gchar *text2;
 414     HildonNote *note;
 415     gint i;
 416     HildonSetPasswordDialogPrivate *priv;
 417
 418     priv = HILDON_SET_PASSWORD_DIALOG_GET_PRIVATE (dialog);
 419     g_assert (priv);
 420
 421     /* Password and verification */
 422     pwd1st_entry = GTK_ENTRY (gtk_bin_get_child
 423             (GTK_BIN (priv->pwd1st_caption)));
 424     pwd2nd_entry = GTK_ENTRY (gtk_bin_get_child
 425             (GTK_BIN (priv->pwd2nd_caption)));
 426     text1 = GTK_ENTRY (pwd1st_entry)->text;
 427     text2 = GTK_ENTRY (pwd2nd_entry)->text;
 428
 429     /* User accepted the dialog */
 430     if (arg1 == GTK_RESPONSE_OK) {
 431         /* Is the checkbox marked, so password protection is still in use? */
 432         if (hildon_check_button_get_active (HILDON_CHECK_BUTTON (priv->checkbox))){
 433             /* Yes, Something is given as password as well? */
 434             if (text1[0] != '\0') {
 435                 if (strcmp (text1, text2) == 0) {
 436                     /* Passwords match, so accept change password */
 437                     priv->protection = TRUE;
 438
 439                 } else if (text2[0] == '\0') {
 440                     /* Second field is empty, so show error, but don't clear fields */
 441                     g_signal_stop_emission_by_name (G_OBJECT(dialog),
 442                             "response");
 443
 444                     hildon_banner_show_information (GTK_WIDGET (dialog), NULL,
 445                             c_(HILDON_SET_PASSWORD_DIALOG_MISMATCH));
 446
 447                     gtk_widget_grab_focus (GTK_WIDGET (pwd2nd_entry));
 448
 449                 } else {
 450                     /* Error: Passwords don't match, so start over */
 451                     g_signal_stop_emission_by_name (G_OBJECT(dialog),
 452                             "response");
 453
 454                     gtk_entry_set_text (GTK_ENTRY (pwd1st_entry), "");
 455                     gtk_entry_set_text (GTK_ENTRY (pwd2nd_entry), "");
 456
 457                     hildon_banner_show_information (GTK_WIDGET (dialog), NULL,
 458                             c_(HILDON_SET_PASSWORD_DIALOG_MISMATCH));
 459
 460                     gtk_widget_grab_focus (GTK_WIDGET (pwd1st_entry));
 461                 }
 462             } else {
 463                 /* No, the password is empty */
 464                 g_signal_stop_emission_by_name (G_OBJECT (dialog), "response");
 465
 466                 if (text2[0] == '\0') {
 467                     /* Error: Both fields are empty */
 468                     hildon_banner_show_information (GTK_WIDGET (dialog), NULL, c_(HILDON_SET_PASSWORD_DIALOG_EMPTY));
 469                 } else {
 470                     /* Error: Second field doesn't match
 471                        the empty first field, so start over */
 472                     hildon_banner_show_information (GTK_WIDGET (dialog), NULL, c_(HILDON_SET_PASSWORD_DIALOG_MISMATCH));
 473                     gtk_entry_set_text (GTK_ENTRY (pwd2nd_entry), "");
 474                 }
 475
 476                 gtk_widget_grab_focus (GTK_WIDGET (pwd1st_entry));
 477             }
 478         } else {
 479             /* No, user wants to remove password protection.
 480                Confirm remove password protection */
 481             note = HILDON_NOTE (hildon_note_new_confirmation
 482                     (GTK_WINDOW (dialog),
 483                      c_(HILDON_SET_PASSWORD_DIALOG_REMOVE_PROTECTION)));
 484
 485             hildon_note_set_button_texts
 486                 (HILDON_NOTE (note),
 487                  c_(HILDON_REMOVE_PROTECTION_CONFIRMATION_REMOVE),
 488                  c_(HILDON_REMOVE_PROTECTION_CONFIRMATION_CANCEL));
 489
 490             /* Display confirmation note */
 491             i = gtk_dialog_run (GTK_DIALOG (note));
 492
 493             gtk_widget_destroy (GTK_WIDGET (note));
 494
 495             if (i == GTK_RESPONSE_OK)
 496                 /* Remove password protection */
 497                 priv->protection = FALSE;
 498             else {
 499                 /* Remove password protection cancelled */
 500                 priv->protection = TRUE;
 501                 g_signal_stop_emission_by_name (G_OBJECT(dialog), "response");
 502             }
 503         }
 504
 505     } else {
 506         /* Watch out for fading boolean values */
 507         priv->protection = TRUE;
 508     }
 509 }
 510
 511 /* We come here when response button is clicked and dialog
 512    is used to set new password. */
 513 static void
 514 hildon_set_password_response_set                (GtkDialog *dialog,
 515                                                  gint arg1,
 516                                                  gpointer unused)
 517 {
 518     GtkEntry *pwd1st_entry;
 519     GtkEntry *pwd2nd_entry;
 520     gchar *text1;
 521     gchar *text2;
 522
 523     HildonSetPasswordDialogPrivate *priv;
 524
 525     priv = HILDON_SET_PASSWORD_DIALOG_GET_PRIVATE (dialog);
 526     g_assert (priv);
 527
 528     /* Password and confirmation */
 529     pwd1st_entry = GTK_ENTRY (gtk_bin_get_child
 530             (GTK_BIN (priv->pwd1st_caption)));
 531
 532     pwd2nd_entry = GTK_ENTRY (gtk_bin_get_child
 533             (GTK_BIN (priv->pwd2nd_caption)));
 534
 535     text1 = GTK_ENTRY (pwd1st_entry)->text;
 536     text2 = GTK_ENTRY (pwd2nd_entry)->text;
 537
 538     if (arg1 == GTK_RESPONSE_OK) {
 539         /* User provided something for password? */
 540         if (text1[0] != '\0') {
 541             if (strcmp (text1, text2) == 0) {
 542                 /* Passwords match, so accept set password */
 543                 priv->protection = TRUE;
 544
 545             } else if (text2[0] == '\0') {
 546                 /* Second field is empty, so show error,
 547                    but don't clear the fields */
 548                 g_signal_stop_emission_by_name (G_OBJECT(dialog), "response");
 549                 hildon_banner_show_information (GTK_WIDGET (dialog), NULL, c_(HILDON_SET_PASSWORD_DIALOG_MISMATCH));
 550
 551                 gtk_widget_grab_focus (GTK_WIDGET (priv->pwd2nd_entry));
 552
 553             } else {
 554                 /* Error: Passwords don't match, so start over */
 555                 g_signal_stop_emission_by_name (G_OBJECT(dialog), "response");
 556                 gtk_entry_set_text (GTK_ENTRY (pwd1st_entry), "");
 557                 gtk_entry_set_text (GTK_ENTRY (pwd2nd_entry), "");
 558                 hildon_banner_show_information (GTK_WIDGET (dialog), NULL, c_(HILDON_SET_PASSWORD_DIALOG_MISMATCH));
 559
 560                 gtk_widget_grab_focus (GTK_WIDGET (priv->pwd1st_entry));
 561             }
 562         } else {
 563             /* First field is empty */
 564             g_signal_stop_emission_by_name (G_OBJECT (dialog), "response");
 565             if (text2[0] == '\0') {
 566                 /* Error: Both fields are empty */
 567                 hildon_banner_show_information (GTK_WIDGET (dialog), NULL, c_(HILDON_SET_PASSWORD_DIALOG_EMPTY));
 568             } else {
 569                 /* Error: Second field doesn't match
 570                    the empty first field, so start over */
 571                 hildon_banner_show_information (GTK_WIDGET (dialog), NULL, c_(HILDON_SET_PASSWORD_DIALOG_MISMATCH));
 572                 gtk_entry_set_text (GTK_ENTRY (pwd2nd_entry), "");
 573             }
 574
 575             gtk_widget_grab_focus (GTK_WIDGET (pwd1st_entry));
 576         }
 577     } else {
 578         /* Watch out for fading boolean values */
 579         priv->protection = FALSE;
 580     }
 581 }
 582
 583 static void
 584 hildon_checkbox_toggled                         (GtkWidget *widget,
 585                                                  gpointer dialog)
 586 {
 587     HildonSetPasswordDialogPrivate *priv = HILDON_SET_PASSWORD_DIALOG_GET_PRIVATE (dialog);
 588     gboolean active;
 589
 590     g_assert (priv);
 591
 592     /* If the user enabled/disabled the password protection feature
 593        we enable/disable password entries accordingly */
 594     active = hildon_check_button_get_active (HILDON_CHECK_BUTTON (widget));
 595     gtk_widget_set_sensitive (GTK_WIDGET (priv->pwd1st_entry), active);
 596     gtk_widget_set_sensitive (GTK_WIDGET (priv->pwd2nd_entry), active);
 597 }
 598
 599 /**
 600  * hildon_set_password_dialog_get_type:
 601  *
 602  * Returns GType for HildonPasswordDialog as produced by
 603  * g_type_register_static().
 604  *
 605  * Returns: HildonSetPasswordDialog type
 606  */
 607 GType G_GNUC_CONST
 608 hildon_set_password_dialog_get_type             (void)
 609 {
 610     static GType dialog_type = 0;
 611
 612     if (! dialog_type) {
 613         static const GTypeInfo dialog_info = {
 614             sizeof (HildonSetPasswordDialogClass),
 615             NULL,       /* base_init */
 616             NULL,       /* base_finalize */
 617             (GClassInitFunc) hildon_set_password_dialog_class_init,
 618             NULL,       /* class_finalize */
 619             NULL,       /* class_data */
 620             sizeof (HildonSetPasswordDialog),
 621             0,  /* n_preallocs */
 622             (GInstanceInitFunc) hildon_set_password_dialog_init
 623         };
 624
 625         dialog_type = g_type_register_static (GTK_TYPE_DIALOG,
 626                 "HildonSetPasswordDialog",
 627                 &dialog_info, 0);
 628     }
 629
 630     return dialog_type;
 631 }
 632
 633 /**
 634  * hildon_set_password_dialog_new:
 635  * @parent: parent window; can be NULL
 636  * @modify_protection: TRUE creates a new change password dialog and FALSE
 637  *                     creates a new set password dialog
 638  *
 639  * Constructs a new HildonSetPasswordDialog.
 640  *
 641  * Returns: a new #GtkWidget of type HildonSetPasswordDialog
 642  */
 643 GtkWidget*
 644 hildon_set_password_dialog_new                  (GtkWindow *parent,
 645                                                  gboolean modify_protection)
 646 {
 647     return hildon_set_password_dialog_new_with_default (parent, "", modify_protection);
 648 }
 649
 650 /**
 651  * hildon_set_password_dialog_new_with_default:
 652  * @parent: parent window; can be NULL
 653  * @password: a default password to be shown in password field
 654  * @modify_protection: TRUE creates a new change password dialog and FALSE
 655  *                     creates a new set password dialog
 656  *
 657  * Same as #hildon_set_password_dialog_new, but with a default password
 658  * in password field.
 659  *
 660  * Returns: a new #GtkWidget of type HildonSetPasswordDialog
 661  */
 662
 663 GtkWidget*
 664 hildon_set_password_dialog_new_with_default     (GtkWindow *parent,
 665                                                  const gchar *password,
 666                                                  gboolean modify_protection)
 667 {
 668     GtkWidget *dialog = g_object_new (HILDON_TYPE_SET_PASSWORD_DIALOG,
 669             "modify_protection", modify_protection,
 670             "password", password, NULL);
 671
 672     if (parent != NULL) {
 673         gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
 674     }
 675
 676     return dialog;
 677 }
 678
 679 /**
 680  * hildon_set_password_dialog_get_password:
 681  * @dialog: pointer to HildonSetPasswordDialog
 682  *
 683  * Returns current password.
 684  *
 685  * Returns: changed password ( if the dialog is successfully
 686  * accepted with 'OK' ( and when the check box is 'ON' ( in Change Password
 687  * Dialog ))
 688  */
 689 const gchar*
 690 hildon_set_password_dialog_get_password         (HildonSetPasswordDialog *dialog)
 691 {
 692     HildonSetPasswordDialogPrivate *priv;
 693
 694     g_return_val_if_fail (HILDON_IS_SET_PASSWORD_DIALOG (dialog), NULL);
 695
 696     priv = HILDON_SET_PASSWORD_DIALOG_GET_PRIVATE (dialog);
 697     g_assert (priv);
 698
 699     return GTK_ENTRY (priv->pwd1st_entry)->text;
 700 }
 701
 702 /**
 703  * hildon_set_password_dialog_get_protected:
 704  * @dialog: pointer to HildonSetPasswordDialog
 705  *
 706  * Returns the protection mode.
 707  *
 708  * Returns: password protection mode ( TRUE when the protection is
 709  *               'ON' and FALSE when the protection is 'OFF' )
 710  */
 711 gboolean
 712 hildon_set_password_dialog_get_protected        (HildonSetPasswordDialog *dialog)
 713 {
 714     HildonSetPasswordDialogPrivate *priv;
 715
 716     g_return_val_if_fail (HILDON_IS_SET_PASSWORD_DIALOG (dialog), FALSE);
 717
 718     priv = HILDON_SET_PASSWORD_DIALOG_GET_PRIVATE (dialog);
 719     g_assert (priv);
 720
 721     return priv->protection;
 722 }
 723
 724 /**
 725  * hildon_set_password_dialog_set_message:
 726  * @dialog: the dialog
 727  * @message: the message or some other descriptive text to be set
 728  *
 729  * Sets the optional descriptive text.
 730  */
 731 void
 732 hildon_set_password_dialog_set_message          (HildonSetPasswordDialog *dialog,
 733                                                  const gchar *message)
 734 {
 735     HildonSetPasswordDialogPrivate *priv = NULL;
 736
 737     g_return_if_fail (HILDON_IS_SET_PASSWORD_DIALOG (dialog));
 738
 739     priv = HILDON_SET_PASSWORD_DIALOG_GET_PRIVATE (dialog);
 740     g_assert (priv);
 741
 742     gtk_label_set_text (priv->message_label, message);
 743 }