settings/src/iLiadBgConnectScreen.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 <stdlib.h>
00032 #include <string.h>
00033 
00034 #include <gtk/gtk.h>
00035 
00036 #include <libergtk/ergtk.h>
00037 
00038 #include "setupLog.h"
00039 #include "displayStatus.h"
00040 #include "background.h"
00041 #include "gtkInfoItem.h"
00042 #include "gtkSettingItem.h"
00043 #include "gtkSettingItemTextEntry.h"
00044 #include "iLiadBgConnectScreen.h"
00045 #include "iLiadBgConnectData.h"
00046 #include "languages.h"
00047 
00048 
00049 static GtkWidget* g_vbox = NULL;
00050 
00051 static GtkWidget* g_wlan_onoff = NULL;
00052 static GtkWidget* g_wlan_onoff_selection = NULL;
00053 static GtkWidget* g_wlan_onoff_label = NULL;
00054 static GtkWidget* g_wlan_button_on  = NULL;
00055 static GtkWidget* g_wlan_button_off = NULL;
00056 static guint      g_wlan_on  = -1;
00057 static guint      g_wlan_off = -1;
00058 
00059 static GtkWidget* g_background_idspc = NULL;
00060 static GtkWidget* g_background_idspc_selection = NULL;
00061 static GtkWidget* g_background_idspc_label = NULL;
00062 static GtkWidget* g_background_button_ids = NULL;
00063 static GtkWidget* g_background_button_pc  = NULL;
00064 static guint      g_background_ids = -1;
00065 static guint      g_background_pc  = -1;
00066 
00067 static GtkWidget* g_background_onoff = NULL;
00068 static GtkWidget* g_background_onoff_selection = NULL;
00069 static GtkWidget* g_background_onoff_label = NULL;
00070 static GtkWidget* g_background_button_on  = NULL;
00071 static GtkWidget* g_background_button_off = NULL;
00072 static guint      g_background_on  = -1;
00073 static guint      g_background_off = -1;
00074 
00075 static GtkWidget* g_background_interval = NULL;
00076 
00077 static GtkWidget* g_background_info = NULL;
00078 
00079 // internally used routines
00080 static GtkWidget* create_wlan_onoff(void);
00081 static GtkWidget* create_background_idspc(void);
00082 static GtkWidget* create_background_onoff(void);
00083 static GtkWidget* create_background_interval(void);
00084 static GtkWidget* create_background_info(void);
00085 //static gint       strtime2int(const gchar* text);
00086 gboolean   iLiad_background_get_on(void);
00087 
00088 // callback functions
00089 static void on_wlan_onoff_selection_update(erGtkSelectionGroup* selection, 
00090                                            gpointer button, 
00091                                            gpointer data);
00092 static void on_background_idspc_selection_update(erGtkSelectionGroup* selection, 
00093                                                  gpointer button, 
00094                                                  gpointer data);
00095 static void on_background_onoff_selection_update(erGtkSelectionGroup* selection, 
00096                                                  gpointer button, 
00097                                                  gpointer data);
00098 
00099 static void on_interval_validate(GtkWidget* item, const gchar* text, gchar** new_text);
00100 
00101 
00102 // object hierarchy:
00103 //     g_vbox
00104 //       |-- g_wlan_onoff
00105 //       |-- g_background_idspc
00106 //       |-- vbox
00107 //       |     |-- g_background_onoff
00108 //       |     |-- g_background_interval
00109 //       |-- g_background_info
00110 //
00111 GtkWidget* iLiad_autoconnect_create(void)
00112 {
00113     GtkWidget* vbox;
00114 
00115     ST_LOGPRINTF("entry");
00116 
00117     g_vbox = gtk_vbox_new(FALSE, BACKGROUNDSCREEN_ITEM_SPACING);
00118 
00119     g_wlan_onoff = create_wlan_onoff();
00120     gtk_box_pack_start(GTK_BOX(g_vbox), GTK_WIDGET(g_wlan_onoff), FALSE, FALSE, 0);
00121 
00122     g_background_idspc = create_background_idspc();
00123     gtk_box_pack_start(GTK_BOX(g_vbox), GTK_WIDGET(g_background_idspc), FALSE, FALSE, 0);
00124 
00125     vbox = gtk_vbox_new(FALSE, SETTINGITEM_ITEM_SPACING);
00126     gtk_box_pack_start(GTK_BOX(g_vbox), GTK_WIDGET(vbox), FALSE, FALSE, 0);
00127     gtk_widget_show(vbox);
00128 
00129     g_background_onoff = create_background_onoff();
00130     gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g_background_onoff), FALSE, FALSE, 0);
00131 
00132     g_background_interval = create_background_interval();
00133     gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g_background_interval), FALSE, FALSE, 0);
00134 
00135     g_background_info = create_background_info();
00136     gtk_box_pack_start(GTK_BOX(g_vbox), GTK_WIDGET(g_background_info), FALSE, FALSE, 0);
00137 
00138     gtk_widget_show(g_vbox);
00139 
00140     return g_vbox;
00141 }
00142 
00143 // object hierarchy:
00144 //     g_wlan_onoff (GtkSettingItem)
00145 //       |-- g_wlan_onoff_selection (erGtkSelectionGroup)
00146 //             |-- alignment
00147 //                   |--vbox
00148 //                        |-- g_wlan_onoff_label (GtkLabel)
00149 //                        |-- hbox
00150 //                              |-- g_wlan_button_on
00151 //                              |-- g_wlan_button_off
00152 //
00153 static GtkWidget* create_wlan_onoff(void)
00154 {
00155     GtkWidget*       widget;
00156     GtkWidget*       alignment;
00157     GtkWidget*       vbox;
00158     GtkWidget*       hbox;
00159     GtkToggleButton* button_tbl[3];
00160 
00161     // g_wlan_onoff
00162     widget = gtk_settingitem_new("");
00163     gtk_widget_set_size_request(widget, (-1), (-1));
00164     gtk_widget_show(widget);
00165     g_wlan_onoff = widget;
00166 
00167     // g_wlan_onoff_selection --> see below
00168 
00169     // alignment
00170     widget = gtk_alignment_new(0, 0, 0, 0);
00171     gtk_alignment_set_padding(GTK_ALIGNMENT(widget),
00172                               BACKGROUND_ITEM_PADDING_TOP,
00173                               BACKGROUND_ITEM_PADDING_BOTTOM,
00174                               BACKGROUND_ITEM_PADDING_LEFT,
00175                               BACKGROUND_ITEM_PADDING_RIGHT);
00176     gtk_widget_show(widget);
00177     alignment = widget;
00178 
00179     // vbox
00180     widget = gtk_vbox_new(FALSE, 2 * BACKGROUNDSCREEN_ITEM_SPACING);
00181     gtk_container_add(GTK_CONTAINER(alignment), widget);
00182     gtk_widget_show(widget);
00183     vbox = widget;
00184     
00185     // g_wlan_onoff_label
00186     widget = gtk_label_new("");
00187     gtk_widget_set_name(widget, "background_screen_info_text");
00188     gtk_widget_set_size_request(widget, BACKGROUND_ONOFF_LABEL_WIDTH, (-1));
00189     gtk_label_set_single_line_mode(GTK_LABEL(widget), FALSE);
00190     gtk_label_set_line_wrap(GTK_LABEL(widget), TRUE);
00191     gtk_label_set_justify(GTK_LABEL(widget), GTK_JUSTIFY_LEFT);
00192     gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
00193     gtk_widget_show(widget);
00194     g_wlan_onoff_label = widget;
00195 
00196     // hbox
00197     widget = gtk_hbox_new(FALSE, SMALL_BUTTON_SPACING);
00198     gtk_container_add(GTK_CONTAINER(vbox), widget);
00199     gtk_widget_show(widget);
00200     hbox = widget;
00201     //     g_wlan_button_on
00202     widget = ergtk_toggle_button_new_with_label("");
00203     gtk_widget_set_size_request(GTK_WIDGET(widget), SMALL_BUTTON_WIDTH, SMALL_BUTTON_HEIGHT);
00204     gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
00205     gtk_widget_show(widget);
00206     g_wlan_button_on = widget;
00207     //     g_wlan_button_off
00208     widget = ergtk_toggle_button_new_with_label("");
00209     gtk_widget_set_size_request(GTK_WIDGET(widget), SMALL_BUTTON_WIDTH, SMALL_BUTTON_HEIGHT);
00210     gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
00211     gtk_widget_show(widget);
00212     g_wlan_button_off = widget;
00213     // add details to selection
00214     button_tbl[0] = GTK_TOGGLE_BUTTON(g_wlan_button_on);
00215     button_tbl[1] = GTK_TOGGLE_BUTTON(g_wlan_button_off );
00216     button_tbl[2] = NULL;
00217     g_wlan_on = 0;  // selection-group counts from 0
00218     g_wlan_off  = 1;
00219     // g_wlan_onoff_selection
00220     widget = ergtk_selection_group_new(button_tbl);
00221     gtk_widget_set_name(widget, "background_idspc_background");
00222     ergtk_selection_group_set_details(ERGTK_SELECTION_GROUP(widget), 1, 1);
00223     gtk_widget_set_size_request(GTK_WIDGET(widget), -1, BACKGROUND_IDSPC_REQ_HEIGHT);
00224     g_signal_connect(G_OBJECT(widget), "selection-update", 
00225                      G_CALLBACK(on_wlan_onoff_selection_update), NULL);
00226     gtk_container_add(GTK_CONTAINER(widget), alignment);
00227     gtk_settingitem_add_details(GTK_SETTINGITEM(g_wlan_onoff), widget);
00228     gtk_widget_show(widget);
00229     g_wlan_onoff_selection = widget;
00230 
00231     return g_wlan_onoff;
00232 }
00233 
00234 
00235 // object hierarchy:
00236 //     g_background_idspc (GtkSettingItem)
00237 //       |-- g_background_idspc_selection (erGtkSelectionGroup)
00238 //             |-- alignment
00239 //                   |--vbox
00240 //                        |-- g_background_idspc_label (GtkLabel)
00241 //                        |-- hbox
00242 //                              |-- g_background_button_ids
00243 //                              |-- g_background_button_pc
00244 //
00245 static GtkWidget* create_background_idspc(void)
00246 {
00247     GtkWidget*       widget;
00248     GtkWidget*       alignment;
00249     GtkWidget*       vbox;
00250     GtkWidget*       hbox;
00251     GtkToggleButton* button_tbl[3];
00252 
00253     // g_background_idspc
00254     widget = gtk_settingitem_new("");
00255     gtk_widget_set_size_request(widget, (-1), (-1));
00256     gtk_widget_show(widget);
00257     g_background_idspc = widget;
00258 
00259     // g_background_idspc_selection --> see below
00260 
00261     // alignment
00262     widget = gtk_alignment_new(0, 0, 0, 0);
00263     gtk_alignment_set_padding(GTK_ALIGNMENT(widget),
00264                               BACKGROUND_ITEM_PADDING_TOP,
00265                               BACKGROUND_ITEM_PADDING_BOTTOM,
00266                               BACKGROUND_ITEM_PADDING_LEFT,
00267                               BACKGROUND_ITEM_PADDING_RIGHT);
00268     gtk_widget_show(widget);
00269     alignment = widget;
00270 
00271     // vbox
00272     widget = gtk_vbox_new(FALSE, 2 * BACKGROUNDSCREEN_ITEM_SPACING);
00273     gtk_container_add(GTK_CONTAINER(alignment), widget);
00274     gtk_widget_show(widget);
00275     vbox = widget;
00276     
00277     // g_background_idspc_label
00278     widget = gtk_label_new("");
00279     gtk_widget_set_name(widget, "background_screen_info_text");
00280     gtk_widget_set_size_request(widget, BACKGROUND_ONOFF_LABEL_WIDTH, (-1));
00281     gtk_label_set_single_line_mode(GTK_LABEL(widget), FALSE);
00282     gtk_label_set_line_wrap(GTK_LABEL(widget), TRUE);
00283     gtk_label_set_justify(GTK_LABEL(widget), GTK_JUSTIFY_LEFT);
00284     gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
00285     gtk_widget_show(widget);
00286     g_background_idspc_label = widget;
00287 
00288     // hbox
00289     widget = gtk_hbox_new(FALSE, SMALL_BUTTON_SPACING);
00290     gtk_container_add(GTK_CONTAINER(vbox), widget);
00291     gtk_widget_show(widget);
00292     hbox = widget;
00293     //     g_background_button_ids
00294     widget = ergtk_toggle_button_new_with_label("");
00295     gtk_widget_set_size_request(GTK_WIDGET(widget), SMALL_BUTTON_WIDTH, SMALL_BUTTON_HEIGHT);
00296     gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
00297     gtk_widget_show(widget);
00298     g_background_button_ids = widget;
00299     //     g_background_button_pc
00300     widget = ergtk_toggle_button_new_with_label("");
00301     gtk_widget_set_size_request(GTK_WIDGET(widget), SMALL_BUTTON_WIDTH, SMALL_BUTTON_HEIGHT);
00302     gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
00303     gtk_widget_show(widget);
00304     g_background_button_pc = widget;
00305     // add details to selection
00306     button_tbl[0] = GTK_TOGGLE_BUTTON(g_background_button_ids);
00307     button_tbl[1] = GTK_TOGGLE_BUTTON(g_background_button_pc );
00308     button_tbl[2] = NULL;
00309     g_background_ids = 0;  // selection-group counts from 0
00310     g_background_pc  = 1;
00311     // g_background_idspc_selection
00312     widget = ergtk_selection_group_new(button_tbl);
00313     gtk_widget_set_name(widget, "background_idspc_background");
00314     ergtk_selection_group_set_details(ERGTK_SELECTION_GROUP(widget), 1, 1);
00315     gtk_widget_set_size_request(GTK_WIDGET(widget), -1, BACKGROUND_IDSPC_REQ_HEIGHT);
00316     g_signal_connect(G_OBJECT(widget), "selection-update", G_CALLBACK(on_background_idspc_selection_update), NULL);
00317     gtk_container_add(GTK_CONTAINER(widget), alignment);
00318     gtk_settingitem_add_details(GTK_SETTINGITEM(g_background_idspc), widget);
00319     gtk_widget_show(widget);
00320     g_background_idspc_selection = widget;
00321 
00322     return g_background_idspc;
00323 }
00324 
00325 
00326 
00327 // object hierarchy:
00328 //     g_background_onoff (GtkSettingItem)
00329 //       |-- g_background_onoff_selection
00330 //             |-- alignment
00331 //                   |--vbox
00332 //                        |-- g_background_onoff_label (GtkLabel)
00333 //                        |-- hbox
00334 //                              |-- g_background_button_on
00335 //                              |-- g_background_button_off
00336 //
00337 static GtkWidget* create_background_onoff(void)
00338 {
00339     GtkWidget*       widget;
00340     GtkWidget*       alignment;
00341     GtkWidget*       vbox;
00342     GtkWidget*       hbox;
00343     GtkToggleButton* button_tbl[3];
00344 
00345     // g_background_onoff
00346     widget = gtk_settingitem_new("");
00347     gtk_widget_set_size_request(widget, (-1), (-1));
00348     gtk_widget_show(widget);
00349     g_background_onoff = widget;
00350 
00351     // g_background_onoff_selection --> see below
00352 
00353     // alignment
00354     widget = gtk_alignment_new(0, 0, 0, 0);
00355     gtk_alignment_set_padding(GTK_ALIGNMENT(widget),
00356                               BACKGROUND_ITEM_PADDING_TOP,
00357                               BACKGROUND_ITEM_PADDING_BOTTOM,
00358                               BACKGROUND_ITEM_PADDING_LEFT,
00359                               BACKGROUND_ITEM_PADDING_RIGHT);
00360     gtk_widget_show(widget);
00361     alignment = widget;
00362 
00363     // vbox
00364     widget = gtk_vbox_new(FALSE, 2 * BACKGROUNDSCREEN_ITEM_SPACING);
00365     gtk_container_add(GTK_CONTAINER(alignment), widget);
00366     gtk_widget_show(widget);
00367     vbox = widget;
00368     
00369     // g_background_onoff_label
00370     widget = gtk_label_new("");
00371     gtk_widget_set_name(widget, "background_screen_info_text");
00372     gtk_widget_set_size_request(widget, BACKGROUND_ONOFF_LABEL_WIDTH, (-1));
00373     gtk_label_set_single_line_mode(GTK_LABEL(widget), FALSE);
00374     gtk_label_set_line_wrap(GTK_LABEL(widget), TRUE);
00375     gtk_label_set_justify(GTK_LABEL(widget), GTK_JUSTIFY_LEFT);
00376     gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
00377     gtk_widget_show(widget);
00378     g_background_onoff_label = widget;
00379 
00380     // hbox
00381     widget = gtk_hbox_new(FALSE, SMALL_BUTTON_SPACING);
00382     gtk_container_add(GTK_CONTAINER(vbox), widget);
00383     gtk_widget_show(widget);
00384     hbox = widget;
00385     //     g_background_button_on
00386     widget = ergtk_toggle_button_new_with_label("");
00387     gtk_widget_set_size_request(GTK_WIDGET(widget), SMALL_BUTTON_WIDTH, SMALL_BUTTON_HEIGHT);
00388     gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
00389     gtk_widget_show(widget);
00390     g_background_button_on = widget;
00391     //     g_background_button_off
00392     widget = ergtk_toggle_button_new_with_label("");
00393     gtk_widget_set_size_request(GTK_WIDGET(widget), SMALL_BUTTON_WIDTH, SMALL_BUTTON_HEIGHT);
00394     gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
00395     gtk_widget_show(widget);
00396     g_background_button_off = widget;
00397     // add details to selection
00398     button_tbl[0] = GTK_TOGGLE_BUTTON(g_background_button_on );
00399     button_tbl[1] = GTK_TOGGLE_BUTTON(g_background_button_off);
00400     button_tbl[2] = NULL;
00401     g_background_on  = 0;  // selection-group counts from 0
00402     g_background_off = 1;
00403     // g_background_onoff_selection
00404     widget = ergtk_selection_group_new(button_tbl);
00405     gtk_widget_set_name(widget, "background_onoff_background");
00406     ergtk_selection_group_set_details(ERGTK_SELECTION_GROUP(widget), 1, 1);
00407     gtk_widget_set_size_request(GTK_WIDGET(widget), -1, BACKGROUND_ONOFF_REQ_HEIGHT);
00408     g_signal_connect(G_OBJECT(widget), "selection-update", G_CALLBACK(on_background_onoff_selection_update), NULL);
00409     gtk_container_add(GTK_CONTAINER(widget), alignment);
00410     gtk_settingitem_add_details(GTK_SETTINGITEM(g_background_onoff), widget);
00411     gtk_widget_show(widget);
00412     g_background_onoff_selection = widget;
00413 
00414     return g_background_onoff;
00415 }
00416 
00417 // object hierarchy:
00418 //     g_background_interval (GtkSettingItemTextEntry)
00419 //
00420 static GtkWidget* create_background_interval(void)
00421 {
00422     ST_LOGPRINTF("entry");
00423 
00424     GtkWidget *widget;
00425 
00426     // g_background_interval_entry
00427     widget = gtk_settingitem_textentry_new();
00428     gtk_settingitem_textentry_setentrywidth(GTK_SETTINGITEM_TEXTENTRY(widget), BACKGROUND_INTERVAL_ENTRY_WIDTH);
00429     gtk_widget_show(widget);
00430     g_background_interval = widget;
00431     //     signal callback
00432     gtk_settingitem_textentry_callback_on_validate(GTK_SETTINGITEM_TEXTENTRY(widget), on_interval_validate);
00433 
00434     return g_background_interval;
00435 }
00436 
00437 
00438 // object hierarchy:
00439 //     g_background_info (GtkInfoItem)
00440 //
00441 static GtkWidget* create_background_info(void)
00442 {
00443     ST_LOGPRINTF("entry");
00444 
00445     // g_background_info
00446     g_background_info = gtk_infoitem_new(FALSE);
00447 
00448     // display
00449     gtk_widget_show(g_background_info);
00450 
00451     return g_background_info;
00452 }
00453 
00454 
00455 void iLiad_autoconnect_set_text(void)
00456 {
00457     gchar *cp;
00458     
00459     ST_LOGPRINTF("entry");
00460 
00461     // wlan onoff  
00462     if (g_wlan_onoff)
00463     {
00464         gtk_settingitem_set_header_text( GTK_SETTINGITEM(g_wlan_onoff),
00465                                          _("Wireless connection preferences")   );
00466         gtk_label_set_text (GTK_LABEL(g_wlan_onoff_label),
00467                             _("Select whether to automatically connect to "
00468                               "a non-secured (open) wireless network.") );
00469         gtk_button_set_label(GTK_BUTTON(g_wlan_button_on ), _("On") );
00470         gtk_button_set_label(GTK_BUTTON(g_wlan_button_off), _("Off"));
00471     }
00472 
00473     // background-connect iDS/pc selection
00474     if (g_background_idspc)
00475     {
00476         gtk_settingitem_set_header_text( GTK_SETTINGITEM(g_background_idspc),
00477                                          _("Background connect")   );
00478         gtk_label_set_text (GTK_LABEL(g_background_idspc_label),
00479                             _("Select whether to download content from the iDS or a computer.") );
00480         gtk_button_set_label(GTK_BUTTON(g_background_button_ids), _("iDS")     );
00481         gtk_button_set_label(GTK_BUTTON(g_background_button_pc ), _("Computer"));
00482     }
00483 
00484     // background-connect enable
00485     if (g_background_onoff)
00486     {
00487         gtk_settingitem_set_header_text( GTK_SETTINGITEM(g_background_onoff),
00488                                          _("Automatic background connect")   );
00489         gtk_label_set_text (GTK_LABEL(g_background_onoff_label),
00490                             _("Enabling \"Automatic background connect\" "
00491                               "causes the iLiad to receive or send content items "
00492                               "at a fixed interval.") );
00493         gtk_button_set_label(GTK_BUTTON(g_background_button_on ), _("On") );
00494         gtk_button_set_label(GTK_BUTTON(g_background_button_off), _("Off"));
00495     }
00496 
00497     // background-connect interval
00498     if (g_background_interval)
00499     {
00500         gtk_settingitem_textentry_setlabel(GTK_SETTINGITEM_TEXTENTRY(g_background_interval),
00501                                            _("Enter the time interval for the background connect.") );
00502         cp = g_strdup_printf( _("minutes (min. %d, max. %d)"), BACKGROUND_MIN_INTERVAL, BACKGROUND_MAX_INTERVAL);
00503         gtk_settingitem_textentry_setinfo(GTK_SETTINGITEM_TEXTENTRY(g_background_interval), cp);
00504         g_free(cp);
00505     }
00506     
00507     // background-connect help text
00508     if (g_background_info)
00509     {
00510         gtk_infoitem_set_text( GTK_INFOITEM(g_background_info),
00511                                _("During the background connection you can operate the iLiad as usual.\n"
00512                                  "\n"
00513                                  "Warning!\n"
00514                                  "Background connect will empty your battery faster.") );
00515     }
00516 }
00517 
00518 void iLiad_ac_set_wlan_onoff(const gboolean enable)
00519 {
00520     ST_LOGPRINTF("entry: enable [%d]", enable);
00521 
00522     if (enable)
00523     {
00524         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_wlan_button_on), TRUE);
00525     }
00526     else
00527     {
00528         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_wlan_button_off), TRUE);
00529     }
00530 }
00531 
00532 static gboolean iLiad_background_get_wlan_onoff(void)
00533 {
00534     erGtkSelectionGroup *selection;
00535     gint selection_id;
00536     gboolean returnValue = TRUE;  // none selected
00537 
00538     selection = ERGTK_SELECTION_GROUP(g_wlan_onoff_selection);
00539     ergtk_selection_group_get_selected_buttons(selection, &selection_id, 1);
00540 
00541     if (g_wlan_on == selection_id)
00542     {
00543         ST_LOGPRINTF("enable connect with open wireless network");
00544         returnValue = TRUE;
00545     }
00546     else if (g_wlan_off == selection_id)
00547     {
00548         ST_LOGPRINTF("disable connect with open wireless network");
00549         returnValue = FALSE;
00550     }
00551     else
00552     {
00553         ST_ERRORPRINTF("invalid wlan on/off [%d]", selection_id);
00554         //terminate application if this point is reached
00555         g_assert_not_reached();
00556     }
00557 
00558     return returnValue;
00559 }
00560 
00561 void iLiad_ac_set_background_idspc(const gint connect_to)
00562 {
00563     ST_LOGPRINTF("entry: connect_to [%d]", connect_to);
00564 
00565     switch (connect_to)
00566     {
00567         case 0:
00568             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_background_button_ids), TRUE);
00569             break;
00570         case 1:
00571             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_background_button_pc), TRUE);
00572             break;
00573         default:
00574             ST_ERRORPRINTF("Illegal connect_to [%d]", connect_to);
00575     }
00576 }
00577 
00578 static gint iLiad_background_get_idspc(void)
00579 {
00580     gint selection_id;
00581     gint returnValue = -1;  // none selected
00582 
00583     ergtk_selection_group_get_selected_buttons(ERGTK_SELECTION_GROUP(g_background_idspc_selection), &selection_id, 1);
00584 
00585     if (g_background_ids == selection_id)
00586     {
00587         ST_LOGPRINTF("connect_to iDS");
00588         returnValue = 0;
00589     }
00590     else if (g_background_pc == selection_id)
00591     {
00592         ST_LOGPRINTF("connect_to PC-share");
00593         returnValue = 1;
00594     }
00595     else
00596     {
00597         ST_ERRORPRINTF("invalid background ids/pc [%d]", selection_id);
00598         //terminate application if this point is reached
00599         g_assert_not_reached();
00600     }
00601     return returnValue;
00602 }
00603 
00604 // set/get functions
00605 void iLiad_ac_set_background_onoff(const gboolean enable)
00606 {
00607     ST_LOGPRINTF("entry: enable [%d]", enable);
00608 
00609     if (enable)
00610     {
00611         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_background_button_on), TRUE);
00612         gtk_widget_show(g_background_interval);
00613         gtk_settingitem_textentry_grabfocus(GTK_SETTINGITEM_TEXTENTRY(g_background_interval));
00614         gtk_widget_hide(g_background_info);
00615     }
00616     else
00617     {
00618         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_background_button_off), TRUE);
00619         gtk_widget_hide(g_background_interval);
00620         gtk_widget_show(g_background_info);
00621     }
00622 }
00623 
00624 static gboolean iLiad_background_get_onoff(void)
00625 {
00626     gint selection_id;
00627     gboolean returnValue = FALSE;
00628 
00629     ergtk_selection_group_get_selected_buttons(ERGTK_SELECTION_GROUP(g_background_onoff_selection), &selection_id, 1);
00630 
00631     if (g_background_on == selection_id)
00632     {
00633         ST_LOGPRINTF("PIN code on");
00634         returnValue = TRUE;
00635     }
00636     else if (g_background_off == selection_id)
00637     {
00638         ST_LOGPRINTF("PIN code off");
00639         returnValue = FALSE;
00640     }
00641     else
00642     {
00643         ST_ERRORPRINTF("invalid background on/off %d", selection_id);
00644         //terminate application if this point is reached
00645         g_assert_not_reached();
00646     }
00647     return returnValue;
00648 }
00649 
00650 void iLiad_ac_set_background_interval(const gint interval)
00651 {
00652     ST_LOGPRINTF("entry: interval [%d]", interval);
00653 
00654     char buf[10];
00655     snprintf(buf, sizeof(buf), "%d", interval);
00656 
00657     gtk_settingitem_textentry_settext(GTK_SETTINGITEM_TEXTENTRY(g_background_interval), buf);
00658 }
00659 
00660 static void on_wlan_onoff_selection_update(erGtkSelectionGroup* selection, 
00661                                            gpointer button,
00662                                            gpointer data)
00663 {
00664     gboolean enable = iLiad_background_get_wlan_onoff();
00665 
00666     ST_LOGPRINTF("enable [%d]", enable);
00667 
00668     // store new value
00669     iLiad_ac_wlan_onoff_changed(enable);
00670 
00671     display_update_request_screen_refresh(SETTING_ITEM_CHANGE, WAVEFORM_FULLSCREEN);
00672 }
00673 
00674 static void on_background_idspc_selection_update(erGtkSelectionGroup* selection, 
00675                                                  gpointer button,
00676                                                  gpointer data)
00677 {
00678     guint connect_to = iLiad_background_get_idspc();
00679 
00680     ST_LOGPRINTF("connect-to [%d]", connect_to);
00681 
00682     // store new value
00683     iLiad_ac_background_idspc_changed(connect_to);
00684 
00685     display_update_request_screen_refresh(SETTING_ITEM_CHANGE, WAVEFORM_FULLSCREEN);
00686 }
00687 
00688 // callback functions
00689 static void on_background_onoff_selection_update(erGtkSelectionGroup* selection, 
00690                                                  gpointer button, 
00691                                                  gpointer data)
00692 {
00693     gboolean enable = iLiad_background_get_onoff();
00694 
00695     ST_LOGPRINTF("background %s", enable == 0 ? "OFF" : "ON");
00696 
00697     // show/hide interval setting
00698     if (enable)
00699     {
00700         gtk_widget_show(g_background_interval);
00701         gtk_settingitem_textentry_grabfocus(GTK_SETTINGITEM_TEXTENTRY(g_background_interval));
00702         gtk_widget_hide(g_background_info);
00703     }
00704     else
00705     {
00706         gtk_widget_hide(g_background_interval);
00707         gtk_widget_show(g_background_info);
00708     }
00709 
00710     // store new value
00711     iLiad_ac_background_onoff_changed(enable);
00712 
00713     display_update_request_screen_refresh(SETTING_ITEM_CHANGE, WAVEFORM_FULLSCREEN);
00714 }
00715 
00716 static void on_interval_validate(GtkWidget* item, const gchar* text, gchar** new_text)
00717 {
00718     ST_LOGPRINTF("entry: item [%p] text [%s]", item, text);
00719 
00720     char  buf[10];
00721     gint  time_value;
00722 
00723     time_value = atoi(text);
00724 
00725     // validate & fix background interval time
00726     if (time_value < 0)
00727     {
00728         // illegal time
00729         time_value = BACKGROUND_DEFAULT_INTERVAL;
00730     }
00731     else if (time_value < BACKGROUND_MIN_INTERVAL)
00732     {
00733         time_value = BACKGROUND_MIN_INTERVAL;
00734     }
00735     else if (time_value > BACKGROUND_MAX_INTERVAL)
00736     {
00737         time_value = BACKGROUND_MAX_INTERVAL;
00738     }
00739     snprintf(buf, sizeof(buf), "%d", time_value);
00740 
00741     // report fixed interval, if needed
00742     if ( strcmp(buf, text) != 0 )
00743     {
00744         *new_text = strdup(buf);
00745     }
00746 
00747     // store new interval
00748     iLiad_ac_background_interval_changed(time_value);
00749 }
00750