connectionMgr/src/editScreenWireless.c File Reference

connectionMgr - "Wireless Configuration" screen. More...

#include "config.h"
#include <string.h>
#include <gtk/gtk.h>
#include <liberdm/connectionMgrConstants.h>
#include <liberdm/display.h>
#include <liberregxml/erregapi.h>
#include <libergtk/ergtk.h>
#include "connectionMgrLog.h"
#include "displayStatus.h"
#include "erbusy.h"
#include "background.h"
#include "connectionMgr.h"
#include "gtkSettingItem.h"
#include "gtkInfoItem.h"
#include "widgetUtils.h"
#include "connectScreen.h"
#include "connectScreenData.h"
#include "editScreen.h"
#include "editScreenOverview.h"
#include "editScreenWireless.h"
#include "connectScan.h"
#include "connectBackground.h"
#include "languages.h"

Go to the source code of this file.

Enumerations

enum wlanStatus_t {
  inputSSID_e, inputEncrType_e, inputEncrKeyWEP_e, inputEncrKeyWPA_e,
  wlanInputProfileName_e, wlanConnecting_e, wlanConnected_e, wlanUnconnected_e,
  wlanAborting_e, wlanAborted_e, undefWlanStatus_e
}

Functions

static void edit_wireless_set_status (wlanStatus_t status)

static void on_ssid_changed (GtkEntry *widget, gpointer data)

static void on_ssid_next (GtkToggleButton *button, gpointer data)

static void on_encrtype_update (GtkWidget *selection, gpointer button, gpointer data)

static void on_encrkey_changed (GtkEntry *widget, gpointer data)

static void on_profilename_changed (GtkEntry *widget, gpointer data)

static void on_profilename_next (GtkToggleButton *button, gpointer data)

static void on_buttons_update (GtkWidget *selection, gpointer button, gpointer data)

static gboolean delayed_deactive_button (gpointer data)

static void on_test (void)

static void on_save (void)

static void on_saveconnect (void)

static void edit_wireless_restore_scan_ctxt (void)

static void scan_done (connection_t networkType, network_spec_t *pScanNetworks, int nScanNetworks)

static void scan_done_after (void)

static void edit_wireless_restore_ping_ctxt (void)

static void on_connected (int profileIndex)

static void on_failed (void)

static void ui_update_status (int profileIndex, pingStatus_t status)

static void ui_display_settings (int profileIndex, gboolean resetStatus)

static void ui_select_profile (int profileIndex)

static void ui_unselect_all_profile (void)

static void edit_wireless_freeze_ui (gboolean freeze)

GtkWidget * edit_wireless_create (void)

static void edit_wireless_show_widgets (wlanStatus_t mode)

void edit_wireless_enable_save_button (gboolean enable)

void edit_wireless_set_text (void)

static void edit_wireless_update_info_text (wlanStatus_t status)

static wlanStatus_t edit_wireless_detect_status (void)

void edit_wireless_determine_status (void)

static gboolean on_delay_determine_status (gpointer data)

void delay_edit_wireless_determine_status (void)

void edit_wireless_set_network_settings (const regNetworkProfile_t *settings)

void edit_wireless_set_ssid (const char *ssid)

void edit_wireless_set_encrtype (const wireless_encr_type_t encrType)

void edit_wireless_set_encrkey (const char *encrkey)

void edit_wireless_set_profilename (const gchar *profilename)

void edit_wireless_get_network_settings (regNetworkProfile_t *settings)

const char * edit_wireless_get_ssid (void)

wireless_encr_type_t edit_wireless_get_encrtype (void)

const char * edit_wireless_get_encrkey (void)

const char * edit_wireless_get_profilename (void)

gboolean edit_wireless_check_network_settings (void)

void edit_wireless_backup_network_settings (void)

void edit_wireless_restore_network_settings (void)

static gboolean on_delayed_profilename_next (gpointer data)

static gboolean on_delayed_test (gpointer data)

static gboolean on_delayed_save (gpointer data)

static void edit_wireless_click_ssid_next (void)

static void edit_wireless_click_encr_none (void)

static void edit_wireless_click_saveconnect (void)

gboolean on_edit_wireless_keypress (GdkEventKey *event)

Variables

static GtkWidget * g_wireless = NULL

static bkWdtLabelEntry * g_ssid = NULL

static bkWdtLabelButton * g_encrtype = NULL

