settings/src/iLiadTimediDSScreen.c Source File

00001 /*
00002  * This file is part of settings.
00003  *
00004  * settings 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  * settings 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 
00031 #include <ctype.h>
00032 #include <stdlib.h>
00033 #include <string.h>
00034 #include <gtk/gtk.h>
00035 #include <libergtk/ergtk.h>
00036 #include "gtkInfoItem.h"
00037 #include "gtkSettingItem.h"
00038 #include "setupLog.h"
00039 #include "iLiadTimediDSData.h"
00040 #include "iLiadTimediDSScreen.h"
00041 #include "languages.h"
00042 
00043 // Global variables
00044 static gtk_timedids_screen_t* g_timedids_screen;
00045 static regTimedIds_t* g_cur_settings = NULL;
00046 
00047 // Internal used functions
00048 static GtkWidget* create_enable_timedids(gtk_enable_timedids_t* enable_timedids);
00049 static GtkWidget* create_time_settings(gtk_time_settings_t* settime);
00050 static void update_timeset(void);
00051 
00052 // Signal handlers
00053 static void on_selection_update(erGtkSelectionGroup * selection, gpointer data);
00054 static void on_checked_software_update(GtkToggleButton* button, gpointer data);
00055 static void on_checked_switch_off(GtkToggleButton* button, gpointer data);
00056 static void on_hour_entry_insert_text(GtkEditable *editable,
00057                                       gchar *new_text,
00058                                       gint new_text_length,
00059                                       gint *position,
00060                                       gpointer user_data);
00061 static void on_minute_entry_insert_text(GtkEditable *editable,
00062                                         gchar *new_text,
00063                                         gint new_text_length,
00064                                         gint *position,
00065                                         gpointer user_data);
00066 static gboolean on_hour_entry_losefocus(GtkWidget *widget, GdkEventFocus *event, gpointer user_data);
00067 static gboolean on_minute_entry_getfocus(GtkWidget *widget, GdkEventFocus *event, gpointer user_data);
00068 static gboolean on_minute_entry_losefocus(GtkWidget *widget, GdkEventFocus *event, gpointer user_data);
00069 
00070 // widget hierarchy
00071 // |--vbox
00072 //    |--enable_timedids (GtkSettingItem)
00073 //    |--settime         (GtkSettingItem)
00074 //    |--info
00075 GtkWidget* iLiad_timedids_screen_create(void)
00076 {
00077     GtkWidget* vbox;
00078     GtkWidget* enable_timedids;
00079     GtkWidget* settime;
00080     GtkWidget* info;
00081 
00082     ST_LOGPRINTF("entry");
00083     
00084     vbox = gtk_vbox_new(FALSE, TIMEDIDS_ITEM_SPACING);
00085 
00086     g_timedids_screen = g_new0(gtk_timedids_screen_t, 1);
00087     
00088     enable_timedids = create_enable_timedids(&g_timedids_screen->enable_timedids);
00089     gtk_box_pack_start(GTK_BOX(vbox), enable_timedids, FALSE, FALSE, 0);
00090 
00091     settime = create_time_settings(&g_timedids_screen->settime);
00092     gtk_box_pack_start(GTK_BOX(vbox), settime, FALSE, FALSE, 0);
00093 
00094     info = gtk_infoitem_new(FALSE);
00095     gtk_box_pack_start(GTK_BOX(vbox), info, FALSE, FALSE, 0);
00096     g_timedids_screen->infoitem = info;
00097     
00098     // show widgets
00099     gtk_widget_show(vbox);
00100     return vbox;
00101 }
00102 
00103 // widget hierarchy
00104 // |--settingitem (GtkSettingItem)
00105 //    |--background (GtkEventBox)
00106 //       |--alignment
00107 //          |--vbox
00108 //             |--label
00109 //             |--hbox
00110 //                |--button
00111 //                |--button
00112 GtkWidget* create_enable_timedids(gtk_enable_timedids_t* enable_timedids)
00113 {
00114     GtkWidget* settingitem;
00115     GtkWidget* background;
00116     GtkWidget* alignment;
00117     GtkWidget* vbox;
00118     GtkWidget* label;
00119     GtkWidget* hbox;
00120     GtkWidget* button;
00121     GtkToggleButton* button_tbl[TIME_OPTIONS];
00122     GtkWidget* selection;
00123 
00124     ST_LOGPRINTF("entry");
00125     
00126     // settingitem
00127     settingitem = gtk_settingitem_new("");
00128     gtk_widget_set_size_request(settingitem, -1, -1);
00129     enable_timedids->settingitem = settingitem;
00130 
00131     // background
00132     background = gtk_event_box_new();
00133     gtk_widget_set_name(background, "timedids_enable_background");
00134     gtk_widget_set_size_request(background, TITLE_MIN_WIDTH, ENABLE_TIMEDIDS_HEIGHT);
00135     gtk_settingitem_add_details(GTK_SETTINGITEM(settingitem), background);
00136 
00137     // alignment
00138     alignment = gtk_alignment_new(0, 0, 0, 0);
00139     gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
00140             TIMEDIDS_SCREEN_ITEM_PADDING_TOP,
00141             TIMEDIDS_SCREEN_ITEM_PADDING_BOTTOM,
00142             TIMEDIDS_SCREEN_ITEM_PADDING_LEFT,
00143             TIMEDIDS_SCREEN_ITEM_PADDING_RIGHT);
00144     gtk_container_add(GTK_CONTAINER(background), alignment);
00145 
00146     // vbox
00147     vbox = gtk_vbox_new(FALSE, ENABLE_TIMEDIDS_ITEM_SPACING);
00148     gtk_container_add(GTK_CONTAINER(alignment), vbox);
00149 
00150     // label
00151     label = gtk_label_new("");
00152     gtk_widget_set_name(label, "timedids_info_text");
00153     gtk_label_set_single_line_mode(GTK_LABEL(label), FALSE);
00154     gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
00155     gtk_widget_set_size_request(label, ENABLE_TIMEDIDS_LABEL_WIDTH, -1);
00156     gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
00157     enable_timedids->label_desc = label;
00158 
00159     // hbox
00160     hbox = gtk_hbox_new(FALSE, SMALL_BUTTON_SPACING);
00161     gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox), FALSE, FALSE, 0);
00162 
00163     // button
00164     button = ergtk_toggle_button_new_with_label("");
00165     gtk_widget_set_size_request(GTK_WIDGET(button), SMALL_BUTTON_WIDTH, SMALL_BUTTON_HEIGHT);
00166     gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
00167     enable_timedids->button_timedids_on = GTK_TOGGLE_BUTTON(button);
00168     button_tbl[0] = enable_timedids->button_timedids_on;
00169 
00170     // button
00171     button = ergtk_toggle_button_new_with_label("");
00172     gtk_widget_set_size_request(GTK_WIDGET(button), SMALL_BUTTON_WIDTH, SMALL_BUTTON_HEIGHT);
00173     gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
00174     enable_timedids->button_timedids_off = GTK_TOGGLE_BUTTON(button);
00175     button_tbl[1] = enable_timedids->button_timedids_off;
00176     
00177     button_tbl[2] = NULL;
00178     // selection group not part of widget hierarchy
00179     selection = ergtk_selection_group_new(button_tbl);
00180     ergtk_selection_group_set_details(ERGTK_SELECTION_GROUP(selection), 1, 1);
00181     g_signal_connect(G_OBJECT(selection), "selection-update", G_CALLBACK(on_selection_update), NULL);
00182     
00183     gtk_widget_show_all(background);
00184     gtk_widget_show(settingitem);
00185 
00186     return settingitem;    
00187 }
00188 
00189 // widget hierarchy
00190 // |--settingitem (GtkSettingItem)
00191 //    |--background (GtkEventBox)
00192 //       |--alignment
00193 //          |--vbox
00194 //             |--label
00195 //             |--hbox
00196 //                |--label   "Connect at"
00197 //                |--entry   "Time option 1: hour"
00198 //                |--label   ":"
00199 //                |--entry   "Time option 1: minute"
00200 //             |--hbox
00201 //                |--label   "Connect at"
00202 //                |--entry   "Time option 2: hour"
00203 //                |--label   ":"
00204 //                |--entry   "Time option 2: minute"
00205 //                ...
00206 //             |--checkbutton
00207 //             |--checkbutton
00208 GtkWidget* create_time_settings(gtk_time_settings_t* settime)
00209 {
00210     int        i;
00211     GtkWidget* settingitem;
00212     GtkWidget* background;
00213     GtkWidget* alignment;
00214     GtkWidget* vbox;
00215     GtkWidget* label;
00216     GtkWidget* hbox;
00217     GtkWidget* entry;
00218     GtkWidget* check;
00219     
00220     ST_LOGPRINTF("entry");
00221     
00222     // settingitem
00223     settingitem = gtk_settingitem_new("");
00224     gtk_widget_set_size_request(settingitem, -1, -1);
00225     settime->settingitem = settingitem;
00226 
00227     // background
00228     background = gtk_event_box_new();
00229     gtk_widget_set_name(background, "timedids_settime_background");
00230     gtk_widget_set_size_request(background, TITLE_MIN_WIDTH, TIME_SETTINGS_HEIGHT);
00231     gtk_settingitem_add_details(GTK_SETTINGITEM(settingitem), background);
00232 
00233     // alignment
00234     alignment = gtk_alignment_new(0, 0, 0, 0);
00235     gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
00236             TIMEDIDS_SCREEN_ITEM_PADDING_TOP,
00237             TIMEDIDS_SCREEN_ITEM_PADDING_BOTTOM,
00238             TIMEDIDS_SCREEN_ITEM_PADDING_LEFT,
00239             TIMEDIDS_SCREEN_ITEM_PADDING_RIGHT);
00240     gtk_container_add(GTK_CONTAINER(background), alignment);
00241 
00242     // vbox
00243     vbox = gtk_vbox_new(FALSE, TIME_SETTINGS_ITEM_SPACING);
00244     gtk_container_add(GTK_CONTAINER(alignment), vbox);
00245 
00246     // label
00247     label = gtk_label_new("");
00248     gtk_widget_set_name(label, "timedids_info_text");
00249     gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
00250     gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
00251     settime->label_desc = label;
00252 
00253     for (i=0; i<TIME_OPTIONS; i++)
00254     {
00255         // create a hbox to contain time entrys
00256         hbox = gtk_hbox_new(FALSE, 0);
00257         gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox), FALSE, FALSE, 0);
00258 
00259         // label "Connect at"
00260         label = gtk_label_new("");
00261         gtk_widget_set_name(label, "timedids_info_text");
00262         gtk_widget_set_size_request(label, TIME_SETTINGS_CONNECTAT_WIDTH, -1);
00263         gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
00264         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
00265         settime->time_entries[i].label_connectat = label;
00266 
00267         // hour entry
00268         entry = ergtk_entry_new();
00269         gtk_widget_set_size_request(entry, TIME_SETTINGS_ENTRY_WIDTH, TIME_SETTINGS_ENTRY_HEIGHT);
00270         gtk_entry_set_alignment(GTK_ENTRY(entry), 1.0);
00271         gtk_entry_set_max_length(GTK_ENTRY(entry), 2);
00272         g_signal_connect(GTK_OBJECT(entry), "insert_text", G_CALLBACK(on_hour_entry_insert_text), (gpointer)i);
00273         g_signal_connect(GTK_OBJECT(entry), "focus-out-event", G_CALLBACK(on_hour_entry_losefocus), (gpointer)i);
00274         gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0);
00275         settime->time_entries[i].entry_hour = entry;
00276 
00277         // label colon
00278         label = gtk_label_new(":");
00279         gtk_widget_set_name(label, "timedids_info_text");
00280         gtk_widget_set_size_request(label, TIME_SETTINGS_COLON_WIDTH, -1);
00281         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
00282 
00283         // minute entry
00284         entry = ergtk_entry_new();
00285         gtk_widget_set_size_request(entry, TIME_SETTINGS_ENTRY_WIDTH, TIME_SETTINGS_ENTRY_HEIGHT);
00286         gtk_entry_set_max_length(GTK_ENTRY(entry), 2);
00287         g_signal_connect(GTK_OBJECT(entry), "insert-text", G_CALLBACK(on_minute_entry_insert_text), (gpointer)i);
00288         g_signal_connect(GTK_OBJECT(entry), "focus-out-event", G_CALLBACK(on_minute_entry_losefocus), (gpointer)i);
00289         g_signal_connect(GTK_OBJECT(entry), "focus-in-event", G_CALLBACK(on_minute_entry_getfocus), (gpointer)i);
00290         gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0);
00291         settime->time_entries[i].entry_minute = entry;
00292     }
00293 
00294     // check_software_update
00295     check = gtk_check_button_new_with_label("");
00296     gtk_box_pack_start(GTK_BOX(vbox), check, FALSE, FALSE, 0);
00297     g_signal_connect(check, "toggled", G_CALLBACK(on_checked_software_update), NULL);
00298     settime->check_software_update = check;
00299     
00300     // check_auto_shutdown
00301     check = gtk_check_button_new_with_label("");
00302     gtk_box_pack_start(GTK_BOX(vbox), check, FALSE, FALSE, 0);
00303     g_signal_connect(check, "toggled", G_CALLBACK(on_checked_switch_off), NULL);
00304     settime->check_auto_shutdown = check;
00305     
00306     gtk_widget_show_all(background);
00307     gtk_widget_show(settingitem);
00308 
00309     return settingitem;
00310 }
00311 
00312 void iLiad_timedids_screen_set_text(void)
00313 {
00314     ST_LOGPRINTF("entry");
00315     if (g_timedids_screen == NULL)
00316     {
00317         return;
00318     }
00319     
00320     gtk_enable_timedids_t* enable_timedids = &g_timedids_screen->enable_timedids;
00321     gtk_time_settings_t* settime = &g_timedids_screen->settime;
00322 
00323     gtk_settingitem_set_header_text(GTK_SETTINGITEM(enable_timedids->settingitem),
00324             _("Time to connect to iDS"));
00325     gtk_label_set_text(GTK_LABEL(enable_timedids->label_desc),
00326             _("Enabling \"time to connection\" causes the iLiad to download content from the iDS at a set time."));
00327     
00328     gtk_button_set_label(GTK_BUTTON(enable_timedids->button_timedids_on), _("On"));
00329     gtk_button_set_label(GTK_BUTTON(enable_timedids->button_timedids_off), _("Off"));
00330 
00331     gtk_settingitem_set_header_text(GTK_SETTINGITEM(settime->settingitem),
00332             _("Set the time"));
00333     gtk_label_set_text(GTK_LABEL(settime->label_desc), _("The iLiad will connect to iDS at the set time:"));
00334 
00335     int i;
00336     for (i=0; i<TIME_OPTIONS; i++)
00337     {
00338         gtk_label_set_text(GTK_LABEL(settime->time_entries[i].label_connectat), _("Connect at"));
00339     }
00340 
00341     gtk_button_set_label(GTK_BUTTON(settime->check_software_update),
00342             _("Include software downloads while connected to iDS."));
00343     gtk_button_set_label(GTK_BUTTON(settime->check_auto_shutdown),
00344             _("Switch off again after waking up the device."));
00345     
00346     // Information text
00347     gtk_infoitem_set_text(GTK_INFOITEM(g_timedids_screen->infoitem),
00348             _("When the iLiad is switched off, it will 'wake-up' to download content from the iDS."));
00349 }
00350 
00351 void iLiad_timedids_screen_data_display(void)
00352 {
00353     ST_LOGPRINTF("entry");
00354     
00355     gtk_enable_timedids_t* enable_timedids = &g_timedids_screen->enable_timedids;
00356     gtk_time_settings_t*   settime         = &g_timedids_screen->settime;
00357 
00358     g_cur_settings = get_current_timedids_settings();
00359 
00360     // Enable timed-iDS or not
00361     if (g_cur_settings->enable)
00362     {
00363         gtk_toggle_button_set_active(enable_timedids->button_timedids_on, TRUE);
00364     }
00365     else
00366     {
00367         gtk_toggle_button_set_active(enable_timedids->button_timedids_off, TRUE);
00368     }
00369 
00370     // Time set
00371     int i;
00372     char hh[4], mm[4];
00373     for (i=0; i<g_cur_settings->timeCnt; i++)
00374     {
00375         snprintf(hh, 4, "%02d", g_cur_settings->timeSet[i] / 3600);
00376         gtk_entry_set_text(GTK_ENTRY(settime->time_entries[i].entry_hour), hh);
00377 
00378         snprintf(mm, 4, "%02d", g_cur_settings->timeSet[i] / 60 % 60);
00379         gtk_entry_set_text(GTK_ENTRY(settime->time_entries[i].entry_minute), mm);
00380     }
00381     
00382     // Include software updates while connected to iDS
00383     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(settime->check_software_update),
00384             g_cur_settings->swUpdate);
00385     
00386     // Switch off iLiad again after waking iLiad up
00387     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(settime->check_auto_shutdown),
00388             g_cur_settings->switchOff);
00389 }
00390 
00391 void iLiad_timedids_handle_page_switch(void)
00392 {
00393     // If disabled timed-iDS, toggle button
00394     gtk_enable_timedids_t* enable_timedids = &g_timedids_screen->enable_timedids;
00395 
00396     if (!g_cur_settings->enable)
00397     {
00398         gtk_toggle_button_set_active(enable_timedids->button_timedids_off, TRUE);
00399     }
00400 }
00401 
00402 void on_selection_update(erGtkSelectionGroup * selection, gpointer data)
00403 {
00404     int index = 0;
00405     
00406     ST_LOGPRINTF("entry");
00407     ergtk_selection_group_get_selected_buttons(ERGTK_SELECTION_GROUP(selection), &index, 1);
00408 
00409     if (index == 0)
00410     {
00411         // User click the "on" button
00412         g_cur_settings->enable = TRUE;
00413         gtk_widget_show(g_timedids_screen->settime.settingitem);
00414     }
00415     else
00416     {
00417         // User click the "off" button
00418         g_cur_settings->enable = FALSE;
00419         gtk_widget_hide(g_timedids_screen->settime.settingitem);
00420     }
00421 }
00422 
00423 void on_checked_software_update(GtkToggleButton* button, gpointer data)
00424 {
00425     ST_LOGPRINTF("entry");
00426 
00427     g_cur_settings->swUpdate = gtk_toggle_button_get_active(button);
00428 }
00429 
00430 void on_checked_switch_off(GtkToggleButton* button, gpointer data)
00431 {
00432     ST_LOGPRINTF("entry");
00433 
00434     g_cur_settings->switchOff = gtk_toggle_button_get_active(button);
00435 }
00436 
00437 void on_hour_entry_insert_text(GtkEditable *editable,
00438                                gchar *new_text,
00439                                gint new_text_length,
00440                                gint *position,
00441                                gpointer user_data)
00442 {
00443     int  count = 0;
00444     char szTmp[8] = {0};
00445     char valid_chars[3] = {0};
00446     char *firstchar = NULL;
00447     GtkWidget *widget = GTK_WIDGET(editable);
00448 
00449     ST_LOGPRINTF("entry");
00450 
00451     // i for loop indicator, j for the current char numbers in szTmp
00452     int i = 0, j = 0;
00453 
00454     if (*position >= 2)
00455     {
00456         gtk_signal_emit_stop_by_name(GTK_OBJECT (editable), "insert_text");
00457         return;
00458     }
00459 
00460     if (*position == 1)
00461     {
00462         firstchar = gtk_editable_get_chars(editable, 0, 1);
00463         szTmp[j++] = firstchar[0];
00464         g_free(firstchar);
00465     }
00466 
00467     for (i=0; i<new_text_length; i++)
00468     {
00469         if (isdigit(new_text[i]))
00470         {
00471             // Check that the digit is valid
00472             szTmp[j++] = new_text[i];
00473             if (atoi(szTmp) <= 24)
00474             {
00475                 // Valid char
00476                 valid_chars[count++] = new_text[i];
00477             }
00478         }
00479     }
00480 
00481     if (count > 0)
00482     {
00483         gtk_signal_handler_block_by_func(GTK_OBJECT(editable),
00484                 GTK_SIGNAL_FUNC(on_hour_entry_insert_text),
00485                 user_data);
00486         gtk_editable_insert_text(editable, valid_chars, count, position);
00487         gtk_signal_handler_unblock_by_func(GTK_OBJECT(editable),
00488                 GTK_SIGNAL_FUNC(on_hour_entry_insert_text),
00489                 user_data);
00490 
00491         // after second digit move focus to minutes entry
00492         firstchar = gtk_editable_get_chars(editable, 0, -1);  // get all characters
00493         if (strlen(firstchar) == 2)
00494         {
00495             for (i=0; i<TIME_OPTIONS; i++)
00496             {
00497                 if (g_timedids_screen->settime.time_entries[i].entry_hour == widget)
00498                 {
00499                     gtk_widget_grab_focus(g_timedids_screen->settime.time_entries[i].entry_minute);
00500                 }
00501             }
00502         }
00503     }
00504     
00505     gtk_signal_emit_stop_by_name(GTK_OBJECT (editable), "insert_text");
00506 }
00507 
00508 void on_minute_entry_insert_text(GtkEditable *editable,
00509                          gchar *new_text,
00510                          gint new_text_length,
00511                          gint *position,
00512                          gpointer user_data)
00513 {
00514     ST_LOGPRINTF("entry");
00515     
00516     int  count = 0;
00517     char szTmp[8] = {0};
00518     char valid_chars[3] = {0};
00519     char *firstchar = NULL;
00520 
00521     // First check if hour entry is empty
00522     int index = (int)user_data;
00523     GtkWidget* entry_hour = g_timedids_screen->settime.time_entries[index].entry_hour;
00524     const char* hour_str = gtk_entry_get_text(GTK_ENTRY(entry_hour));
00525 
00526     // Any input in minute entry is not allowed while hour entry is empty
00527     if (strlen(hour_str) == 0 || *position >= 2)
00528     {
00529         gtk_signal_emit_stop_by_name(GTK_OBJECT (editable), "insert_text");
00530         return;
00531     }
00532 
00533     int i = 0, j = 0;
00534     if (*position == 1)
00535     {
00536         firstchar = gtk_editable_get_chars(editable, 0, 1);
00537         szTmp[j++] = firstchar[0];
00538         g_free(firstchar);
00539     }
00540 
00541     for (i=0; i<new_text_length; i++)
00542     {
00543         if (isdigit(new_text[i]))
00544         {
00545             // Check that the digit is valid
00546             szTmp[j++] = new_text[i];
00547             if (atoi(szTmp) < 60)
00548             {
00549                 // Valid char
00550                 valid_chars[count++] = new_text[i];
00551             }
00552         }
00553     }
00554 
00555     if (count > 0)
00556     {
00557         gtk_signal_handler_block_by_func(GTK_OBJECT(editable),
00558                 GTK_SIGNAL_FUNC(on_minute_entry_insert_text),
00559                 user_data);
00560         gtk_editable_insert_text(editable, valid_chars, count, position);
00561         gtk_signal_handler_unblock_by_func(GTK_OBJECT(editable),
00562                 GTK_SIGNAL_FUNC(on_minute_entry_insert_text),
00563                 user_data);
00564     }
00565     
00566     gtk_signal_emit_stop_by_name(GTK_OBJECT (editable), "insert_text");
00567 }
00568 
00569 gboolean on_hour_entry_losefocus(GtkWidget *widget, GdkEventFocus *event, gpointer user_data)
00570 {
00571     ST_LOGPRINTF("entry");
00572     
00573     const char* str = gtk_entry_get_text(GTK_ENTRY(widget));
00574     int len = strlen(str);
00575     int index = (int)user_data;
00576     GtkWidget* entry_minute = g_timedids_screen->settime.time_entries[index].entry_minute;
00577 
00578     if (len == 0)
00579     {
00580         // Hour entry is empty, empty minute entry too
00581         gtk_entry_set_text(GTK_ENTRY(entry_minute), "");
00582     }
00583     else if (atoi(str) > 23)
00584     {
00585         gtk_entry_set_text(GTK_ENTRY(widget), "00");
00586     }
00587     else
00588     {
00589         char hh[4] = {0};
00590         snprintf(hh, sizeof(hh), "%.2d", atoi(str));
00591         gtk_entry_set_text(GTK_ENTRY(widget), hh);
00592     }
00593 
00594     if (len > 0)
00595     {
00596         str = gtk_entry_get_text(GTK_ENTRY(entry_minute));
00597         if (strlen(str) == 0)
00598         {
00599             gtk_entry_set_text(GTK_ENTRY(entry_minute), "00");
00600         }
00601         gtk_editable_select_region(GTK_EDITABLE(entry_minute), 0, -1);
00602     }
00603 
00604     update_timeset();
00605     return FALSE;
00606 }
00607 
00608 gboolean on_minute_entry_getfocus(GtkWidget *widget, GdkEventFocus *event, gpointer user_data)
00609 {
00610     ST_LOGPRINTF("entry");
00611 
00612     int index = (int)user_data;
00613     GtkWidget* entry_hour = g_timedids_screen->settime.time_entries[index].entry_hour;
00614     
00615     if (strlen(gtk_entry_get_text(GTK_ENTRY(entry_hour))) == 0)
00616     {
00617         // Hour entry is empty, empty minute entry and set focus on hour entry
00618         gtk_entry_set_text(GTK_ENTRY(widget), "");
00619         gtk_widget_grab_focus(entry_hour);
00620     }
00621 
00622     return FALSE;
00623 }
00624 
00625 gboolean on_minute_entry_losefocus(GtkWidget *widget, GdkEventFocus *event, gpointer user_data)
00626 {
00627     ST_LOGPRINTF("entry");
00628 
00629     const char* str = gtk_entry_get_text(GTK_ENTRY(widget));
00630     int index = (int)user_data;
00631     GtkWidget* entry_hour = g_timedids_screen->settime.time_entries[index].entry_hour;
00632     
00633     str = gtk_entry_get_text(GTK_ENTRY(widget));
00634     
00635     if (strlen(gtk_entry_get_text(GTK_ENTRY(entry_hour))) == 0)
00636     {
00637         // Hour entry is empty, empty minute entry too
00638         gtk_entry_set_text(GTK_ENTRY(widget), "");
00639     }
00640     else if (atoi(str) > 59)
00641     {
00642         gtk_entry_set_text(GTK_ENTRY(widget), "59");
00643     }
00644     else
00645     {
00646         char mm[4] = {0};
00647         snprintf(mm, sizeof(mm), "%.2d", atoi(str));
00648         gtk_entry_set_text(GTK_ENTRY(widget), mm);
00649     }
00650 
00651     update_timeset();
00652     return FALSE;
00653 }
00654 
00655 void update_timeset(void)
00656 {
00657     ST_LOGPRINTF("entry");
00658 
00659     g_cur_settings->timeCnt = 0;
00660     int i;
00661     for (i=0; i<TIME_OPTIONS; i++)
00662     {
00663         GtkWidget* entry_hour = g_timedids_screen->settime.time_entries[i].entry_hour;
00664         GtkWidget* entry_minute = g_timedids_screen->settime.time_entries[i].entry_minute;
00665         
00666         const char* str_hour = gtk_entry_get_text(GTK_ENTRY(entry_hour));
00667         const char* str_minute = gtk_entry_get_text(GTK_ENTRY(entry_minute));
00668 
00669         if (strlen(str_hour) > 0 && strlen(str_minute) > 0)
00670         {
00671             g_cur_settings->timeSet[g_cur_settings->timeCnt++] =
00672                 atoi(str_hour) * 3600 + atoi(str_minute) * 60;
00673         }
00674     }
00675 
00676     if (0 == g_cur_settings->timeCnt)
00677     {
00678         g_cur_settings->enable = FALSE;
00679     }
00680 }
00681