connectionMgr/src/editScreenWireless.c Source File

00001 /*
00002  * This file is part of connectionMgr.
00003  *
00004  * connectionMgr 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  * connectionMgr 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 
00026 #include "config.h"
00027 
00028 #include <string.h>
00029 
00030 #include <gtk/gtk.h>
00031 
00032 #include <liberdm/connectionMgrConstants.h>
00033 #include <liberdm/display.h>
00034 #include <liberregxml/erregapi.h>
00035 #include <libergtk/ergtk.h>
00036 
00037 #include "connectionMgrLog.h"
00038 #include "displayStatus.h"
00039 #include "erbusy.h"
00040 #include "background.h"
00041 #include "connectionMgr.h"
00042 #include "gtkSettingItem.h"
00043 #include "gtkInfoItem.h"
00044 #include "widgetUtils.h"
00045 #include "connectScreen.h"
00046 #include "connectScreenData.h"
00047 #include "editScreen.h"
00048 #include "editScreenOverview.h"
00049 #include "editScreenWireless.h"
00050 #include "connectScan.h"
00051 #include "connectBackground.h"
00052 #include "languages.h"
00053 
00054 typedef enum
00055 {
00056     inputSSID_e,
00057     inputEncrType_e,
00058     inputEncrKeyWEP_e,
00059     inputEncrKeyWPA_e,
00060     wlanInputProfileName_e,
00061     wlanConnecting_e,
00062     wlanConnected_e,
00063     wlanUnconnected_e,
00064     wlanAborting_e,
00065     wlanAborted_e,
00066     undefWlanStatus_e
00067 }wlanStatus_t;
00068 
00069 // screen objects
00070 static GtkWidget* g_wireless = NULL;
00071 
00072 static bkWdtLabelEntry  *g_ssid = NULL;
00073 static bkWdtLabelButton *g_encrtype = NULL;
00074 static bkWdtLabelEntry  *g_encrkey = NULL;
00075 static bkWdtLabelEntry  *g_profilename = NULL;
00076 static bkWdtLabelButton *g_buttons = NULL;
00077 
00078 static GtkWidget *g_info = NULL;
00079 
00080 static wlanStatus_t g_wlan_status = undefWlanStatus_e;
00081 
00082 static network_spec_t* g_found_network = NULL;
00083 
00084 static regWirelessSetting_t *g_old_settings = NULL;
00085 static char *g_old_profilename = NULL;
00086 
00087 static void edit_wireless_set_status(wlanStatus_t status);
00088 
00089 static void on_ssid_changed(GtkEntry *widget, gpointer data);
00090 static void on_ssid_next(GtkToggleButton *button, gpointer data);
00091 
00092 static void on_encrtype_update(GtkWidget *selection, 
00093                                gpointer button, 
00094                                gpointer data);
00095 
00096 static void on_encrkey_changed(GtkEntry *widget, gpointer data);
00097 
00098 static void on_profilename_changed(GtkEntry *widget, gpointer data);
00099 static void on_profilename_next(GtkToggleButton *button, gpointer data);
00100 
00101 static void on_buttons_update(GtkWidget *selection, 
00102                               gpointer button, 
00103                               gpointer data);
00104 
00105 static gboolean delayed_deactive_button(gpointer data);
00106 
00107 static void on_test(void);
00108 static void on_save(void);
00109 static void on_saveconnect(void);
00110 
00111 static void edit_wireless_restore_scan_ctxt(void);
00112 static void scan_done(connection_t networkType, 
00113                   network_spec_t* pScanNetworks, 
00114                   int nScanNetworks);
00115 static void scan_done_after(void);
00116 static void edit_wireless_restore_ping_ctxt(void);
00117 static void on_connected(int profileIndex);
00118 static void on_failed(void);
00119 static void ui_update_status(int profileIndex, pingStatus_t status);
00120 static void ui_display_settings(int profileIndex, gboolean resetStatus);
00121 static void ui_select_profile(int profileIndex);
00122 static void ui_unselect_all_profile(void);
00123 
00124 static void edit_wireless_freeze_ui(gboolean freeze);
00125 
00127 // create widgets
00129 
00130 // 
00131 // |--item (GtkSettingsIem)
00132 //    |--vbox
00133 //       |--ssid        (bkWdtLabelEntry)
00134 //       |--encrtype    (bkWdtLabelButton)
00135 //       |--encrkey     (bkWdtLabelEntry)
00136 //       |--profilename (bkWdtLabelEntry)
00137 //       |--buttons     (bkWdtLabelButton)
00138 //       |--info        (GtkInfoItem) 
00139 //
00140 GtkWidget *edit_wireless_create(void)
00141 {
00142     GtkWidget *item;
00143     GtkWidget *vbox;
00144     bkWdtLabelEntry  *ssid;
00145     bkWdtLabelButton *encrtype;
00146     bkWdtLabelEntry  *encrkey;
00147     bkWdtLabelEntry  *profilename;
00148     bkWdtLabelButton *buttons;
00149     GtkWidget *info;
00150     GtkWidget *widget;
00151 
00152     CN_LOGPRINTF("entry");
00153 
00154     // item
00155     item = gtk_settingitem_new("");
00156 
00157     // vbox
00158     vbox = gtk_vbox_new(FALSE, VBOX_SPACING);
00159     gtk_settingitem_add_details(GTK_SETTINGITEM(item), vbox);
00160 
00161     // ssid
00162     ssid = bk_wdt_label_entry_new(string_e);
00163     gtk_box_pack_start(GTK_BOX(vbox), ssid->background, FALSE, FALSE, 0);
00164 
00165     // encrtype
00166     encrtype = bk_wdt_label_button_new(3, TRUE, 0, 1);
00167     gtk_box_pack_start(GTK_BOX(vbox), encrtype->background, 
00168                        FALSE, FALSE, 0);
00169 
00170     // encrkey
00171     encrkey = bk_wdt_label_entry_new(string_e);
00172     gtk_entry_set_visibility(GTK_ENTRY(encrkey->details->entry), FALSE); 
00173     gtk_box_pack_start(GTK_BOX(vbox), encrkey->background, 
00174                        FALSE, FALSE, 0);
00175 
00176     // profilename
00177     profilename = bk_wdt_label_entry_new(string_e);
00178     gtk_box_pack_start(GTK_BOX(vbox), profilename->background, 
00179                        FALSE, FALSE, 0);
00180 
00181     // buttons
00182     buttons = bk_wdt_label_button_new(3, FALSE, 0, 1);
00183     gtk_box_pack_start(GTK_BOX(vbox), buttons->background, 
00184                        FALSE, FALSE, 0);
00185 
00186     // info
00187     info = gtk_infoitem_new(FALSE);
00188     gtk_box_pack_start(GTK_BOX(vbox), info, FALSE, FALSE, 0);
00189 
00190     // signal handlers
00191     widget = ssid->details->entry;
00192     g_signal_connect_after(G_OBJECT(widget), "changed-stable", 
00193                            G_CALLBACK(on_ssid_changed), NULL);
00194     widget = ssid->details->button;
00195     g_signal_connect_after(G_OBJECT(widget), "toggled", 
00196                            G_CALLBACK(on_ssid_next), NULL);
00197 
00198     widget = GTK_WIDGET(encrtype->details->selection);
00199     g_signal_connect(G_OBJECT(widget), "selection-update",
00200                      G_CALLBACK(on_encrtype_update), NULL);
00201     
00202     widget = encrkey->details->entry;
00203     g_signal_connect_after(G_OBJECT(widget), "changed-stable", 
00204                            G_CALLBACK(on_encrkey_changed), NULL);
00205 
00206     widget = profilename->details->entry;
00207     g_signal_connect_after(G_OBJECT(widget), "changed-stable", 
00208                            G_CALLBACK(on_profilename_changed), NULL);
00209     widget = profilename->details->button;
00210     g_signal_connect_after(G_OBJECT(widget), "toggled", 
00211                            G_CALLBACK(on_profilename_next), NULL);
00212 
00213     widget = GTK_WIDGET(buttons->details->selection);
00214     g_signal_connect(G_OBJECT(widget), "selection-update",
00215                      G_CALLBACK(on_buttons_update), NULL);
00216 
00217     // show widgets
00218     gtk_widget_show(item);
00219     gtk_widget_show(vbox);
00220     gtk_widget_show(ssid->background);
00221     gtk_widget_show(encrtype->background);
00222     gtk_widget_show(encrkey->background);
00223     gtk_widget_hide(encrkey->details->button);
00224     gtk_widget_show(profilename->background);
00225     gtk_widget_show(buttons->background);
00226     gtk_widget_show(info);
00227 
00228     // global variables
00229     g_wireless = item;
00230     g_ssid = ssid;
00231     g_encrtype = encrtype;
00232     g_encrkey = encrkey;
00233     g_profilename = profilename;
00234     g_buttons = buttons;
00235     g_info = info;
00236 
00237     CN_LOGPRINTF("done");
00238 
00239     // return
00240     return item;
00241  }
00242 
00243 static void edit_wireless_show_widgets(wlanStatus_t mode)
00244 {
00245     wireless_encr_type_t encrtype;
00246 
00247     CN_LOGPRINTF("entry mode[%d]", mode);
00248 
00249     switch (mode)
00250     {
00251         case inputSSID_e:
00252             gtk_widget_show(g_ssid->background);
00253             gtk_widget_show(g_ssid->details->button);
00254             gtk_widget_hide(g_encrtype->background);
00255             gtk_widget_hide(g_encrkey->background);
00256             gtk_widget_hide(g_profilename->background);
00257             gtk_widget_hide(g_buttons->background);
00258             gtk_widget_grab_focus(g_ssid->details->entry);
00259             break;
00260         case inputEncrType_e:
00261             gtk_widget_show(g_ssid->background);
00262             gtk_widget_hide(g_ssid->details->button);
00263             gtk_widget_show(g_encrtype->background);
00264             gtk_widget_hide(g_encrkey->background);
00265             gtk_widget_hide(g_profilename->background);
00266             gtk_widget_hide(g_buttons->background);
00267             break;
00268         case inputEncrKeyWEP_e:
00269         case inputEncrKeyWPA_e:
00270             gtk_widget_show(g_ssid->background);
00271             gtk_widget_hide(g_ssid->details->button);
00272             gtk_widget_show(g_encrtype->background);
00273             gtk_widget_show(g_encrkey->background);
00274             gtk_widget_show(g_profilename->background);
00275             gtk_widget_show(g_buttons->background);
00276             gtk_widget_grab_focus(g_encrkey->details->entry);
00277             break;
00278         case wlanInputProfileName_e:
00279         case undefWlanStatus_e:
00280         default:
00281             gtk_widget_show(g_ssid->background);
00282             gtk_widget_hide(g_ssid->details->button);
00283             gtk_widget_show(g_encrtype->background); 
00284             encrtype = edit_wireless_get_encrtype();
00285             if (encrtype == encr_none_t)
00286             {
00287                 gtk_widget_hide(g_encrkey->background);
00288             }
00289             else
00290             {
00291                 gtk_widget_show(g_encrkey->background);
00292             }
00293             gtk_widget_show(g_profilename->background);
00294             gtk_widget_show(g_buttons->background);
00295             gtk_widget_grab_focus(g_profilename->details->entry);
00296             break;
00297     }
00298 }
00299 
00300 void edit_wireless_enable_save_button(gboolean enable)
00301 {
00302     GtkWidget *widget;
00303 
00304     CN_LOGPRINTF("entry %d", enable);
00305     
00306     if (g_buttons)
00307     {
00308         widget = GTK_WIDGET(g_buttons->details->buttonList[1]);
00309         gtk_widget_set_sensitive(widget, enable);
00310     }
00311 }
00312 
00313 void edit_wireless_set_text (void)
00314 {
00315     GtkWidget *widget;
00316 
00317     CN_LOGPRINTF("entry");
00318 
00319     if (g_wireless)
00320     {
00321         gtk_settingitem_set_header_text(GTK_SETTINGITEM(g_wireless), 
00322                                         _("Network profile"));
00323     }
00324 
00325     if (g_ssid)
00326     {
00327         widget = g_ssid->details->label;
00328         gtk_label_set_text(GTK_LABEL(widget), 
00329                 _("Type the network name (SSID) and click 'Next'."));
00330     
00331         widget = g_ssid->details->button;
00332         gtk_button_set_label(GTK_BUTTON(widget), _("Next"));
00333     }
00334 
00335     if (g_encrtype)
00336     {
00337         widget = g_encrtype->details->label;
00338         gtk_label_set_text(GTK_LABEL(widget), 
00339                 _("Select the security type of this wireless network."));
00340 
00341         widget = GTK_WIDGET(g_encrtype->details->buttonList[0]);
00342         gtk_button_set_label(GTK_BUTTON(widget), _("Off"));
00343         
00344         widget = GTK_WIDGET(g_encrtype->details->buttonList[1]);
00345         gtk_button_set_label(GTK_BUTTON(widget), _("WEP"));
00346         
00347         widget = GTK_WIDGET(g_encrtype->details->buttonList[2]);
00348         gtk_button_set_label(GTK_BUTTON(widget), _("WPA"));
00349     }
00350 
00351     if (g_encrkey)
00352     {
00353         widget = g_encrkey->details->label;
00354         gtk_label_set_text(GTK_LABEL(widget),
00355                 _("Enter the security key / passphrase:"));
00356     }
00357 
00358     if (g_profilename)
00359     {
00360         widget = g_profilename->details->label;
00361         gtk_label_set_text(GTK_LABEL(widget),
00362                 _("You can personalize the profile name."));
00363 
00364         widget = g_profilename->details->button;
00365         gtk_button_set_label(GTK_BUTTON(widget), _("Next"));
00366     }
00367     
00368     if (g_buttons)
00369     {
00370         widget = g_buttons->details->label;
00371         gtk_label_set_text(GTK_LABEL(widget),
00372                 _("Select an action for this profile."));
00373 
00374         widget = GTK_WIDGET(g_buttons->details->buttonList[0]);
00375         gtk_button_set_label(GTK_BUTTON(widget), _("Test"));
00376 
00377         widget = GTK_WIDGET(g_buttons->details->buttonList[1]);
00378         gtk_button_set_label(GTK_BUTTON(widget), _("Save"));
00379 
00380         widget = GTK_WIDGET(g_buttons->details->buttonList[2]);
00381         gtk_button_set_label(GTK_BUTTON(widget), _("Save & Connect"));
00382     }    
00383 }
00384 
00385 static void edit_wireless_update_info_text(wlanStatus_t status)
00386 {
00387     CN_LOGPRINTF("entry");
00388 
00389     g_return_if_fail(g_info != NULL);
00390 
00391     switch (status)
00392     {
00393         case inputSSID_e:
00394             gtk_infoitem_set_icon(GTK_INFOITEM(g_info), iconInfo_e); 
00395             gtk_infoitem_set_text(GTK_INFOITEM(g_info),
00396                 _("If you do not know the network name "
00397                   "for this access point, "
00398                   "please ask your network administrator."));
00399             break;
00400         case inputEncrType_e:
00401             gtk_infoitem_set_icon(GTK_INFOITEM(g_info), iconInfo_e); 
00402             gtk_infoitem_set_text(GTK_INFOITEM(g_info),
00403                 _("Click 'Off' for a non secured network "
00404                   "or choose the security type of "
00405                   "your network.\n"
00406                   "Both 'WEP' and 'WPA' requires a security key."));
00407             break;
00408         case inputEncrKeyWEP_e:
00409             gtk_infoitem_set_icon(GTK_INFOITEM(g_info), iconInfo_e); 
00410             gtk_infoitem_set_text(GTK_INFOITEM(g_info),
00411                 _("For WEP, set your local router device to a HEX key.\n"
00412                   "Hint: If you do not know the security key "
00413                   "for this network, "
00414                   "please ask your network adminitrator."));
00415             break;
00416         case inputEncrKeyWPA_e:
00417             gtk_infoitem_set_icon(GTK_INFOITEM(g_info), iconInfo_e); 
00418             gtk_infoitem_set_text(GTK_INFOITEM(g_info),
00419                 _("For WPA, set your router to PSK mode with TKIP.\n"
00420                   "Hint: If you do not know the security key "
00421                   "for this network, "
00422                   "please ask your network administrator."));
00423             break;
00424         case wlanInputProfileName_e:
00425         case undefWlanStatus_e:
00426             gtk_infoitem_set_icon(GTK_INFOITEM(g_info), iconInfo_e); 
00427             gtk_infoitem_set_text(GTK_INFOITEM(g_info),
00428                 _("If you personalize the profile name, "
00429                   "it will be easy to recognize "
00430                   "in the iLiad's network profile list.\n"
00431                   "Click 'Next' for more advanced settings."));
00432             break;
00433         case wlanConnecting_e:
00434             gtk_infoitem_set_icon(GTK_INFOITEM(g_info), iconInfo_e); 
00435             gtk_infoitem_set_text(GTK_INFOITEM(g_info),
00436                 _("The iLiad is trying to connect to the server."));
00437             break;
00438         case wlanConnected_e:
00439             gtk_infoitem_set_icon(GTK_INFOITEM(g_info), iconOk_e); 
00440             gtk_infoitem_set_text(GTK_INFOITEM(g_info),
00441                     _("Connection to the server established."));
00442             break;
00443         case wlanUnconnected_e:
00444             gtk_infoitem_set_icon(GTK_INFOITEM(g_info), iconFailed_e); 
00445             gtk_infoitem_set_text(GTK_INFOITEM(g_info),
00446                     _("Connection to server "
00447                       "can not been established correctly."));
00448             break;
00449         case wlanAborting_e:
00450             gtk_infoitem_set_icon(GTK_INFOITEM(g_info), iconInfo_e); 
00451             gtk_infoitem_set_text(GTK_INFOITEM(g_info), 
00452                 _("The iLiad is aborting the connection."));
00453             break;
00454         case wlanAborted_e:
00455             gtk_infoitem_set_icon(GTK_INFOITEM(g_info), iconInfo_e);
00456             gtk_infoitem_set_text(GTK_INFOITEM(g_info), 
00457                 _("The connection has been aborted."));
00458             break;
00459 
00460         default:
00461             break;
00462     }
00463 }
00464 
00465 // return undefWlanStatus_e means all fields have been fill in
00466 static wlanStatus_t edit_wireless_detect_status(void)
00467 {
00468     erGtkEntry *ssid, *encrkey, *profilename;
00469     wireless_encr_type_t encrtype;
00470     wlanStatus_t status = undefWlanStatus_e;
00471 
00472     CN_LOGPRINTF("entry");
00473 
00474     ssid = ERGTK_ENTRY(g_ssid->details->entry);
00475     encrtype = edit_wireless_get_encrtype();
00476     profilename = ERGTK_ENTRY(g_profilename->details->entry);
00477     encrkey = ERGTK_ENTRY(g_encrkey->details->entry);
00478 
00479     if (!ergtk_entry_check_field(ssid))
00480     {
00481         status = inputSSID_e;
00482     }
00483     else if (encrtype == encr_undefined_t)
00484     {
00485         status = inputEncrType_e;
00486     }
00487     else if (encrtype == encr_none_t)
00488     {
00489         if (!ergtk_entry_check_field(profilename))
00490         {
00491             status = wlanInputProfileName_e;
00492         }
00493     }
00494     else if (!ergtk_entry_check_field(encrkey))
00495     {
00496         if (encrtype == encr_wep_t)
00497         {
00498             status = inputEncrKeyWEP_e;
00499         }
00500         else if (encrtype == encr_wpa_t)
00501         {
00502             status = inputEncrKeyWPA_e;
00503         }
00504     }
00505     else if (!ergtk_entry_check_field(profilename))
00506     {
00507         status = wlanInputProfileName_e;
00508     }
00509 
00510     CN_LOGPRINTF("return %d", status);
00511     return status;
00512 }
00513 
00514 void edit_wireless_determine_status(void)
00515 {
00516     wlanStatus_t status;
00517 
00518     status = edit_wireless_detect_status();
00519     edit_wireless_set_status(status);
00520 }
00521 
00522 static gboolean on_delay_determine_status(gpointer data)
00523 {
00524     CN_LOGPRINTF("entry");
00525 
00526     edit_wireless_determine_status();
00527     return FALSE;
00528 }
00529 
00530 void delay_edit_wireless_determine_status(void)
00531 {
00532     g_idle_add(on_delay_determine_status, NULL);
00533 }
00534 
00535 static void edit_wireless_set_status(wlanStatus_t status)
00536 {
00537     CN_LOGPRINTF("entry status[%d]", status);
00538 
00539     g_wlan_status = status;
00540 
00541     edit_wireless_show_widgets(status);
00542     edit_wireless_update_info_text(status);
00543 }
00544 
00546 // set/get functions
00548 
00549 void edit_wireless_set_network_settings(const regNetworkProfile_t* settings)
00550 {   
00551     gchar                *ssid        = NULL;
00552     wireless_encr_type_t encrtype    = encr_none_t;
00553     gchar                *encrkey     = NULL;
00554     gchar                *profilename = NULL;
00555     regWirelessSetting_t *wirelessSettings = NULL;
00556  
00557     CN_LOGPRINTF("entry");
00558 
00559     g_return_if_fail(settings != NULL);
00560     g_return_if_fail(settings->connection == wireless_t);
00561     
00562     profilename = settings->name;
00563     
00564     wirelessSettings = settings->wirelessSettings;
00565     if (wirelessSettings)
00566     {
00567         ssid = wirelessSettings->SSID;
00568         encrtype = wirelessSettings->encrType;
00569         encrkey = wirelessSettings->encrKey;
00570     }
00571 
00572     // set screen objects
00573     edit_wireless_set_ssid(ssid);
00574     edit_wireless_set_encrtype(encrtype);
00575     edit_wireless_set_encrkey(encrkey);
00576     edit_wireless_set_profilename(profilename);
00577 
00578     delay_edit_wireless_determine_status();
00579 
00580     // make a backup copy of the settings
00581     edit_wireless_backup_network_settings();
00582 }
00583 
00584 void edit_wireless_set_ssid(const char* ssid)
00585 {
00586     GtkWidget* widget;
00587 
00588     CN_LOGPRINTF("entry ssid[%s]", ssid);
00589 
00590     if (g_ssid)
00591     {
00592         widget = g_ssid->details->entry;
00593         gtk_entry_set_text(GTK_ENTRY(widget), ssid ? ssid : "");
00594     }
00595 }
00596 
00597 void edit_wireless_set_encrtype(const wireless_encr_type_t encrType)
00598 {
00599     GtkWidget *widget;
00600     erGtkSelectionGroup *sel;
00601     int        nsel;
00602 
00603     CN_LOGPRINTF("entry: encrType [%d]", encrType);
00604 
00605     // set screen objects
00606     switch (encrType)
00607     {
00608         case encr_undefined_t:
00609             widget = g_encrtype->details->selection;
00610             sel = ERGTK_SELECTION_GROUP(widget);
00611             ergtk_selection_group_get_selected_buttons(sel, &nsel, 1);
00612             if ((nsel >= 0) && (nsel <= 2))
00613             {
00614                 widget = GTK_WIDGET(g_encrtype->details->buttonList[nsel]);
00615                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), FALSE);
00616             }
00617             break;
00618         case encr_none_t:
00619             widget = GTK_WIDGET(g_encrtype->details->buttonList[0]);
00620             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
00621             break;
00622         case encr_wep_t:
00623             widget = GTK_WIDGET(g_encrtype->details->buttonList[1]);
00624             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
00625             break;
00626         case encr_wpa_t:
00627             widget = GTK_WIDGET(g_encrtype->details->buttonList[2]);
00628             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
00629             break;
00630         default:
00631             CN_ERRORPRINTF("Illegal encryption type [%d]", encrType);
00632             g_assert_not_reached();
00633     }
00634 }
00635 
00636 void edit_wireless_set_encrkey(const char* encrkey)
00637 {
00638     GtkWidget *widget;
00639 
00640     CN_LOGPRINTF("entry encrkey[%s]", encrkey);
00641 
00642     if (g_encrkey)
00643     {
00644         widget = g_encrkey->details->entry;
00645         gtk_entry_set_text(GTK_ENTRY(widget), encrkey ? encrkey : "");
00646     }
00647 }
00648 
00649 void edit_wireless_set_profilename(const gchar* profilename)
00650 {
00651     GtkWidget *widget;
00652 
00653     CN_LOGPRINTF("entry profilename[%s]", profilename);
00654 
00655     if (g_profilename)
00656     {
00657         widget = g_profilename->details->entry;
00658         gtk_entry_set_text(GTK_ENTRY(widget), 
00659                 profilename ? profilename : "");
00660     }
00661 }
00662 
00663 void edit_wireless_get_network_settings(regNetworkProfile_t* settings)
00664 {
00665     const char *ssid = NULL;
00666     const char *encrkey = NULL;
00667     const char *profilename = NULL;
00668     regWirelessSetting_t *wirelessSettings;
00669 
00670     CN_LOGPRINTF("entry");
00671 
00672     g_return_if_fail(settings != NULL);
00673     g_return_if_fail(settings->connection == wireless_t);
00674    
00675     // clear wireless wirelessSettings
00676     wirelessSettings = settings->wirelessSettings;
00677     if (wirelessSettings)
00678     {
00679         g_free(wirelessSettings->SSID);
00680         g_free(wirelessSettings->encrKey);
00681         g_free(wirelessSettings);
00682         wirelessSettings = NULL;
00683         settings->wirelessSettings = NULL;
00684     }
00685 
00686     // store new settings, if wireless selected
00687     if (settings->connection == wireless_t)
00688     {
00689         ssid = edit_wireless_get_ssid();
00690         encrkey = edit_wireless_get_encrkey();
00691         profilename = edit_wireless_get_profilename();
00692         
00693         g_free(settings->name);
00694         settings->name = g_strdup(profilename);
00695 
00696         wirelessSettings = g_new0(regWirelessSetting_t, 1);
00697         g_assert(wirelessSettings != NULL);
00698         wirelessSettings->SSID     = g_strdup(ssid);
00699         wirelessSettings->encrType = edit_wireless_get_encrtype();
00700         wirelessSettings->encrKey  = g_strdup(encrkey);
00701         // always treat it as non-broadcast access point
00702         wirelessSettings->broadcast = FALSE;
00703         settings->wirelessSettings = wirelessSettings;
00704     }
00705 }
00706 
00707 const char* edit_wireless_get_ssid(void)
00708 {
00709     GtkWidget *widget;
00710     const char *ssid = NULL;
00711 
00712     if (g_ssid)
00713     {
00714         widget = g_ssid->details->entry;
00715         ssid = gtk_entry_get_text(GTK_ENTRY(widget));
00716     }
00717 
00718     CN_LOGPRINTF("return ssid=%s", ssid);
00719     return ssid;
00720 }
00721  
00722 wireless_encr_type_t edit_wireless_get_encrtype(void)
00723 {
00724     GtkWidget *widget;
00725     erGtkSelectionGroup *sel;
00726     int        nsel;
00727     wireless_encr_type_t encrType;
00728  
00729     CN_LOGPRINTF("entry");
00730 
00731     g_return_val_if_fail(g_encrtype != NULL, encr_undefined_t);
00732 
00733     // get current value from screen object
00734     widget =  g_encrtype->details->selection;
00735     sel = ERGTK_SELECTION_GROUP(widget);
00736     ergtk_selection_group_get_selected_buttons(sel, &nsel, 1);
00737     switch (nsel)
00738     {
00739         case 0:
00740             encrType = encr_none_t;
00741             break;
00742         case 1:
00743             encrType = encr_wep_t;
00744             break;
00745         case 2:
00746             encrType = encr_wpa_t;
00747             break;
00748         default:
00749             encrType = encr_undefined_t;
00750             break;
00751     }
00752 
00753     CN_LOGPRINTF("return encrType=%d", encrType);
00754     return encrType;
00755 }
00756 
00757 const char* edit_wireless_get_encrkey(void)
00758 {
00759     GtkWidget  *widget;
00760     const char *encrkey = NULL;
00761 
00762     CN_LOGPRINTF("entry");
00763 
00764     if (g_encrkey)
00765     {
00766         widget =  g_encrkey->details->entry;
00767         encrkey = gtk_entry_get_text(GTK_ENTRY(widget)); 
00768     }
00769 
00770     CN_LOGPRINTF("return encrkey=%s", encrkey);
00771     return encrkey;
00772 }
00773 
00774 const char* edit_wireless_get_profilename(void)
00775 {
00776     GtkWidget  *widget;
00777     const char *profilename = NULL;
00778 
00779     CN_LOGPRINTF("entry");
00780 
00781     if (g_profilename)
00782     {
00783         widget = g_profilename->details->entry;
00784         profilename = gtk_entry_get_text(GTK_ENTRY(widget));
00785     }
00786 
00787     CN_LOGPRINTF("return profilename=%s", profilename);
00788     return profilename;
00789 }
00790 
00791 gboolean edit_wireless_check_network_settings(void)
00792 {
00793     wlanStatus_t status;
00794     gboolean valid = TRUE;
00795 
00796     status = edit_wireless_detect_status();
00797     if (status != undefWlanStatus_e)
00798     {
00799         valid = FALSE;
00800     }
00801     
00802     CN_LOGPRINTF("return valid=%d", valid);
00803     return valid;
00804 }
00805 
00806 void edit_wireless_backup_network_settings(void)
00807 {
00808     const char *ssid, *encrkey, *profilename;
00809     
00810     CN_LOGPRINTF("entry");
00811 
00812     ssid = edit_wireless_get_ssid();
00813     encrkey = edit_wireless_get_encrkey();
00814     profilename = edit_wireless_get_profilename();
00815 
00816     if (g_old_settings)
00817     {
00818         g_free(g_old_settings->SSID);
00819         g_free(g_old_settings->encrKey);
00820         g_free(g_old_settings);
00821     }
00822 
00823     g_old_settings = g_new0(regWirelessSetting_t, 1);
00824     g_assert(g_old_settings != NULL);
00825     g_old_settings->SSID = g_strdup(ssid);
00826     g_old_settings->encrType = edit_wireless_get_encrtype();
00827     g_old_settings->encrKey = g_strdup(encrkey);
00828     
00829     g_free(g_old_profilename);
00830     g_old_profilename = g_strdup(profilename);
00831 }
00832 
00833 void edit_wireless_restore_network_settings(void)
00834 {
00835     char *ssid = NULL;
00836     char *encrkey = NULL;
00837     char *profilename = NULL; 
00838     
00839     CN_LOGPRINTF("entry");
00840      
00841     if (g_old_settings)
00842     {
00843        ssid = g_old_settings->SSID;
00844        encrkey = g_old_settings->encrKey;
00845     }
00846 
00847     if (g_old_profilename)
00848     {
00849         profilename = g_old_profilename;
00850     }
00851 
00852     edit_wireless_set_ssid(ssid);
00853     edit_wireless_set_encrtype(g_old_settings->encrType);
00854     edit_wireless_set_encrkey(encrkey);
00855     edit_wireless_set_profilename(profilename);
00856 }
00857 
00859 // signal handlers
00861 
00862 static void on_ssid_changed(GtkEntry* widget, gpointer data)
00863 {
00864     CN_LOGPRINTF("entry");
00865 
00866     edit_wireless_set_status(inputSSID_e);
00867 }
00868 
00869 // Click 'Next' to detect the encryption type for this ssid automatically.
00870 static void on_ssid_next(GtkToggleButton* button, gpointer data)
00871 {
00872     gboolean   active;
00873     const char *ssid;
00874     scanContext_t *ctxt;
00875 
00876     CN_LOGPRINTF("entry");
00877 
00878     active = gtk_toggle_button_get_active(button);
00879     if (active)
00880     {
00881         ssid = edit_wireless_get_ssid();
00882         if (ssid && ssid[0] != '\0')
00883         {
00884             edit_wireless_restore_scan_ctxt();
00885             ctxt = cmgr_get_scan_ctxt();
00886             connect_scan_ctxt_set_ssidlist(ctxt, (char*)ssid);
00887             connect_scan(ctxt, TRUE);
00888         }
00889         else
00890         {
00891             g_timeout_add(500, delayed_deactive_button, button);
00892         }
00893     }
00894 }
00895 
00896 static gboolean delayed_deactive_button(gpointer data)
00897 {
00898     GtkToggleButton *button = GTK_TOGGLE_BUTTON(data);
00899     
00900     if (button)
00901     {
00902         gtk_toggle_button_set_active(button, FALSE);
00903     }
00904 
00905     return FALSE;
00906 }
00907 
00908 static void on_encrtype_update(GtkWidget* selection, 
00909                                gpointer button, 
00910                                gpointer data)
00911 {
00912     int        nsel;
00913     erGtkSelectionGroup *widget;
00914 
00915     CN_LOGPRINTF("entry");
00916 
00917     g_return_if_fail(g_encrtype != NULL);
00918 
00919     widget = ERGTK_SELECTION_GROUP(selection);
00920     ergtk_selection_group_get_selected_buttons(widget, &nsel, 1);
00921     switch (nsel)
00922     {
00923         case 0:
00924             edit_wireless_set_status(wlanInputProfileName_e);
00925             break;
00926         case 1:
00927             edit_wireless_set_status(inputEncrKeyWEP_e);
00928             break;
00929         case 2:
00930             edit_wireless_set_status(inputEncrKeyWPA_e);
00931             break;
00932         default:
00933             // encrtype is not selected yet
00934             edit_wireless_set_status(inputEncrType_e);
00935             break;
00936     }
00937 }
00938 
00939 static void on_encrkey_changed(GtkEntry *widget, gpointer data)
00940 {
00941     wireless_encr_type_t encrtype;
00942 
00943     CN_LOGPRINTF("entry");
00944 
00945     encrtype = edit_wireless_get_encrtype();
00946     switch (encrtype)
00947     {
00948         case encr_wep_t:
00949             edit_wireless_set_status(inputEncrKeyWEP_e);
00950             break;
00951         case encr_wpa_t:
00952             edit_wireless_set_status(inputEncrKeyWPA_e);
00953             break;
00954         case encr_none_t:
00955         default:
00956             break;
00957     }
00958 }
00959 
00960 static void on_profilename_changed(GtkEntry* widget, gpointer data)
00961 {
00962     CN_LOGPRINTF("entry");
00963 
00964     edit_wireless_set_status(wlanInputProfileName_e);
00965 }
00966 
00967 static gboolean on_delayed_profilename_next(gpointer data)
00968 {
00969     CN_LOGPRINTF("entry");
00970 
00971     erbusy_blink();
00972 
00973     edit_wireless_backup_network_settings();
00974 
00975     edit_goto_page(editScreenOverview_e);
00976     edit_overview_update_info_text(inputProxy_e);
00977     edit_overview_update_profile();
00978 
00979     return FALSE;
00980 }
00981 
00982 // Click 'Next' to goto the page of filling in the advanced settings.
00983 static void on_profilename_next(GtkToggleButton* button, gpointer data)
00984 {
00985     gboolean active;
00986     gboolean valid;
00987 
00988     CN_LOGPRINTF("entry");
00989 
00990     active = gtk_toggle_button_get_active(button);
00991     if (active)
00992     {
00993         valid = edit_wireless_check_network_settings();
00994         if (valid)
00995         {
00996             // use timeout to show button is in active state
00997             g_timeout_add(500, on_delayed_profilename_next, NULL);
00998         }
00999         else
01000         {
01001             edit_wireless_determine_status();
01002         }
01003 
01004         g_timeout_add(500, delayed_deactive_button, button);
01005     }
01006 }
01007 
01008 static void on_buttons_update(GtkWidget *selection, 
01009                               gpointer button, 
01010                               gpointer data)
01011 {
01012     gboolean   active;
01013     gboolean   valid;
01014     int        nsel;
01015     GtkWidget *widget;
01016     erGtkSelectionGroup *sel;
01017     gboolean  toDeactive = TRUE;
01018 
01019     CN_LOGPRINTF("entry");
01020 
01021     active = gtk_toggle_button_get_active(button);
01022     valid = edit_wireless_check_network_settings();
01023     if (!valid)
01024     {
01025         edit_wireless_determine_status();
01026     }
01027 
01028     if (active && valid)
01029     {
01030         widget = g_buttons->details->selection;
01031         sel = ERGTK_SELECTION_GROUP(widget);
01032         ergtk_selection_group_get_selected_buttons(sel, &nsel, 1);
01033 
01034         switch (nsel)
01035         {
01036             case 0:
01037                 // test button is selected
01038                 on_test();
01039                 toDeactive = FALSE;
01040                 break;
01041             case 1:
01042                 // save button is selected
01043                 on_save();
01044                 toDeactive = FALSE;
01045                 break;
01046             case 2:
01047                 // save&connect button is selected
01048                 on_saveconnect();
01049                 toDeactive = FALSE;
01050                 break;
01051             default:
01052                 break;
01053         }
01054     }
01055 
01056     if (active && toDeactive)
01057     {
01058         g_timeout_add(500, delayed_deactive_button, button);
01059     }
01060 }
01061 
01062 static gboolean on_delayed_test(gpointer data)
01063 {
01064     GtkToggleButton *button;
01065 
01066     CN_LOGPRINTF("entry");
01067 
01068     erbusy_blink();
01069 
01070     edit_wireless_backup_network_settings();
01071 
01072     edit_goto_page(editScreenOverview_e);
01073 
01074     edit_overview_update_profile();
01075     
01076     // similuate clicking the 'Test' button
01077     edit_overview_click_test();
01078 
01079     if (g_buttons)
01080     {
01081         button = g_buttons->details->buttonList[0];
01082         gtk_toggle_button_set_active(button, FALSE);
01083     }
01084 
01085     return FALSE;
01086 }
01087 
01088 static void on_test(void)
01089 {
01090     CN_LOGPRINTF("entry");
01091 
01092     // use timeout to show button is in active state
01093     g_timeout_add(500, on_delayed_test, NULL);
01094 }
01095 
01096 static gboolean on_delayed_save(gpointer data)
01097 {
01098     GtkToggleButton *button;
01099     
01100     CN_LOGPRINTF("entry");
01101 
01102     erbusy_blink();
01103 
01104     edit_save_profile();
01105 
01106     edit_goto_page(editScreenProfiles_e);
01107     if (g_buttons)
01108     {
01109         button = g_buttons->details->buttonList[1];
01110         gtk_toggle_button_set_active(button, FALSE);
01111     }
01112 
01113     return FALSE;
01114 }
01115 
01116 static void on_save(void)
01117 {
01118     CN_LOGPRINTF("entry");
01119 
01120     // use timeout to show button is in active state
01121     g_timeout_add(500, on_delayed_save, NULL);
01122 }
01123 
01124 static void on_saveconnect(void)
01125 {
01126     pingContext_t *ctxt;
01127 
01128     CN_LOGPRINTF("entry");
01129 
01130     erbusy_blink();
01131 
01132     edit_wireless_freeze_ui(TRUE);
01133 
01134     edit_wireless_restore_ping_ctxt();
01135 
01136     ctxt = cmgr_get_ping_ctxt();
01137     connect_ping_select_initial_profile(ctxt);
01138     connect_ping(ctxt, TRUE);
01139 }
01140 
01142 // functions about scan context
01144 static void edit_wireless_restore_scan_ctxt(void)
01145 {
01146     scanContext_t *ctxt;
01147 
01148     CN_LOGPRINTF("entry");
01149 
01150     ctxt = cmgr_get_scan_ctxt();
01151     if (ctxt)
01152     {
01153         connect_scan_ctxt_set_mode(ctxt, editScan_e);
01154         connect_scan_ctxt_set_network_type(ctxt, wireless_t);
01155         connect_scan_ctxt_set_done_callbacks(ctxt, 
01156                         scan_done, scan_done_after);
01157     }
01158 }
01159 
01160 static void scan_done(connection_t networkType, 
01161                       network_spec_t* pScanNetworks, 
01162                       int nScanNetworks)
01163 {
01164     int        i;
01165     const char *ssid;
01166 
01167     CN_LOGPRINTF("entry");
01168 
01169     g_found_network = NULL;
01170 
01171     ssid = edit_wireless_get_ssid();
01172     if (pScanNetworks && (nScanNetworks != 0) && ssid)
01173     {
01174         for (i = 0; i < nScanNetworks; i++)
01175         {
01176            if (pScanNetworks[i].ssid 
01177                && (strcmp(pScanNetworks[i].ssid, ssid) == 0))
01178            {
01179                CN_LOGPRINTF("found [%d]", i);
01180                g_found_network = &pScanNetworks[i];
01181                break;
01182            }
01183         }
01184     }
01185 }
01186 
01187 static void scan_done_after(void)
01188 {
01189     GtkToggleButton *button;
01190     wireless_encr_type_t encrtype;
01191     
01192     CN_LOGPRINTF("entry");
01193 
01194     // de-active the button
01195     if (g_ssid)
01196     {
01197         button = GTK_TOGGLE_BUTTON(g_ssid->details->button);
01198         gtk_toggle_button_set_active(button, FALSE);
01199     }
01200 
01201     CN_ERRORPRINTF("%p", g_found_network);
01202 
01203     if (g_found_network)
01204     {
01205         encrtype = g_found_network->encryption;
01206     }
01207     else
01208     {
01209         encrtype = encr_undefined_t;
01210     }
01211     
01212     edit_wireless_set_encrtype(encrtype);
01213     
01214     edit_wireless_determine_status();
01215     display_update_request_screen_refresh(STATUS_ITEM_CHANGE, 
01216                                           WAVEFORM_TYPING);
01217 }
01218 
01220 // functions about ping context
01222 static void edit_wireless_restore_ping_ctxt(void)
01223 {
01224     pingContext_t *ctxt;
01225     cmgrConnectType_t connectType;
01226 
01227     CN_LOGPRINTF("entry");
01228     
01229     ctxt = cmgr_get_ping_ctxt();
01230     if (ctxt)
01231     {
01232         // set mode and connect type
01233         connect_ping_ctxt_set_mode(ctxt, editPing_e);
01234         connectType = connect_data_get_connect_type();
01235         connect_ping_ctxt_set_connect_type(ctxt, connectType);
01236         
01237         // ping done callbacks
01238         connect_ping_ctxt_set_done_callbacks(ctxt, 
01239                             on_connected, on_failed);
01240        
01241         // data access callbacks
01242         connect_ping_ctxt_set_get_initial_profile(ctxt, 
01243                             edit_get_initial_profile);
01244         connect_ping_ctxt_set_access_network_profiles_callbacks(ctxt,
01245                                     edit_get_n_network_profiles,
01246                                     edit_get_network_profile,
01247                                     edit_select_next_regprofile);
01248 
01249         // ui callbacks
01250         connect_ping_ctxt_set_ui_callbacks(ctxt, 
01251                                     ui_update_status, 
01252                                     ui_display_settings,
01253                                     ui_select_profile,
01254                                     ui_unselect_all_profile);
01255     }
01256 }
01257 
01258 static void on_connected(int profileIndex)
01259 {
01260     GtkToggleButton *button;
01261 
01262     CN_LOGPRINTF("entry");
01263  
01264     edit_save_profile();
01265  
01266     edit_wireless_freeze_ui(FALSE);
01267 
01268     if (g_buttons)
01269     {
01270         button = g_buttons->details->buttonList[2];
01271         g_timeout_add(500, delayed_deactive_button, button);
01272     }
01273 
01274     edit_on_connected();    
01275 }
01276 
01277 static void on_failed(void)
01278 {
01279     GtkToggleButton *button;
01280 
01281     CN_LOGPRINTF("entry");
01282 
01283     edit_wireless_freeze_ui(FALSE);
01284 
01285     if (g_buttons)
01286     {
01287         button = g_buttons->details->buttonList[2];
01288         g_timeout_add(500, delayed_deactive_button, button);
01289     }
01290 }
01291 
01292 static void ui_update_status(int profileIndex, pingStatus_t status)
01293 {
01294     wlanStatus_t state;
01295 
01296     CN_LOGPRINTF("entry");
01297 
01298     switch (status)
01299     {
01300         case pingSucceeded_e:
01301             state = wlanConnected_e;
01302             break;
01303         case pingFailed_e:
01304         case pingFailedPCShare_e:
01305         case pingFailedNetwork_e:
01306             state = wlanUnconnected_e;
01307             break;
01308         case pingConnecting_e:
01309             state = wlanConnecting_e;
01310             break;
01311         case pingAborting_e:
01312             state  = wlanAborting_e;
01313             break;
01314         case pingAborted_e:
01315             state = wlanAborted_e;
01316             on_failed();
01317             break;
01318         default:
01319             state = undefWlanStatus_e;
01320             break;
01321     }
01322 
01323     edit_wireless_update_info_text(state);
01324     display_update_request_screen_refresh(STATUS_ITEM_CHANGE, 
01325                                           WAVEFORM_TYPING);
01326 }
01327 
01328 static void ui_display_settings(int profileIndex, gboolean resetStatus)
01329 {
01330     CN_LOGPRINTF("entry");
01331     // nothing to do
01332 }
01333 
01334 static void ui_select_profile(int profileIndex)
01335 {
01336     CN_LOGPRINTF("entry");
01337     // nothing to do
01338 }
01339 
01340 static void ui_unselect_all_profile(void)
01341 {
01342     CN_LOGPRINTF("entry");
01343     // nothing to do
01344 }
01345 
01346 static void edit_wireless_click_ssid_next(void)
01347 {
01348     GtkToggleButton *button;
01349 
01350     CN_LOGPRINTF("entry");
01351 
01352     g_return_if_fail(g_ssid != NULL);
01353     
01354     button = GTK_TOGGLE_BUTTON(g_ssid->details->button);
01355     gtk_toggle_button_set_active(button, TRUE);
01356 }
01357 
01358 static void edit_wireless_click_encr_none(void)
01359 {
01360     GtkToggleButton *button;
01361 
01362     CN_LOGPRINTF("entry");
01363 
01364     g_return_if_fail(g_encrtype != NULL);
01365     
01366     button = g_encrtype->details->buttonList[0];
01367     gtk_toggle_button_set_active(button, TRUE);
01368 }
01369 
01370 static void edit_wireless_click_saveconnect(void)
01371 {
01372     GtkToggleButton *button;
01373 
01374     CN_LOGPRINTF("entry");
01375 
01376     g_return_if_fail(g_buttons != NULL);
01377 
01378     button = g_buttons->details->buttonList[2];
01379     gtk_toggle_button_set_active(button, TRUE);
01380 }
01381 
01382 gboolean on_edit_wireless_keypress(GdkEventKey *event)
01383 {
01384     pingContext_t *ctxt;
01385     const char *encrkey = NULL;
01386     gboolean ret = FALSE;
01387 
01388     CN_LOGPRINTF("entry");
01389 
01390     ctxt = cmgr_get_ping_ctxt();
01391     switch (event->keyval)
01392     {
01393         case GDK_Return:
01394             // 'Enter' key is pressed
01395             if (!connect_ping_in_pinging(ctxt))
01396             {
01397                 switch (g_wlan_status)
01398                 {
01399                     case inputSSID_e:
01400                         // simulate clicking the 'Next' button 
01401                         // of g_ssid
01402                         edit_wireless_click_ssid_next();
01403                         break;
01404                     case inputEncrType_e:
01405                         // simulate clicking the encr_none_t button
01406                         edit_wireless_click_encr_none();
01407                         break;
01408                     case inputEncrKeyWEP_e:
01409                     case inputEncrKeyWPA_e:
01410                         encrkey = edit_wireless_get_encrkey();
01411                         if (encrkey && (encrkey[0] != '\0'))
01412                         {
01413                             // move to the next field(profile name)
01414                             edit_wireless_set_status(wlanInputProfileName_e);
01415                             display_update_request_screen_refresh(STATUS_ITEM_CHANGE, 
01416                                                               WAVEFORM_TYPING);
01417 
01418                         }
01419                         break;
01420                     case wlanInputProfileName_e:
01421                     case undefWlanStatus_e:
01422                         // simulate clicking the 'Save & Connect' button
01423                         edit_wireless_click_saveconnect();
01424                         break;
01425                     default:
01426                         break;
01427                 }
01428                 ret = TRUE;
01429             }
01430             break;
01431 
01432         case GDK_F5:
01433             // 'UP' key is pressed
01434             // goto the one top level page
01435             connect_ping_abort(ctxt);
01436             cmgr_up_page();
01437             ret = TRUE;
01438             break;
01439         case GDK_Down:
01440         case GDK_Up:
01441             // avoid the standard GTK behaviour for GtkEntries
01442             erbusy_off();
01443             ret = TRUE;
01444         default:
01445             erbusy_off();
01446     }
01447     
01448     return ret;
01449 }
01450 
01452 // functions for freezing the ui when in ping-to-server state
01454 
01455 static void edit_wireless_freeze_ui(gboolean freeze)
01456 {
01457     editMode_t mode;
01458     gboolean sensitive;
01459     GtkWidget *widget;
01460 
01461     CN_LOGPRINTF("entry[%d]", freeze);
01462 
01463     sensitive = !freeze;
01464 
01465     // the ssid
01466     widget = g_ssid->details->entry;
01467     gtk_widget_set_sensitive(widget, sensitive);
01468 
01469     // the encryption type
01470     widget = GTK_WIDGET(g_encrtype->details->buttonList[0]);
01471     gtk_widget_set_sensitive(widget, sensitive);
01472 
01473     widget = GTK_WIDGET(g_encrtype->details->buttonList[1]);
01474     gtk_widget_set_sensitive(widget, sensitive);
01475 
01476     widget = GTK_WIDGET(g_encrtype->details->buttonList[2]);
01477     gtk_widget_set_sensitive(widget, sensitive);
01478 
01479     // the encryption key
01480     widget = g_encrkey->details->entry;
01481     gtk_widget_set_sensitive(widget, sensitive);
01482 
01483     // the profilename
01484     widget = g_profilename->details->entry;
01485     gtk_widget_set_sensitive(widget, sensitive);
01486 
01487     widget = g_profilename->details->button;
01488     gtk_widget_set_sensitive(widget, sensitive);
01489     
01490     // the buttons
01491     widget = GTK_WIDGET(g_buttons->details->buttonList[0]);
01492     gtk_widget_set_sensitive(widget, sensitive);
01493     
01494     widget = GTK_WIDGET(g_buttons->details->buttonList[1]);
01495     gtk_widget_set_sensitive(widget, sensitive);
01496 
01497     widget = GTK_WIDGET(g_buttons->details->buttonList[2]);
01498     gtk_widget_set_sensitive(widget, sensitive);
01499  
01500     if (sensitive)
01501     {
01502         // restore the previous in-sensitive widgets
01503         // save button
01504         mode = edit_get_mode();
01505         if ((mode == editModeConnectFillIn_e)
01506             || (mode == editModeConnectCreate_e)
01507             || (mode == editModeConnectNormal_e))
01508         {
01509             edit_wireless_enable_save_button(FALSE);
01510         }
01511     }
01512 }
01513