static bkWdtLabelEntry * g_encrkey = NULL

static bkWdtLabelEntry * g_profilename = NULL

static bkWdtLabelButton * g_buttons = NULL

static GtkWidget * g_info = NULL

static wlanStatus_t g_wlan_status = undefWlanStatus_e

static network_spec_t * g_found_network = NULL

static regWirelessSetting_t * g_old_settings = NULL

static char * g_old_profilename = NULL

Detailed Description

connectionMgr - "Wireless Configuration" screen.

Definition in file editScreenWireless.c.

Enumeration Type Documentation

enum wlanStatus_t

Enumerator:

inputSSID_e
inputEncrType_e
inputEncrKeyWEP_e
inputEncrKeyWPA_e
wlanInputProfileName_e
wlanConnecting_e
wlanConnected_e
wlanUnconnected_e
wlanAborting_e
wlanAborted_e
undefWlanStatus_e

Definition at line 54 of file editScreenWireless.c.

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;

Function Documentation

void delay_edit_wireless_determine_status ( void )

Definition at line 530 of file editScreenWireless.c.

00531 {
00532     g_idle_add(on_delay_determine_status, NULL);
00533 }

Here is the call graph for this function:

static gboolean delayed_deactive_button ( gpointer data ) [static]

Definition at line 896 of file editScreenWireless.c.

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 }

void edit_wireless_backup_network_settings ( void )

Definition at line 806 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

gboolean edit_wireless_check_network_settings ( void )

Definition at line 791 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void edit_wireless_click_encr_none ( void ) [static]

Definition at line 1358 of file editScreenWireless.c.

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 }

static void edit_wireless_click_saveconnect ( void ) [static]

Definition at line 1370 of file editScreenWireless.c.

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 }

static void edit_wireless_click_ssid_next ( void ) [static]

Definition at line 1346 of file editScreenWireless.c.

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 }

GtkWidget* edit_wireless_create ( void )

Definition at line 140 of file editScreenWireless.c.

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  }

Here is the call graph for this function:

static wlanStatus_t edit_wireless_detect_status ( void ) [static]

Definition at line 466 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

void edit_wireless_determine_status ( void )

Definition at line 514 of file editScreenWireless.c.

00515 {
00516     wlanStatus_t status;
00517 
00518     status = edit_wireless_detect_status();
00519     edit_wireless_set_status(status);
00520 }

Here is the call graph for this function:

void edit_wireless_enable_save_button ( gboolean enable )

Definition at line 300 of file editScreenWireless.c.

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 }

static void edit_wireless_freeze_ui ( gboolean freeze ) [static]

Definition at line 1455 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

const char* edit_wireless_get_encrkey ( void )

Definition at line 757 of file editScreenWireless.c.

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 }

wireless_encr_type_t edit_wireless_get_encrtype ( void )

Definition at line 722 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

void edit_wireless_get_network_settings ( regNetworkProfile_t * settings )

Definition at line 663 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

const char* edit_wireless_get_profilename ( void )

Definition at line 774 of file editScreenWireless.c.

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 }

const char* edit_wireless_get_ssid ( void )

Definition at line 707 of file editScreenWireless.c.

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 }

void edit_wireless_restore_network_settings ( void )

Definition at line 833 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void edit_wireless_restore_ping_ctxt ( void ) [static]

Definition at line 1222 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void edit_wireless_restore_scan_ctxt ( void ) [static]

Definition at line 1144 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

void edit_wireless_set_encrkey ( const char * encrkey )

Definition at line 636 of file editScreenWireless.c.

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 }

void edit_wireless_set_encrtype ( const wireless_encr_type_t encrType )

Definition at line 597 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

void edit_wireless_set_network_settings ( const regNetworkProfile_t * settings )

Definition at line 549 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

void edit_wireless_set_profilename ( const gchar * profilename )

Definition at line 649 of file editScreenWireless.c.

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 }

void edit_wireless_set_ssid ( const char * ssid )

Definition at line 584 of file editScreenWireless.c.

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 }

static void edit_wireless_set_status ( wlanStatus_t status ) [static]

Definition at line 535 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

void edit_wireless_set_text ( void )

Definition at line 313 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void edit_wireless_show_widgets ( wlanStatus_t mode ) [static]

Definition at line 243 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void edit_wireless_update_info_text ( wlanStatus_t status ) [static]

