contentLister/src/gtkPincodeScreen.c Source File

00001 /*
00002  * This file is part of contentLister.
00003  *
00004  * contentLister is free software: you can redistribute it and/or modify
00005  * it under the terms of the GNU General Public License as published by
00006  * the Free Software Foundation, either version 2 of the License, or
00007  * (at your option) any later version.
00008  *
00009  * contentLister is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
00012  * GNU General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU General Public License
00015  * along with this program. If not, see <http://www.gnu.org/licenses/>.
00016  */
00017 
00051 // system includes
00052 #include <glib.h>
00053 #include <gdk/gdk.h>
00054 #include <gtk/gtk.h>
00055 #include <gdk/gdkkeysyms.h>
00056 
00057 // ereader library includes
00058 #include <liberdm/display.h>
00059 #include <liberdm/erdm.h>
00060 #include <libergtk/ergtk.h>
00061 #include <liberipc/eripctoolbar.h>
00062 #include <libermanifest/ermanifest.h>
00063 
00064 // local includes
00065 #include "contentListerLog.h"
00066 #include "system.h"
00067 #include "pincodeIdleTime.h"
00068 #include "gtkPincodeScreen.h"
00069 #include "displayUpdate.h"
00070 #include "erConnect.h"
00071 #include "control.h"
00072 #include "erbusy.h"
00073 #include "languages.h"
00074 
00075 #define PINCODE_UI_MIN_LENGTH 4
00076 #define PINCODE_UI_MAX_LENGTH 4
00077 
00078 static gint g_timeout_handler_id = 0;
00079 //
00080 // internally used routines forward declarations
00081 //
00082 // create widgets
00083 static void gtk_pincode_screen_class_init(GtkPincodeScreenClass * klass);
00084 static void gtk_pincode_screen_init(GtkPincodeScreen * screen);
00085 static GtkWidget *create_pincode_input_widget(GtkPincodeScreen * screen);
00086 static GtkWidget *create_pincode_message_widget(GtkPincodeScreen * screen);
00087 //
00088 static void gtk_pincode_screen_set_text(GtkPincodeScreen * screen);
00089 static void pincode_message_widget_set_text(GtkPincodeScreen * screen, gchar * text);
00090 static void gtk_pincode_screen_show_input_widget(GtkPincodeScreen * screen);
00091 static void gtk_pincode_screen_show_message_widget(GtkPincodeScreen * screen);
00092 // create pincode stars
00093 static GtkWidget *create_pincode_stars(GtkPincodeScreen * screen);
00094 static void destroy_pincode_stars(GtkPincodeScreen * screen);
00095 static void pincode_stars_append_number(pincodeStars * stars, gint number);
00096 static void pincode_stars_backspace(pincodeStars * stars);
00097 static gchar *pincode_stars_get_text(pincodeStars * stars);
00098 static gboolean pincode_stars_check_text(pincodeStars * stars);
00099 static void pincode_stars_reset(pincodeStars * stars);
00100 static gboolean delayed_on_changed(gpointer user_data);
00101 
00102 // gtkPincodeScreen signals
00103 static gboolean on_gtk_pincode_screen_expose_event(GtkPincodeScreen * screen,
00104                                                    GdkEventExpose * event, gpointer user_data);
00105 static gboolean on_gtk_pincode_screen_hide(GtkPincodeScreen * screen, gpointer user_data);
00106 static gboolean on_gtk_pincode_screen_button_press(GtkPincodeScreen * screen,
00107                                                    GdkEventButton * event, gpointer user_data);
00108 static gboolean on_gtk_pincode_motion_notify_event(GtkPincodeScreen * screen,
00109                                                    GdkEventMotion * event, gpointer user_data);
00110 static gboolean on_gtk_pincode_screen_button_release(GtkPincodeScreen *
00111                                                      screen, GdkEventButton * event, gpointer user_data);
00112 static gboolean on_gtk_pincode_screen_key_press(GtkPincodeScreen * screen, GdkEventKey * event, gpointer user_data);
00113 static gboolean on_gtk_pincode_screen_key_release(GtkPincodeScreen * screen, GdkEventKey * event, gpointer user_data);
00114 static gboolean on_gtk_pincode_screen_destroy(GtkPincodeScreen * screen, GdkEvent * event, gpointer user_data);
00115 // keyboard signals
00116 static gboolean on_gtk_pincode_keyboard_button_press(GtkWidget * keyboard, GdkEventButton * event, gpointer user_data);
00117 static gint get_clicked_number(gint x, gint y);
00118 // confirmButton signals
00119 static void on_confirm_button_toggled(GtkToggleButton * button, gpointer screen);
00120 static gboolean delayed_on_confirm_button_clicked(gpointer user_data);
00121 static gboolean pincode_shutdown(gpointer user_data);
00122 static gboolean pincode_passed(gpointer user_data);
00123 static gboolean pincode_decrease_display_level(gpointer data);
00124 // messageWidget signals
00125 static gboolean on_message_widget_clicked_event(GtkWidget * widget, GdkEventButton * event, gpointer user_data);
00126 
00127 //
00128 // create a gtkPincodeScreen object
00129 // 
00130 GtkWidget *gtk_pincode_screen_new()
00131 {
00132     GtkPincodeScreen *screen;
00133     screen = (GtkPincodeScreen *) g_object_new(GTK_PINCODE_SCREEN_TYPE, NULL);
00134     return GTK_WIDGET(screen);
00135 }
00136 
00137 GType gtk_pincode_screen_get_type(void)
00138 {
00139     static GType pincode_screen_type = 0;
00140 
00141     if (!pincode_screen_type)
00142     {
00143         static const GTypeInfo pincode_screen_info = {
00144             sizeof(GtkPincodeScreenClass),
00145             NULL,               /* base_init */
00146             NULL,               /* base_finalize */
00147             (GClassInitFunc) gtk_pincode_screen_class_init,
00148             NULL,               /* class_finalize */
00149             NULL,               /* class_data */
00150             sizeof(GtkPincodeScreen),
00151             0,                  /* n_preallocs */
00152             (GInstanceInitFunc) gtk_pincode_screen_init,
00153         };
00154         pincode_screen_type = g_type_register_static(GTK_TYPE_EVENT_BOX, "PincodeScreen", &pincode_screen_info, 0);
00155     }
00156     return pincode_screen_type;
00157 }
00158 
00159 //
00160 // create gtkPincodeScreen - set the default values 
00161 //
00162 // object hierarchy:
00163 // screen (GtkPincodeScreen background)
00164 //    |--alignment
00165 //       |--clientArea(GtkVBox)
00166 //          |--inputWidget
00167 //          |--messageWidget
00168 // 
00169 static void gtk_pincode_screen_init(GtkPincodeScreen * screen)
00170 {
00171     GtkWidget *alignment;
00172     GtkWidget *clientArea;      // GtkVBox
00173     GtkWidget *inputWidget;     // input widget
00174     GtkWidget *messageWidget;   // message widget
00175     gboolean enable = FALSE;
00176     gchar pincode[PINCODE_MAX_LENGTH + 1] = "";
00177 
00178     if (NULL == screen)
00179         return;
00180     gtk_widget_set_name(GTK_WIDGET(screen), "pincode_screen_background");
00181     gtk_widget_set_size_request(GTK_WIDGET(screen), PINCODE_SCREEN_WIDTH, PINCODE_SCREEN_HEIGHT);
00182     // alignment 
00183     alignment = gtk_alignment_new(0.0, 0.0, 0.0, 0.0);
00184     gtk_container_add(GTK_CONTAINER(screen), GTK_WIDGET(alignment));
00185     gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
00186                               PINCODE_SCREEN_PADDING_TOP,
00187                               PINCODE_SCREEN_PADDING_BOTTOM, PINCODE_SCREEN_PADDING_LEFT, PINCODE_SCREEN_PADDING_RIGHT);
00188     // clientArea
00189     clientArea = gtk_vbox_new(FALSE, 0);
00190     gtk_container_add(GTK_CONTAINER(alignment), clientArea);
00191     // inputWidget
00192     inputWidget = create_pincode_input_widget(screen);
00193     gtk_box_pack_start(GTK_BOX(clientArea), GTK_WIDGET(inputWidget), FALSE, FALSE, 0);
00194     // messageWidget
00195     messageWidget = create_pincode_message_widget(screen);
00196     gtk_box_pack_start(GTK_BOX(clientArea), GTK_WIDGET(messageWidget), FALSE, FALSE, 0);
00197     // signals 
00198     g_signal_connect(G_OBJECT(screen), "expose_event", G_CALLBACK(on_gtk_pincode_screen_expose_event), NULL);
00199     g_signal_connect(G_OBJECT(screen), "hide", G_CALLBACK(on_gtk_pincode_screen_hide), NULL);
00200     g_signal_connect(G_OBJECT(screen), "button-press-event", G_CALLBACK(on_gtk_pincode_screen_button_press), NULL);
00201     g_signal_connect(G_OBJECT(screen), "motion_notify_event", G_CALLBACK(on_gtk_pincode_motion_notify_event), NULL);
00202     g_signal_connect(G_OBJECT(screen), "button-release-event", G_CALLBACK(on_gtk_pincode_screen_button_release), NULL);
00203     g_signal_connect(G_OBJECT(screen), "key_press_event", G_CALLBACK(on_gtk_pincode_screen_key_press), NULL);
00204     g_signal_connect(G_OBJECT(screen), "key_release_event", G_CALLBACK(on_gtk_pincode_screen_key_release), NULL);
00205     g_signal_connect(G_OBJECT(screen), "destroy", G_CALLBACK(on_gtk_pincode_screen_destroy), NULL);
00206     // set gtkPincodeScreen default values
00207     screen->clientArea = clientArea;
00208     screen->inputWidget = inputWidget;
00209     screen->messageWidget = messageWidget;
00210     screen->tryTimes = 0;
00211     screen->passed = FALSE;
00212     screen->isVisible = FALSE;
00213     // store 'enable' and 'pincode' to gtkPincodeScreen
00214     screen->pincodeOn = enable;
00215     strcpy(screen->pincode, pincode);
00216     // 
00217     gtk_pincode_screen_set_text(screen);
00218     // show widget 
00219     gtk_widget_show(GTK_WIDGET(clientArea));
00220     gtk_widget_show(GTK_WIDGET(alignment));
00221     gtk_pincode_screen_show_input_widget(screen);
00222 //  add timeout in order to compute user idle time later
00223 //  accumulate_idle_time_begin();
00224 }
00225 
00226 //
00227 // init class
00228 //
00229 static void gtk_pincode_screen_class_init(GtkPincodeScreenClass * klass)
00230 {
00231     // nothing needs to be done here 
00232 }
00233 
00234 //
00235 // create input pincode widget
00236 //
00237 // object hierarchy:
00238 // |--box(GtkEventBox background)
00239 //    |--fixed(GtkFixed)
00240 //       |--inputLabel
00241 //       |--starsWidget
00242 //       |--keyboard(GtkEventBox)
00243 //       |--confirmButton(GtkToggleButton)
00244 //       |--inputInfoLabel
00245 // 
00246 static GtkWidget *create_pincode_input_widget(GtkPincodeScreen * screen)
00247 {
00248     GtkWidget *box;
00249     GtkWidget *fixed;
00250     GtkWidget *inputLabel;
00251     GtkWidget *starsWidget;
00252     GtkWidget *keyboard;
00253     GtkWidget *confirmButton;
00254     GtkWidget *inputInfoLabel;
00255     // box
00256     box = gtk_event_box_new();
00257     gtk_widget_set_name(box, "pincode_input_background");
00258     gtk_widget_set_size_request(box, PINCODE_BACKGROUND_WIDTH, PINCODE_BACKGROUND_HEIGHT);
00259     // fixed
00260     fixed = gtk_fixed_new();
00261     gtk_container_add(GTK_CONTAINER(box), fixed);
00262     // inputLabel
00263     inputLabel = gtk_label_new("");
00264     gtk_fixed_put(GTK_FIXED(fixed), inputLabel, PINCODE_INPUT_LABEL_XPOS, PINCODE_INPUT_LABEL_YPOS);
00265     gtk_widget_set_name(inputLabel, "pincode_input_title_text");
00266     gtk_widget_set_size_request(inputLabel, PINCODE_INPUT_LABEL_WIDTH, PINCODE_INPUT_LABEL_HEIGHT);
00267     gtk_label_set_justify(GTK_LABEL(inputLabel), GTK_JUSTIFY_CENTER);
00268     // starsWidget
00269     starsWidget = create_pincode_stars(screen);
00270     gtk_fixed_put(GTK_FIXED(fixed), starsWidget, PINCODE_STARS_XPOS, PINCODE_STARS_YPOS);
00271     // keyboard
00272     keyboard = gtk_event_box_new();
00273     gtk_fixed_put(GTK_FIXED(fixed), keyboard, PINCODE_KEYBOARD_XPOS, PINCODE_KEYBOARD_YPOS);
00274     gtk_widget_set_name(keyboard, "pincode_keyboard_background");
00275     gtk_widget_set_size_request(GTK_WIDGET(keyboard), PINCODE_KEYBOARD_WIDTH, PINCODE_KEYBOARD_HEIGHT);
00276     // confirmButton
00277     confirmButton = ergtk_toggle_button_new();
00278     gtk_widget_set_name(confirmButton, "pincode_confirm");
00279     gtk_fixed_put(GTK_FIXED(fixed), confirmButton, PINCODE_BUTTON_XPOS, PINCODE_BUTTON_YPOS);
00280     gtk_widget_set_size_request(confirmButton, PINCODE_BUTTON_WIDTH, PINCODE_BUTTON_HEIGHT);
00281     // inputInfoLabel  
00282     inputInfoLabel = gtk_label_new("");
00283     gtk_fixed_put(GTK_FIXED(fixed), inputInfoLabel, PINCODE_INFO_LABEL_XPOS, PINCODE_INFO_LABEL_YPOS);
00284     gtk_widget_set_name(inputInfoLabel, "pincode_screen_info_text");
00285     gtk_widget_set_size_request(GTK_WIDGET(inputInfoLabel), PINCODE_INFO_LABEL_WIDTH, PINCODE_INFO_LABEL_HEIGHT);
00286     gtk_label_set_justify(GTK_LABEL(inputInfoLabel), GTK_JUSTIFY_CENTER);
00287     // set screen values
00288     screen->inputLabel = inputLabel;
00289     screen->keyboard = keyboard;
00290     screen->confirmButton = confirmButton;
00291     screen->inputInfoLabel = inputInfoLabel;
00292     // keyboard signals 
00293     g_signal_connect(G_OBJECT(keyboard), "button-press-event",
00294                      G_CALLBACK(on_gtk_pincode_keyboard_button_press), screen);
00295     // confirmButton signals
00296     g_signal_connect(G_OBJECT(confirmButton), "toggled", G_CALLBACK(on_confirm_button_toggled), screen);
00297     // show widgets
00298     gtk_widget_show(fixed);
00299     gtk_widget_show(inputLabel);
00300     gtk_widget_show(starsWidget);
00301     gtk_widget_show(keyboard);
00302     gtk_widget_show(confirmButton);
00303     gtk_widget_show(inputInfoLabel);
00304 
00305     return box;
00306 }
00307 
00308 // 
00309 // screen
00310 //   |--box(GtkEventBox background)
00311 //      |--vbox
00312 //         |--messageLabel
00313 //         |--infoLabel
00314 // 
00315 static GtkWidget *create_pincode_message_widget(GtkPincodeScreen * screen)
00316 {
00317     GtkWidget *box;
00318     GtkWidget *vbox;
00319     GtkWidget *messageLabel;
00320     GtkWidget *messageInfoLabel;
00321     // box
00322     box = gtk_event_box_new();
00323     gtk_widget_set_name(box, "pincode_message_background");
00324     gtk_widget_set_size_request(box, PINCODE_BACKGROUND_WIDTH, PINCODE_BACKGROUND_HEIGHT);
00325     // vbox
00326     vbox = gtk_vbox_new(FALSE, 0);
00327     gtk_container_add(GTK_CONTAINER(box), vbox);
00328     // messageLabel 
00329     messageLabel = gtk_label_new("");
00330     gtk_box_pack_start(GTK_BOX(vbox), messageLabel, FALSE, FALSE, 0);
00331     gtk_widget_set_name(messageLabel, "pincode_message_title_text");
00332     gtk_label_set_line_wrap(GTK_LABEL(messageLabel), TRUE);
00333     gtk_widget_set_size_request(messageLabel, PINCODE_MESSAGE_LABEL_WIDTH, PINCODE_MESSAGE_LABEL_HEIGHT);
00334     gtk_label_set_justify(GTK_LABEL(messageLabel), GTK_JUSTIFY_CENTER);
00335     // messageInfoLabel
00336     messageInfoLabel = gtk_label_new("");
00337     gtk_box_pack_start(GTK_BOX(vbox), messageInfoLabel, FALSE, FALSE, 0);
00338     gtk_widget_set_name(messageInfoLabel, "pincode_screen_info_text");
00339     gtk_widget_set_size_request(GTK_WIDGET(messageInfoLabel), PINCODE_INFO_LABEL_WIDTH, PINCODE_INFO_LABEL_HEIGHT);
00340     gtk_label_set_justify(GTK_LABEL(messageInfoLabel), GTK_JUSTIFY_CENTER);
00341     // signals 
00342     g_signal_connect(G_OBJECT(box), "button-press-event", G_CALLBACK(on_message_widget_clicked_event), screen);
00343     // set screen values
00344     screen->messageLabel = messageLabel;
00345     screen->messageInfoLabel = messageInfoLabel;
00346     // show widgets
00347     gtk_widget_show_all(vbox);
00348 
00349     return box;
00350 }
00351 
00352 //
00353 // widgets display text string
00354 //
00355 static void gtk_pincode_screen_set_text(GtkPincodeScreen * screen)
00356 {
00357     CL_LOGPRINTF("entry");
00358     g_return_if_fail(NULL != screen);
00359     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00360     if (screen->inputLabel)
00361     {
00362         gtk_label_set_text(GTK_LABEL(screen->inputLabel), _("Enter your PIN code"));
00363     }
00364     if (screen->confirmButton)
00365     {
00366         gtk_button_set_label(GTK_BUTTON(screen->confirmButton), _("Confirm"));
00367     }
00368     if (screen->inputInfoLabel)
00369     {
00370         gtk_label_set_text(GTK_LABEL(screen->inputInfoLabel),
00371                            _("Forgot your PIN code? Please visit your MyiRex account."));
00372     }
00373     if (screen->messageInfoLabel)
00374     {
00375         gtk_label_set_text(GTK_LABEL(screen->messageInfoLabel),
00376                            _("Forgot your PIN code? Please visit your MyiRex account."));
00377     }
00378 }
00379 
00380 static void pincode_message_widget_set_text(GtkPincodeScreen * screen, gchar * text)
00381 {
00382     g_return_if_fail(NULL != screen);
00383     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00384     g_return_if_fail(NULL != screen->messageLabel);
00385     g_return_if_fail(NULL != text);
00386     gtk_label_set_text(GTK_LABEL(screen->messageLabel), text);
00387 }
00388 
00389 //
00390 // show input widget, hide message widget
00391 //
00392 static void gtk_pincode_screen_show_input_widget(GtkPincodeScreen * screen)
00393 {
00394     GtkWidget *clientArea = NULL;
00395     GtkWidget *inputWidget = NULL;
00396     GtkWidget *messageWidget = NULL;
00397 
00398     gboolean show = FALSE;
00399 
00400     g_return_if_fail(NULL != screen);
00401     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00402 
00403     clientArea = GTK_PINCODE_SCREEN(screen)->clientArea;
00404     messageWidget = GTK_PINCODE_SCREEN(screen)->messageWidget;
00405     inputWidget = GTK_PINCODE_SCREEN(screen)->inputWidget;
00406 
00407     g_return_if_fail(NULL != clientArea);
00408     g_return_if_fail(NULL != inputWidget);
00409     g_return_if_fail(NULL != messageWidget);
00410 
00411     show = GTK_WIDGET_VISIBLE(inputWidget);
00412     if (TRUE == show)
00413     {
00414         return;
00415     }
00416 
00417     gtk_widget_hide(messageWidget);
00418     gtk_widget_show(inputWidget);
00419 
00420     gtk_widget_grab_focus(GTK_WIDGET(inputWidget));
00421 }
00422 
00423 //
00424 // hide input widget, show message widget
00425 //
00426 static void gtk_pincode_screen_show_message_widget(GtkPincodeScreen * screen)
00427 {
00428     GtkWidget *clientArea = NULL;
00429     GtkWidget *inputWidget = NULL;
00430     GtkWidget *messageWidget = NULL;
00431     gboolean show = FALSE;
00432 
00433     g_return_if_fail(NULL != screen);
00434     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00435 
00436     clientArea = GTK_PINCODE_SCREEN(screen)->clientArea;
00437     messageWidget = GTK_PINCODE_SCREEN(screen)->messageWidget;
00438     inputWidget = GTK_PINCODE_SCREEN(screen)->inputWidget;
00439 
00440     g_return_if_fail(NULL != clientArea);
00441     g_return_if_fail(NULL != inputWidget);
00442     g_return_if_fail(NULL != messageWidget);
00443 
00444     show = GTK_WIDGET_VISIBLE(messageWidget);
00445     if (TRUE == show)
00446     {
00447         return;
00448     }
00449 
00450     gtk_widget_hide(inputWidget);
00451     gtk_widget_show(messageWidget);
00452 
00453     gtk_widget_grab_focus(GTK_WIDGET(GTK_PINCODE_SCREEN(screen)->messageWidget));
00454 }
00455 
00456 static void gtk_pincode_show_message_info_label(GtkPincodeScreen * screen, gboolean show)
00457 {
00458     GtkWidget *messageInfoLabel = NULL;
00459     gboolean visible = FALSE;
00460 
00461     g_return_if_fail(NULL != screen);
00462     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00463 
00464     messageInfoLabel = GTK_PINCODE_SCREEN(screen)->messageInfoLabel;
00465     g_return_if_fail(NULL != messageInfoLabel);
00466 
00467     visible = GTK_WIDGET_VISIBLE(messageInfoLabel);
00468     if (show == visible)
00469     {
00470         return;
00471     }
00472     if (TRUE == show)
00473     {
00474         gtk_widget_show(messageInfoLabel);
00475     }
00476     else
00477     {
00478         gtk_widget_hide(messageInfoLabel);
00479     }
00480 }
00481 
00482 void gtk_pincode_screen_layout_reset(GtkWidget*screen)
00483 {
00484     g_return_if_fail(NULL != screen);
00485     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00486     
00487     gtk_pincode_screen_set_text(GTK_PINCODE_SCREEN(screen));
00488     pincode_stars_reset(GTK_PINCODE_SCREEN(screen)->stars);
00489     gtk_pincode_screen_show_input_widget(GTK_PINCODE_SCREEN(screen));
00490     gtk_pincode_show_message_info_label(GTK_PINCODE_SCREEN(screen), TRUE);
00491 }
00492 
00493 void gtk_pincode_screen_data_reset(GtkWidget * screen)
00494 {
00495     g_return_if_fail(NULL != screen);
00496     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00497 
00498 //    GTK_PINCODE_SCREEN(screen)->tryTimes = 0;// remove to- only pincode passed, reset tryTimes
00499     GTK_PINCODE_SCREEN(screen)->passed = 0;
00500 }
00501 
00502 void gtk_pincode_screen_set_pincode_settings(GtkWidget * screen, gboolean on, const gchar * pincode)
00503 {
00504     g_return_if_fail(NULL != screen && NULL != pincode);
00505     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00506 
00507     GTK_PINCODE_SCREEN(screen)->pincodeOn = on;
00508     strcpy(GTK_PINCODE_SCREEN(screen)->pincode, pincode);
00509 }
00510 
00511 void gtk_pincode_screen_get_pincode_settings(GtkWidget * screen, gboolean * on, gchar * pincode)
00512 {
00513     g_return_if_fail(NULL != screen && NULL != on && NULL != pincode);
00514     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00515 
00516     *on = GTK_PINCODE_SCREEN(screen)->pincodeOn;
00517     strcpy(pincode, GTK_PINCODE_SCREEN(screen)->pincode);
00518 }
00519 
00520 void gtk_pincode_screen_set_reason(GtkWidget * screen, showPincodeReason_t reason)
00521 {
00522     g_return_if_fail(NULL != screen);
00523     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00524 
00525     GTK_PINCODE_SCREEN(screen)->reason = reason;
00526 }
00527 
00528 showPincodeReason_t gtk_pincode_screen_get_reason(GtkWidget * screen)
00529 {
00530     showPincodeReason_t reason = undefinedReason_t;
00531     if (NULL == screen)
00532         return reason;
00533     if (!IS_GTK_PINCODE_SCREEN(screen))
00534         return reason;
00535 
00536     return GTK_PINCODE_SCREEN(screen)->reason;
00537 }
00538 
00539 void gtk_pincode_screen_set_on_cancel_callback(GtkWidget * screen, on_cancel_callback_t * func)
00540 {
00541     g_return_if_fail(NULL != screen);
00542     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00543 
00544     GTK_PINCODE_SCREEN(screen)->on_cancel_callback = func;
00545 }
00546 
00547 void gtk_pincode_screen_on_cancel_callback(GtkWidget * screen)
00548 {
00549     g_return_if_fail(NULL != screen);
00550     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00551     if (GTK_PINCODE_SCREEN(screen)->on_cancel_callback)
00552     {
00553         GTK_PINCODE_SCREEN(screen)->on_cancel_callback();
00554     }
00555 }
00556 
00557 void gtk_pincode_screen_set_on_passed_callback(GtkWidget * screen, on_passed_callback_t * func)
00558 {
00559     g_return_if_fail(NULL != screen);
00560     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00561 
00562     GTK_PINCODE_SCREEN(screen)->on_passed_callback = func;
00563 }
00564 //
00565 // pincode screen signals callback functions
00566 //
00567 static gboolean
00568 on_gtk_pincode_screen_expose_event(GtkPincodeScreen * screen, GdkEventExpose * event, gpointer user_data)
00569 {
00570     // ignore partial exposure events
00571     if ( !screen->isVisible )
00572     {
00573         screen->isVisible = TRUE;
00574         display_update_request_screen_refresh(MAIN_WINDOW_EXPOSE_LEVEL);
00575     }
00576     return FALSE;
00577 }
00578 
00579 static gboolean
00580 on_gtk_pincode_screen_hide(GtkPincodeScreen * screen, gpointer user_data)
00581 {
00582     screen->isVisible = FALSE;
00583     return FALSE;
00584 }
00585 
00586 static gboolean
00587 on_gtk_pincode_screen_button_press(GtkPincodeScreen * screen, GdkEventButton * event, gpointer user_data)
00588 {
00589     accumulate_idle_time_reset();
00590     return FALSE;
00591 }
00592 
00593 static gboolean
00594 on_gtk_pincode_motion_notify_event(GtkPincodeScreen * screen, GdkEventMotion * event, gpointer user_data)
00595 {
00596     accumulate_idle_time_reset();
00597     return FALSE;
00598 }
00599 
00600 static gboolean
00601 on_gtk_pincode_screen_button_release(GtkPincodeScreen * screen, GdkEventButton * event, gpointer user_data)
00602 {
00603     accumulate_idle_time_reset();
00604     return FALSE;
00605 }
00606 
00607 static gboolean on_gtk_pincode_screen_key_press(GtkPincodeScreen * screen, GdkEventKey * event, gpointer user_data)
00608 {
00609     accumulate_idle_time_reset();
00610     return FALSE;
00611 }
00612 
00613 static gboolean on_gtk_pincode_screen_key_release(GtkPincodeScreen * screen, GdkEventKey * event, gpointer user_data)
00614 {
00615     accumulate_idle_time_reset();
00616     return FALSE;
00617 }
00618 
00619 static gboolean on_gtk_pincode_screen_destroy(GtkPincodeScreen * screen, GdkEvent * event, gpointer user_data)
00620 {
00621     accumulate_idle_time_end();
00622     destroy_pincode_stars(screen);
00623     return FALSE;
00624 }
00625 
00626 //
00627 // keyboard signals
00628 //
00629 static gboolean on_gtk_pincode_keyboard_button_press(GtkWidget * button, GdkEventButton * event, gpointer user_data)
00630 {
00631     GtkPincodeScreen *screen = user_data;
00632     gint xPos = 0;
00633     gint yPos = 0;
00634     gint number;
00635 
00636     if (NULL == screen)
00637         return FALSE;
00638     if (!IS_GTK_PINCODE_SCREEN(screen))
00639         return FALSE;
00640     if (event->type != GDK_BUTTON_PRESS)
00641     {
00642         CL_ERRORPRINTF("event->type(%d)",event->type);
00643         return FALSE;
00644     }
00645     xPos = event->x;
00646     yPos = event->y;
00647     number = get_clicked_number(xPos, yPos);
00648     if (number >= 0 && number <= 9)
00649     {
00650         pincode_stars_append_number(screen->stars, number);
00651     }
00652     else if (-1 == number)
00653     {
00654         pincode_stars_backspace(screen->stars);
00655     }
00656     return FALSE;
00657 }
00658 
00659 // 
00660 // return 0-9
00661 // return -1 means backspace
00662 // return other means invalid  
00663 // 
00664 gint get_clicked_number(gint x, gint y)
00665 {
00666     int i, numbers, w, h;
00667     int spacing, leftPadding, rightPadding, topPadding, bottomPadding;
00668     int rcL, rcR, rcT, rcB;
00669     int returnVal = -2;
00670 
00671     numbers = 11;
00672     w = 35;
00673     h = 35;
00674     spacing = 4;
00675     leftPadding = 9;
00676     rightPadding = 9;
00677     topPadding = 7;
00678     bottomPadding = 7;
00679 
00680     if (x >= 0 && x <= PINCODE_KEYBOARD_WIDTH && y >= 0 && y <= PINCODE_KEYBOARD_HEIGHT)
00681     {
00682         rcT = topPadding;
00683         rcB = rcT + h;
00684         i = 0;
00685         for (i = 0; i <= numbers; i++)
00686         {
00687             if (0 == i)         // zero
00688             {
00689                 rcL = leftPadding;
00690                 rcR = rcL + w;
00691             }
00692             else if (10 == i)   // backspace
00693             {
00694                 rcR = PINCODE_KEYBOARD_WIDTH - rightPadding;
00695                 rcL = rcR - w;
00696             }
00697             else
00698             {
00699                 rcL = leftPadding + i * (w + spacing);
00700                 rcR = rcL + w;
00701             }
00702             if (x >= rcL && x <= rcR && y >= rcT && y <= rcB)
00703             {
00704                 returnVal = i + 1;
00705                 if (10 == returnVal)
00706                     returnVal = 0;
00707                 else if (11 == returnVal)
00708                     returnVal = -1;
00709                 break;
00710             }
00711         }                       // for
00712     }
00713     return returnVal;
00714 }
00715 
00716 //
00717 // confirmButton signals handlers
00718 //
00719 
00720 // confirm button selected
00721 static void on_confirm_button_toggled(GtkToggleButton * button, gpointer screen)
00722 {
00723     g_return_if_fail(NULL != screen);
00724     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
00725     pincodeStars *stars = (pincodeStars *) (GTK_PINCODE_SCREEN(screen)->stars);
00726     g_return_if_fail(NULL != stars);
00727 
00728     gboolean active = gtk_toggle_button_get_active(button);
00729     if (active)
00730     {
00731         g_timeout_add(1000, delayed_on_confirm_button_clicked, screen);
00732     }
00733 }
00734 
00735 static gboolean delayed_on_confirm_button_clicked(gpointer user_data)
00736 {
00737     GtkPincodeScreen *screen = user_data;
00738     GtkWidget *button = screen->confirmButton;
00739     const gchar *text = NULL;
00740     gboolean check = FALSE;
00741 
00742     erbusy_blink();
00743 
00744     //  check pincode
00745     if (screen->stars)
00746     {
00747         screen->tryTimes++;
00748         // for signing document, we don't check pincode onoff flag
00749         if (   (signDocument_t != screen->reason && FALSE == screen->pincodeOn)
00750             || (0 == strlen(screen->pincode)) )
00751         {
00752             check = TRUE;
00753         }
00754         else
00755         {
00756             check = pincode_stars_check_text(screen->stars);
00757         }
00758         if (FALSE == check)
00759         {
00760             screen->passed = FALSE;
00761             if (screen->tryTimes >= MAX_TRY_PINCODE_TIMES)
00762             {
00763 //                pincode_message_widget_set_text(screen,_("Tried too many times! System is going to power off now."));
00764 //                gtk_pincode_screen_show_message_widget(screen);
00765 //                display_update_request_screen_refresh(TEXTENTRY_CHANGED_LEVEL, NULL);
00766 
00767 //                g_timeout_handler_id = g_timeout_add(500, pincode_shutdown, NULL);
00768                 pincode_shutdown(NULL);
00769             }
00770             else
00771             {
00772                 pincode_message_widget_set_text(screen, _("PIN code is incorrect. Please try again."));
00773                 gtk_pincode_screen_show_message_widget(screen);               
00774                 display_update_request_screen_refresh(TEXTENTRY_CHANGED_LEVEL);
00775 
00776                 g_timeout_handler_id = g_timeout_add(3000, pincode_passed, (gpointer)screen);
00777             }
00778         }
00779         else
00780         {
00781             text = pincode_stars_get_text(screen->stars);
00782             if (   (signDocument_t != screen->reason && FALSE == screen->pincodeOn) 
00783                 || (0 == strlen(screen->pincode)) 
00784                 || (0 == strcmp(screen->pincode, text)) )
00785             {
00786                 screen->passed = TRUE;
00787                 screen->tryTimes = 0;
00788             }
00789             else
00790             {
00791                 screen->passed = FALSE;
00792             }
00793             if (FALSE == screen->passed)
00794             {
00795                 if (screen->tryTimes >= MAX_TRY_PINCODE_TIMES)
00796                 {
00797 //                  pincode_message_widget_set_text(screen, _("Tried too many times! System is going to power off now."));
00798 //                  gtk_pincode_screen_show_message_widget(screen);
00799 //                  display_update_request_screen_refresh(TEXTENTRY_CHANGED_LEVEL, NULL);
00800 
00801 //                  g_timeout_handler_id = g_timeout_add(500, pincode_shutdown, NULL);
00802                    pincode_shutdown(NULL);
00803                 }
00804                 else
00805                 {
00806                     pincode_message_widget_set_text(screen, _("PIN code is incorrect. Please try again."));
00807                     gtk_pincode_screen_show_message_widget(screen);
00808                     display_update_request_screen_refresh(TEXTENTRY_CHANGED_LEVEL);
00809 
00810                     g_timeout_handler_id = g_timeout_add(3000, pincode_passed, (gpointer)screen);
00811                 }
00812             }
00813             else
00814             {
00815 //                pincode_message_widget_set_text(screen, _("Your code is accepted."));
00816 //                gtk_pincode_screen_show_message_widget(screen);
00817 //                gtk_pincode_show_message_info_label(screen, FALSE);
00818 //                display_update_request_screen_refresh(TEXTENTRY_CHANGED_LEVEL, NULL);
00819                 
00820 //                g_timeout_handler_id = g_timeout_add(500, pincode_passed, (gpointer) screen);
00821                 pincode_passed(screen);                
00822             }
00823         }
00824     }
00825 
00826     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE);
00827     return FALSE;               // don't call me anymore
00828 }
00829 
00830 static gboolean pincode_shutdown(gpointer user_data)
00831 {
00832      if (g_timeout_handler_id)
00833     {
00834         gtk_timeout_remove(g_timeout_handler_id);
00835         g_timeout_handler_id = 0;
00836     }
00837    ctrl_hide_pincode_screen();
00838    ctrl_shutdown();
00839    return FALSE;
00840 }
00841 
00842 static gboolean pincode_passed(gpointer user_data)
00843 {
00844     GtkPincodeScreen* screen = user_data;
00845     gboolean passed = screen->passed;
00846     
00847     if (g_timeout_handler_id)
00848     {
00849         gtk_timeout_remove(g_timeout_handler_id);
00850         g_timeout_handler_id = 0;
00851     }
00852 
00853     if (!passed)
00854     {
00855         // show input messaget to let user try again
00856         pincode_stars_reset(screen->stars);
00857         gtk_pincode_screen_show_input_widget(screen);
00858         display_update_request_screen_refresh( TEXTENTRY_CHANGED_LEVEL);
00859     }
00860     else
00861     {
00862         int level = display_update_get_level();
00863 
00864         // hide pincode
00865         if (screen->reason == enterSettings_t)
00866         {
00867             display_update_increase_level(NO_DISPLAY_UPDATE_LEVEL);
00868         }
00869         else
00870         {
00871              display_update_increase_level(MAIN_WINDOW_EXPOSE_LEVEL);
00872         }
00873         ctrl_hide_pincode_screen();
00874         if (screen->reason != startup_t)
00875         {
00876             g_idle_add(pincode_decrease_display_level, (gpointer)level);
00877         }
00878 
00879         // trigger on_passed_callback
00880         if (screen->on_passed_callback)
00881         {
00882             screen->on_passed_callback();
00883         }
00884     }
00885     return FALSE;               // not call again
00886 }
00887 
00888 static gboolean pincode_decrease_display_level(gpointer data)
00889 {
00890     // allow display updates again
00891     display_update_decrease_level((gint)data/*LOWEST_LEVEL*/);
00892 
00893     return FALSE;               // don't call me again
00894 }
00895 
00896 //
00897 // messageWidget signals fucntions
00898 //
00899 static gboolean on_message_widget_clicked_event(GtkWidget * widget, GdkEventButton * event, gpointer user_data)
00900 {
00901     GtkPincodeScreen *screen = user_data;
00902 
00903     if (!IS_GTK_PINCODE_SCREEN(screen))
00904         return FALSE;
00905     if (screen->tryTimes >= MAX_TRY_PINCODE_TIMES)
00906     {
00907         pincode_shutdown(NULL);
00908     }
00909     else
00910     {
00911         // when error message appears, click to return back input pincode again
00912         // when passed message appears, click to (boot normally...)
00913         pincode_passed((gpointer) screen);
00914     }
00915     return FALSE;
00916 }
00917 
00918 //
00919 // pincode stars
00920 //
00921 //|--hbox
00922 //   |--vbox1
00923 //      |--grayStar(GtkEventBox)
00924 //      |--whiteStar(GtkEventBox)
00925 //   |--vbox2
00926 //      |--grayStar
00927 //      |--whiteStar
00928 //   |--vbox3
00929 //      |--grayStar
00930 //      |--whiteStar
00931 //   |--vbox4
00932 //      |--grayStar
00933 //      |--whiteStar
00934 //    
00935 static GtkWidget *create_pincode_stars(GtkPincodeScreen * screen)
00936 {
00937     pincodeStars *stars = NULL;
00938 
00939     GtkWidget *hbox;
00940     GtkWidget *vbox;
00941     GtkWidget *grayStar;
00942     GtkWidget *whiteStar;
00943 
00944     if (NULL == screen)
00945         return NULL;
00946     if (!IS_GTK_PINCODE_SCREEN(screen))
00947         return NULL;
00948     stars = g_new0(pincodeStars, 1);
00949     if (NULL == stars)
00950         return NULL;
00951 
00952     hbox = gtk_hbox_new(FALSE, PINCODE_STAR_SPACING);
00953     stars->hbox = hbox;
00954 // vbox1
00955     vbox = gtk_vbox_new(FALSE, 0);
00956     gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
00957     stars->vbox1 = vbox;
00958     grayStar = gtk_event_box_new();
00959     gtk_box_pack_start(GTK_BOX(vbox), grayStar, FALSE, FALSE, 0);
00960     stars->grayStar1 = grayStar;
00961     gtk_widget_set_name(grayStar, "pincode_gray_star");
00962     gtk_widget_set_size_request(grayStar, PINCODE_STAR_WIDTH, PINCODE_STAR_HEIGHT);
00963     whiteStar = gtk_event_box_new();
00964     gtk_box_pack_start(GTK_BOX(vbox), whiteStar, FALSE, FALSE, 0);
00965     stars->whiteStar1 = whiteStar;
00966     gtk_widget_set_name(whiteStar, "pincode_white_star");
00967     gtk_widget_set_size_request(whiteStar, PINCODE_STAR_WIDTH, PINCODE_STAR_HEIGHT);
00968 // vbox2
00969     vbox = gtk_vbox_new(FALSE, 0);
00970     gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
00971     stars->vbox2 = vbox;
00972     grayStar = gtk_event_box_new();
00973     gtk_box_pack_start(GTK_BOX(vbox), grayStar, FALSE, FALSE, 0);
00974     stars->grayStar2 = grayStar;
00975     gtk_widget_set_name(grayStar, "pincode_gray_star");
00976     gtk_widget_set_size_request(grayStar, PINCODE_STAR_WIDTH, PINCODE_STAR_HEIGHT);
00977     whiteStar = gtk_event_box_new();
00978     gtk_box_pack_start(GTK_BOX(vbox), whiteStar, FALSE, FALSE, 0);
00979     stars->whiteStar2 = whiteStar;
00980     gtk_widget_set_name(whiteStar, "pincode_white_star");
00981     gtk_widget_set_size_request(whiteStar, PINCODE_STAR_WIDTH, PINCODE_STAR_HEIGHT);
00982 // vbox3
00983     vbox = gtk_vbox_new(FALSE, 0);
00984     gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
00985     stars->vbox3 = vbox;
00986     grayStar = gtk_event_box_new();
00987     gtk_box_pack_start(GTK_BOX(vbox), grayStar, FALSE, FALSE, 0);
00988     stars->grayStar3 = grayStar;
00989     gtk_widget_set_name(grayStar, "pincode_gray_star");
00990     gtk_widget_set_size_request(grayStar, PINCODE_STAR_WIDTH, PINCODE_STAR_HEIGHT);
00991     whiteStar = gtk_event_box_new();
00992     gtk_box_pack_start(GTK_BOX(vbox), whiteStar, FALSE, FALSE, 0);
00993     stars->whiteStar3 = whiteStar;
00994     gtk_widget_set_name(whiteStar, "pincode_white_star");
00995     gtk_widget_set_size_request(whiteStar, PINCODE_STAR_WIDTH, PINCODE_STAR_HEIGHT);
00996 // vbox4
00997     vbox = gtk_vbox_new(FALSE, 0);
00998     gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
00999     stars->vbox4 = vbox;
01000     grayStar = gtk_event_box_new();
01001     gtk_box_pack_start(GTK_BOX(vbox), grayStar, FALSE, FALSE, 0);
01002     stars->grayStar4 = grayStar;
01003     gtk_widget_set_name(grayStar, "pincode_gray_star");
01004     gtk_widget_set_size_request(grayStar, PINCODE_STAR_WIDTH, PINCODE_STAR_HEIGHT);
01005     whiteStar = gtk_event_box_new();
01006     gtk_box_pack_start(GTK_BOX(vbox), whiteStar, FALSE, FALSE, 0);
01007     stars->whiteStar4 = whiteStar;
01008     gtk_widget_set_name(whiteStar, "pincode_white_star");
01009     gtk_widget_set_size_request(whiteStar, PINCODE_STAR_WIDTH, PINCODE_STAR_HEIGHT);
01010 // 
01011     memset(stars->pincode, 0, sizeof(stars->pincode));
01012 // show widgets
01013     gtk_widget_show(stars->hbox);
01014     gtk_widget_show(stars->vbox1);
01015     gtk_widget_show(stars->grayStar1);
01016     gtk_widget_show(stars->vbox2);
01017     gtk_widget_show(stars->grayStar2);
01018     gtk_widget_show(stars->vbox3);
01019     gtk_widget_show(stars->grayStar3);
01020     gtk_widget_show(stars->vbox4);
01021     gtk_widget_show(stars->grayStar4);
01022 
01023     screen->stars = stars;
01024     stars->on_change_occurred = FALSE;
01025     stars->display_update_pending = FALSE;
01026 
01027     return hbox;
01028 }
01029 
01030 static void destroy_pincode_stars(GtkPincodeScreen * screen)
01031 {
01032     pincodeStars *stars;
01033     g_return_if_fail(NULL != screen);
01034     g_return_if_fail(IS_GTK_PINCODE_SCREEN(screen));
01035     stars = (pincodeStars *) screen->stars;
01036     g_return_if_fail(NULL != stars);
01037     g_free(stars);
01038     screen->stars = NULL;
01039 }
01040 
01041 static void pincode_stars_append_number(pincodeStars * stars, gint number)
01042 {
01043     GtkWidget *vbox = NULL;
01044     GtkWidget *grayStar = NULL;
01045     GtkWidget *whiteStar = NULL;
01046 
01047     gchar string[2];
01048     int len;
01049 
01050     if (NULL == stars)
01051         return;
01052     len = strlen(stars->pincode);
01053     if (len >= PINCODE_UI_MAX_LENGTH)
01054     {
01055         CL_ERRORPRINTF("input pincode length reaches pincode_max_length");
01056         return;
01057     }
01058     sprintf(string, "%d", number);
01059     if (0 == len)
01060         strcpy(stars->pincode, string);
01061     else
01062         strcat(stars->pincode, string);
01063     len = strlen(stars->pincode);
01064     if (1 == len)
01065     {
01066         vbox = stars->vbox1;
01067         grayStar = stars->grayStar1;
01068         whiteStar = stars->whiteStar1;
01069     }
01070     else if (2 == len)
01071     {
01072         vbox = stars->vbox2;
01073         grayStar = stars->grayStar2;
01074         whiteStar = stars->whiteStar2;
01075     }
01076     else if (3 == len)
01077     {
01078         vbox = stars->vbox3;
01079         grayStar = stars->grayStar3;
01080         whiteStar = stars->whiteStar3;
01081     }
01082     else if (4 == len)
01083     {
01084         vbox = stars->vbox4;
01085         grayStar = stars->grayStar4;
01086         whiteStar = stars->whiteStar4;
01087     }
01088     else
01089     {
01090         CL_ERRORPRINTF("error");
01091     }
01092     if (vbox && grayStar && whiteStar)
01093     {
01094         gtk_widget_hide(vbox);
01095         gtk_widget_hide(grayStar);
01096         gtk_widget_show(whiteStar);
01097         gtk_widget_show(vbox);
01098     }
01099 
01100     if (stars->display_update_pending)
01101     {
01102         // timer already running: tell it that another change has occurred
01103         stars->on_change_occurred = TRUE;
01104     }
01105     else
01106     {
01107         // timer not running: start it now
01108         g_timeout_add(500, delayed_on_changed, stars);
01109         stars->display_update_pending = TRUE;
01110     }
01111 }
01112 
01113 static void pincode_stars_backspace(pincodeStars * stars)
01114 {
01115     GtkWidget *vbox = NULL;
01116     GtkWidget *grayStar = NULL;
01117     GtkWidget *whiteStar = NULL;
01118     int len;
01119 
01120     if (NULL == stars)
01121         return;
01122     len = strlen(stars->pincode);
01123     if (len <= 0)
01124     {
01125         CL_ERRORPRINTF("input pincode length equals zero, neen't backspace");
01126         return;
01127     }
01128     stars->pincode[len - 1] = '\0';
01129     if (1 == len)
01130     {
01131         vbox = stars->vbox1;
01132         grayStar = stars->grayStar1;
01133         whiteStar = stars->whiteStar1;
01134     }
01135     else if (2 == len)
01136     {
01137         vbox = stars->vbox2;
01138         grayStar = stars->grayStar2;
01139         whiteStar = stars->whiteStar2;
01140     }
01141     else if (3 == len)
01142     {
01143         vbox = stars->vbox3;
01144         grayStar = stars->grayStar3;
01145         whiteStar = stars->whiteStar3;
01146     }
01147     else if (4 == len)
01148     {
01149         vbox = stars->vbox4;
01150         grayStar = stars->grayStar4;
01151         whiteStar = stars->whiteStar4;
01152     }
01153     else
01154     {
01155         CL_ERRORPRINTF("error");
01156     }
01157     if (vbox && grayStar && whiteStar)
01158     {
01159         gtk_widget_hide(vbox);
01160         gtk_widget_hide(whiteStar);
01161         gtk_widget_show(grayStar);
01162         gtk_widget_show(vbox);
01163     }
01164  
01165     if (stars->display_update_pending)
01166     {
01167         // timer already running: tell it that another change has occurred
01168         stars->on_change_occurred = TRUE;
01169     }
01170     else
01171     {
01172         // timer not running: start it now
01173         g_timeout_add(500, delayed_on_changed, stars);
01174         stars->display_update_pending = TRUE;
01175     }
01176 }
01177 
01178 static gboolean delayed_on_changed(gpointer user_data)
01179 {
01180     pincodeStars *stars = user_data;
01181 
01182     if (NULL == stars)
01183         return FALSE;
01184 
01185     if (stars->on_change_occurred)
01186     {
01187         // item text has been changed: check again later
01188         stars->on_change_occurred = FALSE;
01189     }
01190     else
01191     {
01192         // for back to pincode after downloadMgr
01193          int level = display_update_get_level();
01194          if (level > TEXTENTRY_CHANGED_LEVEL)
01195          {
01196              display_update_decrease_level(TEXTENTRY_CHANGED_LEVEL);
01197          }
01198         // item text is stable: update screen
01199         display_update_request_screen_refresh(TEXTENTRY_CHANGED_LEVEL);
01200         stars->display_update_pending = FALSE;
01201     }
01202 
01203     return stars->display_update_pending;       // TRUE = call me again, FALSE = don't call
01204 }
01205 
01206 static gchar *pincode_stars_get_text(pincodeStars * stars)
01207 {
01208     if (NULL == stars)
01209         return NULL;
01210     return stars->pincode;
01211 }
01212 
01213 static gboolean pincode_stars_check_text(pincodeStars * stars)
01214 {
01215     gchar *text;
01216     int len;
01217 
01218     if (NULL == stars)
01219         return FALSE;
01220     text = pincode_stars_get_text(stars);
01221     if (NULL == text)
01222         return FALSE;
01223     len = strlen(text);
01224     if (len >= PINCODE_UI_MIN_LENGTH && len <= PINCODE_UI_MAX_LENGTH)
01225         return TRUE;
01226     else
01227         return FALSE;
01228 }
01229 
01230 static void pincode_stars_reset(pincodeStars * stars)
01231 {
01232     if (NULL == stars)
01233         return;
01234     memset(stars->pincode, 0, sizeof(stars->pincode));
01235 
01236     gtk_widget_hide(stars->vbox1);
01237     gtk_widget_hide(stars->vbox2);
01238     gtk_widget_hide(stars->vbox3);
01239     gtk_widget_hide(stars->vbox4);
01240 
01241     gtk_widget_hide(stars->whiteStar1);
01242     gtk_widget_hide(stars->whiteStar2);
01243     gtk_widget_hide(stars->whiteStar3);
01244     gtk_widget_hide(stars->whiteStar4);
01245 
01246     gtk_widget_show(stars->grayStar1);
01247     gtk_widget_show(stars->grayStar2);
01248     gtk_widget_show(stars->grayStar3);
01249     gtk_widget_show(stars->grayStar4);
01250 
01251     gtk_widget_show(stars->vbox1);
01252     gtk_widget_show(stars->vbox2);
01253     gtk_widget_show(stars->vbox3);
01254     gtk_widget_show(stars->vbox4);
01255 
01256     display_update_request_screen_refresh(TEXTENTRY_CHANGED_LEVEL);
01257 }