Definition at line 385 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void on_buttons_update	(	GtkWidget *	selection,
		gpointer	button,
		gpointer	data
	)			`[static]`

Definition at line 1008 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void on_connected ( int profileIndex ) [static]

Definition at line 1258 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static gboolean on_delay_determine_status ( gpointer data ) [static]

Definition at line 522 of file editScreenWireless.c.

00523 {
00524     CN_LOGPRINTF("entry");
00525 
00526     edit_wireless_determine_status();
00527     return FALSE;
00528 }

Here is the call graph for this function:

static gboolean on_delayed_profilename_next ( gpointer data ) [static]

Definition at line 967 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static gboolean on_delayed_save ( gpointer data ) [static]

Definition at line 1096 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static gboolean on_delayed_test ( gpointer data ) [static]

Definition at line 1062 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

gboolean on_edit_wireless_keypress ( GdkEventKey * event )

Definition at line 1382 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void on_encrkey_changed	(	GtkEntry *	widget,
		gpointer	data
	)			`[static]`

Definition at line 939 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void on_encrtype_update	(	GtkWidget *	selection,
		gpointer	button,
		gpointer	data
	)			`[static]`

Definition at line 908 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void on_failed ( void ) [static]

Definition at line 1277 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void on_profilename_changed	(	GtkEntry *	widget,
		gpointer	data
	)			`[static]`

Definition at line 960 of file editScreenWireless.c.

00961 {
00962     CN_LOGPRINTF("entry");
00963 
00964     edit_wireless_set_status(wlanInputProfileName_e);
00965 }

Here is the call graph for this function:

static void on_profilename_next	(	GtkToggleButton *	button,
		gpointer	data
	)			`[static]`

Definition at line 983 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void on_save ( void ) [static]

Definition at line 1116 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void on_saveconnect ( void ) [static]

Definition at line 1124 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void on_ssid_changed	(	GtkEntry *	widget,
		gpointer	data
	)			`[static]`

Definition at line 862 of file editScreenWireless.c.

00863 {
00864     CN_LOGPRINTF("entry");
00865 
00866     edit_wireless_set_status(inputSSID_e);
00867 }

Here is the call graph for this function:

static void on_ssid_next	(	GtkToggleButton *	button,
		gpointer	data
	)			`[static]`

Definition at line 870 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void on_test ( void ) [static]

Definition at line 1088 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void scan_done	(	connection_t	networkType,
		network_spec_t *	pScanNetworks,
		int	nScanNetworks
	)			`[static]`

Definition at line 1160 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void scan_done_after ( void ) [static]

Definition at line 1187 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

static void ui_display_settings	(	int	profileIndex,
		gboolean	resetStatus
	)			`[static]`

Definition at line 1328 of file editScreenWireless.c.

01329 {
01330     CN_LOGPRINTF("entry");
01331     // nothing to do
01332 }

static void ui_select_profile ( int profileIndex ) [static]

Definition at line 1334 of file editScreenWireless.c.

01335 {
01336     CN_LOGPRINTF("entry");
01337     // nothing to do
01338 }

static void ui_unselect_all_profile ( void ) [static]

Definition at line 1340 of file editScreenWireless.c.

01341 {
01342     CN_LOGPRINTF("entry");
01343     // nothing to do
01344 }

static void ui_update_status	(	int	profileIndex,
		pingStatus_t	status
	)			`[static]`

Definition at line 1292 of file editScreenWireless.c.

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 }

Here is the call graph for this function:

Variable Documentation

bkWdtLabelButton* g_buttons = NULL [static]

Definition at line 76 of file editScreenWireless.c.

bkWdtLabelEntry* g_encrkey = NULL [static]

Definition at line 74 of file editScreenWireless.c.

bkWdtLabelButton* g_encrtype = NULL [static]

Definition at line 73 of file editScreenWireless.c.

network_spec_t* g_found_network = NULL [static]

Definition at line 82 of file editScreenWireless.c.

GtkWidget* g_info = NULL [static]

Definition at line 78 of file editScreenWireless.c.

char* g_old_profilename = NULL [static]

Definition at line 85 of file editScreenWireless.c.

regWirelessSetting_t* g_old_settings = NULL [static]

Definition at line 84 of file editScreenWireless.c.

bkWdtLabelEntry* g_profilename = NULL [static]

Definition at line 75 of file editScreenWireless.c.

bkWdtLabelEntry* g_ssid = NULL [static]

Definition at line 72 of file editScreenWireless.c.

GtkWidget* g_wireless = NULL [static]

Definition at line 70 of file editScreenWireless.c.

wlanStatus_t g_wlan_status = undefWlanStatus_e [static]

Definition at line 80 of file editScreenWireless.c.


Enumerations
enum	wlanStatus_t { inputSSID_e, inputEncrType_e, inputEncrKeyWEP_e, inputEncrKeyWPA_e, wlanInputProfileName_e, wlanConnecting_e, wlanConnected_e, wlanUnconnected_e, wlanAborting_e, wlanAborted_e, undefWlanStatus_e }
Functions
static void	edit_wireless_set_status (wlanStatus_t status)
static void	on_ssid_changed (GtkEntry *widget, gpointer data)
static void	on_ssid_next (GtkToggleButton *button, gpointer data)
static void	on_encrtype_update (GtkWidget *selection, gpointer button, gpointer data)
static void	on_encrkey_changed (GtkEntry *widget, gpointer data)
static void	on_profilename_changed (GtkEntry *widget, gpointer data)
static void	on_profilename_next (GtkToggleButton *button, gpointer data)
static void	on_buttons_update (GtkWidget *selection, gpointer button, gpointer data)
static gboolean	delayed_deactive_button (gpointer data)
static void	on_test (void)
static void	on_save (void)
static void	on_saveconnect (void)
static void	edit_wireless_restore_scan_ctxt (void)
static void	scan_done (connection_t networkType, network_spec_t *pScanNetworks, int nScanNetworks)
static void	scan_done_after (void)
static void	edit_wireless_restore_ping_ctxt (void)
static void	on_connected (int profileIndex)
static void	on_failed (void)
static void	ui_update_status (int profileIndex, pingStatus_t status)
static void	ui_display_settings (int profileIndex, gboolean resetStatus)
static void	ui_select_profile (int profileIndex)
static void	ui_unselect_all_profile (void)
static void	edit_wireless_freeze_ui (gboolean freeze)
GtkWidget *	edit_wireless_create (void)
static void	edit_wireless_show_widgets (wlanStatus_t mode)
void	edit_wireless_enable_save_button (gboolean enable)
void	edit_wireless_set_text (void)
static void	edit_wireless_update_info_text (wlanStatus_t status)
static wlanStatus_t	edit_wireless_detect_status (void)
void	edit_wireless_determine_status (void)
static gboolean	on_delay_determine_status (gpointer data)
void	delay_edit_wireless_determine_status (void)
void	edit_wireless_set_network_settings (const regNetworkProfile_t *settings)
void	edit_wireless_set_ssid (const char *ssid)
void	edit_wireless_set_encrtype (const wireless_encr_type_t encrType)
void	edit_wireless_set_encrkey (const char *encrkey)
void	edit_wireless_set_profilename (const gchar *profilename)
void	edit_wireless_get_network_settings (regNetworkProfile_t *settings)
const char *	edit_wireless_get_ssid (void)
wireless_encr_type_t	edit_wireless_get_encrtype (void)
const char *	edit_wireless_get_encrkey (void)
const char *	edit_wireless_get_profilename (void)
gboolean	edit_wireless_check_network_settings (void)
void	edit_wireless_backup_network_settings (void)
void	edit_wireless_restore_network_settings (void)
static gboolean	on_delayed_profilename_next (gpointer data)
static gboolean	on_delayed_test (gpointer data)
static gboolean	on_delayed_save (gpointer data)
static void	edit_wireless_click_ssid_next (void)
static void	edit_wireless_click_encr_none (void)
static void	edit_wireless_click_saveconnect (void)
gboolean	on_edit_wireless_keypress (GdkEventKey *event)
Variables
static GtkWidget *	g_wireless = NULL
static bkWdtLabelEntry *	g_ssid = NULL
static bkWdtLabelButton *	g_encrtype = NULL
static bkWdtLabelEntry *	g_encrkey = NULL
static bkWdtLabelEntry *	g_profilename = NULL
static bkWdtLabelButton *	g_buttons = NULL
static GtkWidget *	g_info = NULL
static wlanStatus_t	g_wlan_status = undefWlanStatus_e
static network_spec_t *	g_found_network = NULL
static regWirelessSetting_t *	g_old_settings = NULL
static char *	g_old_profilename = NULL