Migrate the Airpcap UI code from GtkCombos (deprecated) to GtkComboBoxes.

Consolidate some common code. Rename a bunch of variables. Remove some
unused code.

Fix an offset flag bug in airpcap_loader.c.

This had to be merged by hand with r28349. Hopefully none of those
changes were clobbered.

svn path=/trunk/; revision=28350

9 files changed, 557 insertions, 835 deletions

diff --git a/airpcap_loader.c b/airpcap_loader.c
index 765737cac6..b42b8d5dc6 100644
--- a/airpcap_loader.c
+++ b/airpcap_loader.c
@@ -821,10 +821,10 @@ airpcap_if_get_device_supported_channels_array(PAirpcapHandle ah, guint32 * pNum
             switch(chanInfo[i].ExtChannel)
             {
                 case -1:
-                    pSupportedChannels[numSupportedChannels].Flags = FLAG_CAN_BE_HIGH;
+                    pSupportedChannels[numSupportedChannels].Flags = FLAG_CAN_BE_LOW;
                     break;
                 case +1:
-                    pSupportedChannels[numSupportedChannels].Flags = FLAG_CAN_BE_LOW;
+                    pSupportedChannels[numSupportedChannels].Flags = FLAG_CAN_BE_HIGH;
                     break;
                 case 0:
                 default:
@@ -850,10 +850,10 @@ airpcap_if_get_device_supported_channels_array(PAirpcapHandle ah, guint32 * pNum
             switch(chanInfo[i].ExtChannel)
             {
                 case -1:
-                    pSupportedChannels[supportedChannel].Flags |= FLAG_CAN_BE_HIGH;
+                    pSupportedChannels[supportedChannel].Flags |= FLAG_CAN_BE_LOW;
                     break;
                 case +1:
-                    pSupportedChannels[supportedChannel].Flags |= FLAG_CAN_BE_LOW;
+                    pSupportedChannels[supportedChannel].Flags |= FLAG_CAN_BE_HIGH;
                     break;
                 case 0:
                 default:
diff --git a/gtk/airpcap_dlg.c b/gtk/airpcap_dlg.c
index cde4d4e7eb..8231f6e3c4 100644
--- a/gtk/airpcap_dlg.c
+++ b/gtk/airpcap_dlg.c
@@ -181,7 +181,7 @@ on_key_ls_click_column(GtkWidget *widget _U_,
  * Callback for the crc checkbox
  */
 static void
-on_fcs_ck_toggled(GtkWidget *w _U_, gpointer user_data _U_)
+on_fcs_ck_toggled(GtkWidget *w, gpointer user_data)
 
 {
     if (airpcap_if_selected != NULL)
@@ -203,24 +203,24 @@ on_fcs_ck_toggled(GtkWidget *w _U_, gpointer user_data _U_)
  * Callback for the wrong crc combo
  */
 static void
-on_edit_type_en_changed(GtkWidget *w, gpointer data)
+on_edit_type_cb_changed(GtkWidget *w, gpointer data)
 {
     GtkWidget *edit_key_w;
     GtkWidget *edit_ssid_te;
-    GtkWidget *type_te;
+    GtkWidget *type_cb;
     GtkWidget *key_lb;
     GtkWidget *ssid_lb;
 
     gchar* type_text = NULL;
 
     edit_key_w = GTK_WIDGET(data);
-    type_te    = w;
+    type_cb    = w;
 
     edit_ssid_te = g_object_get_data(G_OBJECT(edit_key_w),AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY);
     key_lb = g_object_get_data(G_OBJECT(edit_key_w),AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY);
     ssid_lb = g_object_get_data(G_OBJECT(edit_key_w),AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY);
 
-    type_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(type_te)));
+    type_text = gtk_combo_box_get_active_text(GTK_COMBO_BOX(type_cb));
 
     if (string_is_not_empty(type_text))
     {
@@ -271,24 +271,24 @@ on_edit_type_en_changed(GtkWidget *w, gpointer data)
  * Callback for the wrong crc combo
  */
 static void
-on_add_type_en_changed(GtkWidget *w, gpointer data)
+on_add_type_cb_changed(GtkWidget *w, gpointer data)
 {
     GtkWidget *add_key_w;
     GtkWidget *add_ssid_te;
-    GtkWidget *type_te;
+    GtkWidget *type_cb;
     GtkWidget *key_lb;
     GtkWidget *ssid_lb;
 
     gchar* type_text = NULL;
 
     add_key_w = GTK_WIDGET(data);
-    type_te    = w;
+    type_cb   = w;
 
     add_ssid_te = g_object_get_data(G_OBJECT(add_key_w),AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY);
     key_lb = g_object_get_data(G_OBJECT(add_key_w),AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY);
     ssid_lb = g_object_get_data(G_OBJECT(add_key_w),AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY);
 
-    type_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(type_te)));
+    type_text = gtk_combo_box_get_active_text(GTK_COMBO_BOX(type_cb));
 
     if (string_is_not_empty(type_text))
     {
@@ -352,91 +352,43 @@ string_is_not_empty(gchar *s)
  * Callback for the wrong crc combo
  */
 static void
-on_fcs_filter_en_changed(GtkWidget *w, gpointer data _U_)
+on_fcs_filter_cb_changed(GtkWidget *fcs_filter_cb, gpointer data _U_)
 {
-    const gchar *s;
+    gchar *fcs_filter_str;
 
-    s = gtk_entry_get_text(GTK_ENTRY(w));
-
-    if (w != NULL)
+    if (fcs_filter_cb != NULL)
     {
-        if ((g_ascii_strcasecmp("",s)))
+        fcs_filter_str = gtk_combo_box_get_active_text(GTK_COMBO_BOX(fcs_filter_cb));
+        if (fcs_filter_str && (g_ascii_strcasecmp("", fcs_filter_str)))
         {
-            airpcap_if_selected->CrcValidationOn = airpcap_get_validation_type(s);
+            airpcap_if_selected->CrcValidationOn = airpcap_get_validation_type(fcs_filter_str);
             airpcap_if_selected->saved = FALSE;
         }
+        g_free(fcs_filter_str);
     }
 }
 
-/*
- * Changed callback for the channel combobox
- */
-static void
-on_channel_en_changed(GtkWidget *w, gpointer data _U_)
-{
-    const gchar *s;
-    guint32 ch_freq;
-
-    if (w != NULL)
-    {
-        s = gtk_entry_get_text(GTK_ENTRY(w));
-        if ((g_ascii_strcasecmp("",s)))
-        {
-            if (airpcap_if_selected != NULL)
-            {
-				ch_freq = airpcap_get_frequency_from_str(s);
-				airpcap_if_active->channelInfo.Frequency = ch_freq;
-				airpcap_if_selected->saved = FALSE;
-				airpcap_update_channel_offset_cb(airpcap_if_selected, ch_freq, GTK_WIDGET(data));
-            }
-        }
-    }
-}
-
-/*
- * Changed callback for the channel offset combobox
- */
-static void
-on_channel_offset_cb_changed(GtkWidget *w, gpointer data _U_)
-{
-	const gchar *s;
-	int offset;
-
-	if (w == NULL || !GTK_WIDGET_SENSITIVE(w)) {
-		return;
-	}
-
-	s = gtk_entry_get_text(GTK_ENTRY(w));
-	if ((g_ascii_strcasecmp("",s)))
-	{
-		if (airpcap_if_selected != NULL)
-		{
-			sscanf(s,"%d",&offset);
-			airpcap_if_selected->channelInfo.ExtChannel = offset;
-			airpcap_if_selected->saved = FALSE;
-		}
-	}
-}
 
 /*
  * Changed callback for the capture type combobox
  */
 static void
-on_capture_type_en_changed(GtkWidget *w, gpointer data _U_)
+on_capture_type_cb_changed(GtkWidget *cb, gpointer data _U_)
 {
-    const gchar *s;
+    gchar *s;
 
-	if (w == NULL) {
+	if (cb == NULL) {
 		return;
 	}
 	
-    s = gtk_entry_get_text(GTK_ENTRY(w));
+    s = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cb));
 
 	if ((g_ascii_strcasecmp("",s)))
 	{
 		airpcap_if_selected->linkType = airpcap_get_link_type(s);
 		airpcap_if_selected->saved = FALSE;
 	}
+    g_free(s);
 }
 
 /*
@@ -500,7 +452,7 @@ on_blink_bt_clicked( GtkWidget *blink_bt, gpointer if_data _U_)
                 airpcap_if_close(ad);
             }
         }
-	}
+    }
 }
 
 /*
@@ -604,33 +556,36 @@ on_key_management_apply_bt_clicked(GtkWidget *button _U_, gpointer data)
 
     /* widgets in the toolbar */
     GtkWidget	*toolbar;
-    GtkWidget   *toolbar_cm;
+    GtkWidget   *toolbar_cb;
     GtkWidget   *key_ls;
-    GtkWidget   *decryption_en;
+    GtkWidget   *decryption_mode_cb;
 
     module_t *wlan_module = prefs_find_module("wlan");
+    gchar *decryption_mode_string;
 
     /* retrieve main window */
     key_management_w      = GTK_WIDGET(data);
-    decryption_en         = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_WEP_DECRYPTION_KEY));
+    decryption_mode_cb    = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_DECRYPTION_MODE_KEY));
     key_ls                = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_ADVANCED_KEYLIST_KEY));
     toolbar               = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_TOOLBAR_KEY));
-    toolbar_cm            = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+    toolbar_cb            = GTK_WIDGET(g_object_get_data(G_OBJECT(key_management_w),AIRPCAP_TOOLBAR_DECRYPTION_KEY));
 
 #define CANT_SAVE_ERR_STR "Cannot save configuration! Another application " \
     "might be using AirPcap, or you might not have sufficient privileges."
     /* Set the Decryption Mode */
-    if (g_ascii_strcasecmp(gtk_entry_get_text(GTK_ENTRY(decryption_en)),AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK) == 0)
+
+    decryption_mode_string = gtk_combo_box_get_active_text (GTK_COMBO_BOX(decryption_mode_cb));
+    if (g_ascii_strcasecmp(decryption_mode_string, AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK) == 0)
     {
         set_wireshark_decryption(TRUE);
         if (!set_airpcap_decryption(FALSE)) g_warning(CANT_SAVE_ERR_STR);
     }
-    else if (g_ascii_strcasecmp(gtk_entry_get_text(GTK_ENTRY(decryption_en)),AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0)
+    else if (g_ascii_strcasecmp(decryption_mode_string, AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0)
     {
         set_wireshark_decryption(FALSE);
         if (!set_airpcap_decryption(TRUE)) g_warning(CANT_SAVE_ERR_STR);
     }
-    else if (g_ascii_strcasecmp(gtk_entry_get_text(GTK_ENTRY(decryption_en)),AIRPCAP_DECRYPTION_TYPE_STRING_NONE) == 0)
+    else if (g_ascii_strcasecmp(decryption_mode_string, AIRPCAP_DECRYPTION_TYPE_STRING_NONE) == 0)
     {
         set_wireshark_decryption(FALSE);
         if (!set_airpcap_decryption(FALSE)) g_warning(CANT_SAVE_ERR_STR);
@@ -640,105 +595,11 @@ on_key_management_apply_bt_clicked(GtkWidget *button _U_, gpointer data)
     airpcap_read_and_save_decryption_keys_from_clist(key_ls,airpcap_if_selected,airpcap_if_list); /* This will save the keys for every adapter */
 
     /* The update will make redissect al the packets... no need to do it here again */
-    update_decryption_mode_cm(toolbar_cm);
+    update_decryption_mode(toolbar_cb);
 
     /* Redissect all the packets, and re-evaluate the display filter. */
     prefs_apply(wlan_module);
 }
-/*
- * Callback for the Wireless Advanced Settings 'Apply' button.
- */
-void
-on_advanced_apply_bt_clicked(GtkWidget *button _U_, gpointer data _U_)
-{
-    /* advenced window */
-    GtkWidget	*main_w;
-
-    /* widgets in the toolbar */
-    GtkWidget	*toolbar,
-    *toolbar_if_lb,
-    *toolbar_channel_cm,
-    *toolbar_channel_offset_cb,
-    *toolbar_wrong_crc_cm;
-
-    /* retrieve main window */
-    main_w = GTK_WIDGET(data);
-
-    toolbar = GTK_WIDGET(g_object_get_data(G_OBJECT(main_w),AIRPCAP_TOOLBAR_KEY));
-
-    /* retrieve toolbar info */
-    toolbar_if_lb				= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
-    toolbar_channel_cm			= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
-    toolbar_channel_offset_cb	= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY));
-    toolbar_wrong_crc_cm		= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
-
-    /* Save the configuration (for all ) */
-    airpcap_save_selected_if_configuration(airpcap_if_selected);
-
-    /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
-    if ( g_ascii_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
-    {
-		gtk_label_set_text(GTK_LABEL(toolbar_if_lb), g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_selected)));
-		airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);
-		airpcap_update_channel_offset_combo_entry(GTK_WIDGET(toolbar_channel_offset_cb),airpcap_if_selected->channelInfo.ExtChannel);
-		airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
-    }
-}
-
-#if 0 /* XXX: not used ?? */
-/*
- * Callback for the 'OK' button.
- */
-static void
-airpcap_advanced_ok_cb(GtkWidget *w, gpointer data _U_)
-{
-    /* advanced window */
-    GtkWidget	*main_w;
-
-    /* widgets in the toolbar */
-    GtkWidget	*toolbar,
-    *toolbar_if_lb,
-    *toolbar_channel_cm,
-    *toolbar_wrong_crc_cm,
-    *toolbar_decryption_ck;
-
-    GtkWidget	*key_ls;
-
-    /* retrieve main window */
-    main_w = GTK_WIDGET(data);
-
-    toolbar = GTK_WIDGET(g_object_get_data(G_OBJECT(main_w),AIRPCAP_TOOLBAR_KEY));
-
-    key_ls	= GTK_WIDGET(g_object_get_data(G_OBJECT(main_w),AIRPCAP_ADVANCED_KEYLIST_KEY));
-
-    /* retrieve toolbar info */
-    toolbar_if_lb			= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
-    toolbar_channel_cm		= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
-    toolbar_wrong_crc_cm	= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
-    toolbar_decryption_ck	= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_DECRYPTION_KEY));
-
-    /* Save the configuration */
-    airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
-    airpcap_save_selected_if_configuration(airpcap_if_selected);
-    /* Remove GLIB timeout */
-    g_source_remove(airpcap_if_selected->tag);
-
-    /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
-    if ( g_ascii_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
-    {
-        gtk_label_set_text(GTK_LABEL(toolbar_if_lb), g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_selected)));
-        airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);
-        airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
-
-        g_signal_handlers_block_by_func (toolbar_decryption_ck,airpcap_toolbar_encryption_cb, toolbar);
-        if (airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
-            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),TRUE);
-        else
-            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),FALSE);
-        g_signal_handlers_unblock_by_func (toolbar_decryption_ck,airpcap_toolbar_encryption_cb, toolbar);
-    }
-}
-#endif
 
 /*
  * Callback for the 'Reset Configuration' button.
@@ -1169,16 +1030,14 @@ on_edit_key_ok_bt_clicked(GtkWidget *widget _U_, gpointer data _U_)
  * Callback for the 'Add Key' button.
  */
 void
-on_add_new_key_bt_clicked(GtkWidget *button _U_, gpointer data _U_)
+on_add_new_key_bt_clicked(GtkWidget *button, gpointer data _U_)
 {
     GtkWidget *add_key_window;
     GtkWidget *add_frame;
     GtkWidget *main_v_box;
     GtkWidget *add_tb;
     GtkWidget *add_frame_al;
-    GtkWidget *add_type_cm;
-    GList *add_type_cm_items = NULL;
-    GtkWidget *add_type_en;
+    GtkWidget *add_type_cb;
     GtkWidget *add_key_te;
     GtkWidget *add_ssid_te;
     GtkWidget *add_type_lb;
@@ -1251,28 +1110,20 @@ on_add_new_key_bt_clicked(GtkWidget *button _U_, gpointer data _U_)
     gtk_widget_show (add_tb);
     gtk_container_add (GTK_CONTAINER (add_frame_al), add_tb);
 
-    add_type_cm = gtk_combo_new ();
-    gtk_widget_set_name (add_type_cm, "add_type_cm");
-    gtk_widget_show (add_type_cm);
-    gtk_table_attach (GTK_TABLE (add_tb), add_type_cm, 0, 1, 1, 2,
-                      (GtkAttachOptions) (GTK_FILL),
-                      (GtkAttachOptions) (0), 0, 0);
-    gtk_widget_set_size_request (add_type_cm, 83, -1);
-    add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WEP_KEY_STRING);
+    add_type_cb = gtk_combo_box_new_text();
+    gtk_combo_box_append_text(GTK_COMBO_BOX(add_type_cb), AIRPCAP_WEP_KEY_STRING);
 
-    /* XXX - DEcomment only when WPA and WPA_BIN will be ready */
 #ifdef HAVE_AIRPDCAP
-    add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WPA_PWD_KEY_STRING);
-    add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WPA_BIN_KEY_STRING);
+    gtk_combo_box_append_text(GTK_COMBO_BOX(add_type_cb), AIRPCAP_WPA_PWD_KEY_STRING);
+    gtk_combo_box_append_text(GTK_COMBO_BOX(add_type_cb), AIRPCAP_WPA_BIN_KEY_STRING);
 #endif
-    gtk_combo_set_popdown_strings (GTK_COMBO (add_type_cm),
-                                   add_type_cm_items);
-    g_list_free (add_type_cm_items);
-
-    add_type_en = GTK_COMBO (add_type_cm)->entry;
-    gtk_widget_set_name (add_type_en, "add_type_en");
-    gtk_editable_set_editable (GTK_EDITABLE (add_type_en), FALSE);
-    gtk_widget_show (add_type_en);
+    gtk_combo_box_set_active(GTK_COMBO_BOX(add_type_cb), 0);
+    gtk_widget_set_name (add_type_cb, "add_type_cb");
+    gtk_widget_show (add_type_cb);
+    gtk_table_attach (GTK_TABLE (add_tb), add_type_cb, 0, 1, 1, 2,
+                      (GtkAttachOptions) (GTK_FILL),
+                      (GtkAttachOptions) (0), 0, 0);
+    gtk_widget_set_size_request (add_type_cb, 83, -1);
 
     add_key_te = gtk_entry_new ();
     gtk_widget_set_name (add_key_te, "add_key_te");
@@ -1344,14 +1195,14 @@ on_add_new_key_bt_clicked(GtkWidget *button _U_, gpointer data _U_)
     /* Add callbacks */
     g_signal_connect(ok_bt, "clicked", G_CALLBACK(on_add_key_ok_bt_clicked), add_key_window );
     g_signal_connect(cancel_bt, "clicked", G_CALLBACK(window_cancel_button_cb), add_key_window );
-    g_signal_connect(add_type_en, "changed", G_CALLBACK(on_add_type_en_changed), add_key_window);
+    g_signal_connect(add_type_cb, "changed", G_CALLBACK(on_add_type_cb_changed), add_key_window);
     g_signal_connect(add_key_window, "delete_event", G_CALLBACK(window_delete_event_cb), add_key_window);
     g_signal_connect(add_key_window, "destroy", G_CALLBACK(on_add_key_w_destroy), data);
 
     /* Add widget data */
     g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_LIST_KEY,key_ls);
     g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY,selected_item);
-    g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY,add_type_cm);
+    g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY,add_type_cb);
     g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_KEY_KEY,add_key_te);
     g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY,add_ssid_te);
     g_object_set_data(G_OBJECT(add_key_window),AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY,add_key_lb);
@@ -1448,9 +1299,7 @@ on_edit_key_bt_clicked(GtkWidget *button _U_, gpointer data)
     GtkWidget *main_v_box;
     GtkWidget *edit_tb;
     GtkWidget *edit_frame_al;
-    GtkWidget *edit_type_cm;
-    GList *edit_type_cm_items = NULL;
-    GtkWidget *edit_type_en;
+    GtkWidget *edit_type_cb;
     GtkWidget *edit_key_te;
     GtkWidget *edit_ssid_te;
     GtkWidget *edit_type_lb;
@@ -1523,29 +1372,28 @@ on_edit_key_bt_clicked(GtkWidget *button _U_, gpointer data)
         gtk_widget_show (edit_tb);
         gtk_container_add (GTK_CONTAINER (edit_frame_al), edit_tb);
 
-        edit_type_cm = gtk_combo_new ();
-        gtk_widget_set_name (edit_type_cm, "edit_type_cm");
-        gtk_widget_show (edit_type_cm);
-        gtk_table_attach (GTK_TABLE (edit_tb), edit_type_cm, 0, 1, 1, 2,
-                          (GtkAttachOptions) (GTK_FILL),
-                          (GtkAttachOptions) (0), 0, 0);
-        gtk_widget_set_size_request (edit_type_cm, 83, -1);
-        edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WEP_KEY_STRING);
-        /* XXX - Decomment only when WPA and WPA_BIN support will be ready!!! */
+        edit_type_cb = gtk_combo_box_new_text();
+        gtk_combo_box_append_text(GTK_COMBO_BOX(edit_type_cb), AIRPCAP_WEP_KEY_STRING);
+
 #ifdef HAVE_AIRPDCAP
-        edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WPA_PWD_KEY_STRING);
-        edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WPA_BIN_KEY_STRING);
+        gtk_combo_box_append_text(GTK_COMBO_BOX(edit_type_cb), AIRPCAP_WPA_PWD_KEY_STRING);
+        gtk_combo_box_append_text(GTK_COMBO_BOX(edit_type_cb), AIRPCAP_WPA_BIN_KEY_STRING);
 #endif
-        gtk_combo_set_popdown_strings (GTK_COMBO (edit_type_cm),
-                                       edit_type_cm_items);
-        g_list_free (edit_type_cm_items);
-
-        edit_type_en = GTK_COMBO (edit_type_cm)->entry;
-        gtk_widget_set_name (edit_type_en, "edit_type_en");
         /* Set current type */
-        gtk_entry_set_text(GTK_ENTRY(edit_type_en),row_type);
-        gtk_editable_set_editable (GTK_EDITABLE (edit_type_en), FALSE);
-        gtk_widget_show (edit_type_en);
+        gtk_combo_box_set_active(GTK_COMBO_BOX(edit_type_cb), 0);
+#ifdef HAVE_AIRPDCAP
+        if (g_ascii_strcasecmp(row_type, AIRPCAP_WPA_PWD_KEY_STRING) == 0) {
+            gtk_combo_box_set_active(GTK_COMBO_BOX(edit_type_cb), 1);
+        } else if (g_ascii_strcasecmp(row_type, AIRPCAP_WPA_BIN_KEY_STRING) == 0) {
+            gtk_combo_box_set_active(GTK_COMBO_BOX(edit_type_cb), 2);
+        }
+#endif
+        gtk_widget_set_name (edit_type_cb, "edit_type_cb");
+        gtk_widget_show (edit_type_cb);
+        gtk_table_attach (GTK_TABLE (edit_tb), edit_type_cb, 0, 1, 1, 2,
+                          (GtkAttachOptions) (GTK_FILL),
+                          (GtkAttachOptions) (0), 0, 0);
+        gtk_widget_set_size_request (edit_type_cb, 83, -1);
 
         edit_key_te = gtk_entry_new ();
         gtk_widget_set_name (edit_key_te, "edit_key_te");
@@ -1631,14 +1479,14 @@ on_edit_key_bt_clicked(GtkWidget *button _U_, gpointer data)
         /* Add callbacks */
         g_signal_connect(ok_bt, "clicked", G_CALLBACK(on_edit_key_ok_bt_clicked), edit_key_window );
         g_signal_connect(cancel_bt, "clicked", G_CALLBACK(window_cancel_button_cb), edit_key_window );
-        g_signal_connect(edit_type_en, "changed", G_CALLBACK(on_edit_type_en_changed), edit_key_window);
+        g_signal_connect(edit_type_cb, "changed", G_CALLBACK(on_edit_type_cb_changed), edit_key_window);
         g_signal_connect(edit_key_window, "delete_event", G_CALLBACK(window_delete_event_cb), edit_key_window);
         g_signal_connect(edit_key_window, "destroy", G_CALLBACK(on_edit_key_w_destroy), data);
 
         /* Add widget data */
         g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_LIST_KEY,key_ls);
         g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_SELECTED_KEY,selected_item);
-        g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY,edit_type_cm);
+        g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY,edit_type_cb);
         g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_KEY_KEY,edit_key_te);
         g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY,edit_ssid_te);
         g_object_set_data(G_OBJECT(edit_key_window),AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY,edit_key_lb);
@@ -1750,34 +1598,34 @@ on_move_key_down_bt_clicked(GtkWidget *button _U_, gpointer data)
 
 /* Turns the decryption on or off */
 void
-on_enable_decryption_en_changed(GtkWidget *w, gpointer data _U_)
+on_decryption_mode_cb_changed(GtkWidget *cb, gpointer data)
 {
-    GtkEntry *decryption_en;
-
-    decryption_en = GTK_ENTRY(w);
-
-    /*
-     * This callback is called twice: when the current text is canceled ("")
-     * and then when the 'new text' is added ("new text"). We don't really
-     * care about the first time, and we just return.
-     */
-    if (g_ascii_strcasecmp(gtk_entry_get_text(decryption_en),"") == 0)
+    gint cur_active;
+    
+    if (cb == NULL) {
         return;
-
-    if (g_ascii_strcasecmp(gtk_entry_get_text(decryption_en),AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK) == 0)
-    {
-        set_wireshark_decryption(TRUE);
-        if (!set_airpcap_decryption(FALSE)) g_warning(CANT_SAVE_ERR_STR);
     }
-    else if (g_ascii_strcasecmp(gtk_entry_get_text(decryption_en),AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0)
-    {
-        set_wireshark_decryption(FALSE);
-        if (!set_airpcap_decryption(TRUE)) g_warning(CANT_SAVE_ERR_STR);
+    
+    cur_active = gtk_combo_box_get_active(GTK_COMBO_BOX(cb));
+    
+    if (cur_active < 0) {
+        return;
     }
-    else if (g_ascii_strcasecmp(gtk_entry_get_text(decryption_en),AIRPCAP_DECRYPTION_TYPE_STRING_NONE) == 0)
-    {
-        set_wireshark_decryption(FALSE);
-        if (!set_airpcap_decryption(FALSE)) g_warning(CANT_SAVE_ERR_STR);
+    
+    switch(cur_active) {
+        /* XXX - Don't use magic numbers here */
+        case 1: /* Wireshark */
+            set_wireshark_decryption(TRUE);
+            if (!set_airpcap_decryption(FALSE)) g_warning(CANT_SAVE_ERR_STR);
+            break;
+        case 2: /* Driver */
+            set_wireshark_decryption(FALSE);
+            if (!set_airpcap_decryption(TRUE)) g_warning(CANT_SAVE_ERR_STR);
+            break;
+        default:
+            set_wireshark_decryption(FALSE);
+            if (!set_airpcap_decryption(FALSE)) g_warning(CANT_SAVE_ERR_STR);
+            break;
     }
 
     /* Redissect all the packets, and re-evaluate the display filter. */
@@ -1785,33 +1633,29 @@ on_enable_decryption_en_changed(GtkWidget *w, gpointer data _U_)
 }
 
 /*
- * Will fill the given combo box with the current decryption mode string
+ * Selects the current decryption mode string in the decryption mode combo box
  */
 void
-update_decryption_mode_cm(GtkWidget *w)
+update_decryption_mode(GtkWidget *cb)
 {
-    /*
-     * This ensures that the entry get changes... the callback will return immediately, but
-     * at least next time packets will be redissected...
-     */
-    gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),"");
+    if (cb == NULL) {
+        return;
+    }
 
     /* Wireshark decryption is on */
     if (wireshark_decryption_on())
     {
-        gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK);
-        /* We don't know if AirPcap decryption is on or off, but we just turn it off */
-        if (!set_airpcap_decryption(FALSE)) g_warning(CANT_SAVE_ERR_STR);
+        gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 1);
     }
     /* AirPcap decryption is on */
     else if (airpcap_decryption_on())
     {
-        gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP);
+        gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 2);
     }
     /* No decryption enabled */
     else
     {
-        gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),AIRPCAP_DECRYPTION_TYPE_STRING_NONE);
+        gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 0);
     }
 
     return;
@@ -1821,51 +1665,51 @@ update_decryption_mode_cm(GtkWidget *w)
  * Creates the list of available decryption modes, depending on the adapters found
  */
 void
-update_decryption_mode_list(GtkWidget *w)
+update_decryption_mode_list(GtkWidget *cb)
 {
-    GList		*enable_decryption_cb_items = NULL;
-    GtkWidget	*entry;
-    gchar		*current_text;
+    gchar *current_text;
 
-    if (w == NULL)
+    if (cb == NULL)
         return;
 
-    entry = GTK_COMBO(w)->entry;
     current_text = NULL;
 
     /*
      * XXX - Retrieve the current 'decryption mode'. It would be better just block the
      * signal handler, but it doesn't work... one of these days I'll try to figure out why...
      */
-    current_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
-
-    enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_NONE);
-    enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK);
+    current_text = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cb));
+    
+    while (gtk_tree_model_iter_n_children(gtk_combo_box_get_model(GTK_COMBO_BOX(cb)), NULL) > 0) {
+        gtk_combo_box_remove_text(GTK_COMBO_BOX(cb), 0);
+    }
 
+    gtk_combo_box_append_text(GTK_COMBO_BOX(cb), AIRPCAP_DECRYPTION_TYPE_STRING_NONE);
+    gtk_combo_box_append_text(GTK_COMBO_BOX(cb), AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK);
+    
     if (airpcap_if_list != NULL && g_list_length(airpcap_if_list) > 0)
     {
-        enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP);
+        gtk_combo_box_append_text(GTK_COMBO_BOX(cb), AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP);
     }
     else
     {
         /* The last decryption mode was 'Driver', but no more AirPcap adapter are found */
         if (g_ascii_strcasecmp(current_text,AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0)
         {
-            if (current_text != NULL) g_free(current_text);
-
+            g_free(current_text);
             current_text = g_strdup(AIRPCAP_DECRYPTION_TYPE_STRING_NONE);
         }
     }
 
-    g_signal_handlers_block_matched(entry,G_SIGNAL_MATCH_DATA,0,0,0,0,airpcap_tb);
-    gtk_combo_set_popdown_strings (GTK_COMBO (w), enable_decryption_cb_items);
-    /* The 'changed' callback will be called twice */
-    gtk_entry_set_text(GTK_ENTRY(entry),current_text);
-    g_signal_handlers_unblock_matched(entry,G_SIGNAL_MATCH_DATA,0,0,0,0,airpcap_tb);
-
-    if (current_text != NULL) g_free(current_text);
+    if (g_ascii_strcasecmp(current_text, AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK) == 0) {
+        gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 1);
+    } else if (g_ascii_strcasecmp(current_text, AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0) {
+        gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 2);
+    } else { /* None / Invalid */
+        gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 0);
+    }
 
-    g_list_free (enable_decryption_cb_items);
+    g_free(current_text);
 }
 
 /* Called to create the airpcap settings' window */
@@ -1887,19 +1731,13 @@ display_airpcap_advanced_cb(GtkWidget *w _U_, gpointer data)
     GtkWidget *channel_lb;
     GtkWidget *channel_offset_lb;
     GtkWidget *capture_type_lb;
-    GtkWidget *channel_cm;
-    GList *channel_cm_items = NULL;
-    GtkWidget *channel_en;
-    GtkWidget *capture_type_cm;
+    GtkWidget *channel_cb;
     GtkWidget *channel_offset_cb;
-    GList *capture_type_cm_items = NULL;
-    GtkWidget *capture_type_en;
+    GtkWidget *capture_type_cb;
     GtkWidget *fcs_ck;
     GtkWidget *basic_parameters_fcs_h_box;
     GtkWidget *basic_parameters_fcs_filter_lb;
-    GtkWidget *fcs_filter_cm;
-    GList *fcs_filter_cm_items = NULL;
-    GtkWidget *fcs_filter_en;
+    GtkWidget *fcs_filter_cb;
     GtkWidget *basic_parameters_frame_lb;
     GtkWidget *low_buttons_h_box;
     GtkWidget *left_h_button_box;
@@ -1909,25 +1747,17 @@ display_airpcap_advanced_cb(GtkWidget *w _U_, gpointer data)
     GtkWidget *apply_bt;
     GtkWidget *cancel_bt;
 
-    /* for loop counter */
-    guint i;
-
     /* widgets in the toolbar */
     GtkWidget	*toolbar,
     *toolbar_if_lb,
-    *toolbar_channel_cm,
-    *toolbar_wrong_crc_cm;
-
-    /* other stuff */
-    /*GList				*channel_list,*capture_list;*/
-    /*GList				*linktype_list = NULL;*/
-    gchar				*capture_s;
+    *toolbar_channel_cb,
+    *toolbar_wrong_crc_cb;
 
     /* user data - RETRIEVE pointers of toolbar widgets */
     toolbar				= GTK_WIDGET(data);
     toolbar_if_lb		= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
-    toolbar_channel_cm	= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
-    toolbar_wrong_crc_cm= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
+    toolbar_channel_cb	= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
+    toolbar_wrong_crc_cb= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
 
     /* gray out the toolbar */
     gtk_widget_set_sensitive(toolbar,FALSE);
@@ -2059,12 +1889,10 @@ display_airpcap_advanced_cb(GtkWidget *w _U_, gpointer data)
     /* End: Channel offset label */
 
     /* Start: Channel offset combo box */
-    channel_offset_cb = gtk_combo_new();
+    channel_offset_cb = gtk_combo_box_new_text();
     gtk_widget_set_name (channel_offset_cb, "channel_offset_cb");
-    gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(channel_offset_cb)->entry),FALSE);
 
-    airpcap_update_channel_offset_cb(airpcap_if_selected, airpcap_if_selected->channelInfo.Frequency, channel_offset_cb);
-    airpcap_update_channel_offset_combo_entry(channel_offset_cb, airpcap_if_selected->channelInfo.ExtChannel);
+    airpcap_update_channel_offset_combo(airpcap_if_selected, airpcap_if_selected->channelInfo.Frequency, channel_offset_cb);
 
     gtk_widget_show(channel_offset_cb);
 
@@ -2073,72 +1901,40 @@ display_airpcap_advanced_cb(GtkWidget *w _U_, gpointer data)
                   (GtkAttachOptions) (0), 0, 0);
     /* End: Channel offset combo box */
 
-    channel_cm = gtk_combo_new ();
-    gtk_widget_set_name (channel_cm, "channel_cm");
-    gtk_widget_show (channel_cm);
-    gtk_table_attach (GTK_TABLE (basic_parameters_tb), channel_cm, 1, 2, 0, 1,
+    channel_cb = gtk_combo_box_new_text();
+    gtk_widget_set_name (channel_cb, "channel_cb");
+    gtk_widget_show (channel_cb);
+    gtk_table_attach (GTK_TABLE (basic_parameters_tb), channel_cb, 1, 2, 0, 1,
                       (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                       (GtkAttachOptions) (0), 0, 0);
 
-    if (airpcap_if_selected != NULL && airpcap_if_selected->pSupportedChannels != NULL && airpcap_if_selected->numSupportedChannels > 0){
-        for (i = 0; i<(airpcap_if_selected->numSupportedChannels); i++){
-            channel_cm_items = g_list_append(channel_cm_items, ieee80211_mhz_to_str(airpcap_if_selected->pSupportedChannels[i].Frequency));
-        }
-        gtk_combo_set_popdown_strings( GTK_COMBO(channel_cm), channel_cm_items);
-        airpcap_free_channel_combo_list (channel_cm_items);
-    }
+    /* Select the current channel */
+    airpcap_update_channel_combo(GTK_WIDGET(channel_cb), airpcap_if_selected);
 
-    /* Select the first entry */
-    if (airpcap_if_selected != NULL)
-    {
-        airpcap_update_channel_combo(GTK_WIDGET(channel_cm), airpcap_if_selected);
+    capture_type_cb = gtk_combo_box_new_text();
+    gtk_combo_box_append_text(GTK_COMBO_BOX(capture_type_cb), AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
+    gtk_combo_box_append_text(GTK_COMBO_BOX(capture_type_cb), AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
+    if (airpcap_get_dll_state() == AIRPCAP_DLL_OK) {
+        gtk_combo_box_append_text(GTK_COMBO_BOX(capture_type_cb), AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_PPI);
     }
 
-
-    channel_en = GTK_COMBO (channel_cm)->entry;
-    gtk_editable_set_editable(GTK_EDITABLE(channel_en),FALSE);
-    gtk_widget_set_name (channel_en, "channel_en");
-    gtk_widget_show (channel_en);
-
-    capture_type_cm = gtk_combo_new ();
-    gtk_widget_set_name (capture_type_cm, "capture_type_cm");
-    gtk_widget_show (capture_type_cm);
-    gtk_table_attach (GTK_TABLE (basic_parameters_tb), capture_type_cm, 1, 2, 2,
+    gtk_widget_set_name (capture_type_cb, "capture_type_cb");
+    gtk_widget_show (capture_type_cb);
+    gtk_table_attach (GTK_TABLE (basic_parameters_tb), capture_type_cb, 1, 2, 2,
                       3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                       (GtkAttachOptions) (0), 0, 0);
-    capture_type_cm_items =
-        g_list_append (capture_type_cm_items, (gpointer) AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
-    capture_type_cm_items =
-        g_list_append (capture_type_cm_items, (gpointer) AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
-
-    if (airpcap_get_dll_state() == AIRPCAP_DLL_OK){
-        capture_type_cm_items =
-            g_list_append (capture_type_cm_items, (gpointer) AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_PPI);
-    }
-    gtk_combo_set_popdown_strings (GTK_COMBO (capture_type_cm),
-                                   capture_type_cm_items);
 
     /* Current interface value */
-    capture_s = NULL;
     if (airpcap_if_selected != NULL)
     {
-		if (airpcap_if_selected->linkType == AIRPCAP_LT_802_11){
-			capture_s = g_strdup(AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
-		}else if (airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_RADIO){
-			capture_s = g_strdup(AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
+		if (airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_RADIO){
+            gtk_combo_box_set_active(GTK_COMBO_BOX(capture_type_cb), AIRPCAP_LINK_TYPE_NUM_802_11_PLUS_RADIO);
 		}else if (airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_PPI){
-			capture_s = g_strdup(AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_PPI);
+            gtk_combo_box_set_active(GTK_COMBO_BOX(capture_type_cb), AIRPCAP_LINK_TYPE_NUM_802_11_PLUS_PPI);
+		} else {
+            gtk_combo_box_set_active(GTK_COMBO_BOX(capture_type_cb), AIRPCAP_LINK_TYPE_NUM_802_11_ONLY);
 		}
-
-        if (capture_s != NULL) gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_type_cm)->entry), capture_s);
     }
-    g_free(capture_s);
-
-    g_list_free (capture_type_cm_items);
-
-    capture_type_en = GTK_COMBO (capture_type_cm)->entry;
-    gtk_widget_set_name (capture_type_en, "capture_type_en");
-    gtk_widget_show (capture_type_en);
 
     fcs_ck = gtk_check_button_new_with_label ("Include 802.11 FCS in Frames");
 
@@ -2174,32 +1970,22 @@ display_airpcap_advanced_cb(GtkWidget *w _U_, gpointer data)
     gtk_box_pack_start (GTK_BOX (basic_parameters_fcs_h_box),
                         basic_parameters_fcs_filter_lb, FALSE, FALSE, 0);
 
-    fcs_filter_cm = gtk_combo_new ();
-    gtk_widget_set_name (fcs_filter_cm, "fcs_filter_cm");
-    gtk_widget_show (fcs_filter_cm);
-    gtk_box_pack_start (GTK_BOX (basic_parameters_fcs_h_box), fcs_filter_cm,
+    fcs_filter_cb = gtk_combo_box_new_text();
+    gtk_combo_box_append_text(GTK_COMBO_BOX(fcs_filter_cb), airpcap_get_validation_name(AIRPCAP_VT_ACCEPT_EVERYTHING));
+    gtk_combo_box_append_text(GTK_COMBO_BOX(fcs_filter_cb), airpcap_get_validation_name(AIRPCAP_VT_ACCEPT_CORRECT_FRAMES));
+    gtk_combo_box_append_text(GTK_COMBO_BOX(fcs_filter_cb), airpcap_get_validation_name(AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES));
+    gtk_combo_box_set_active(GTK_COMBO_BOX(fcs_filter_cb), 0);
+    gtk_widget_set_name (fcs_filter_cb, "fcs_filter_cb");
+    gtk_widget_show (fcs_filter_cb);
+    gtk_box_pack_start (GTK_BOX (basic_parameters_fcs_h_box), fcs_filter_cb,
                         FALSE, FALSE, 0);
-    gtk_widget_set_size_request (fcs_filter_cm, 112, -1);
-    fcs_filter_cm_items =
-        g_list_append (fcs_filter_cm_items, (gpointer) "All Frames");
-    fcs_filter_cm_items =
-        g_list_append (fcs_filter_cm_items, (gpointer) "Valid Frames");
-    fcs_filter_cm_items =
-        g_list_append (fcs_filter_cm_items, (gpointer) "Invalid Frames");
-    gtk_combo_set_popdown_strings (GTK_COMBO (fcs_filter_cm),
-                                   fcs_filter_cm_items);
-    g_list_free (fcs_filter_cm_items);
-
-    fcs_filter_en = GTK_COMBO (fcs_filter_cm)->entry;
-    gtk_widget_set_name (fcs_filter_en, "fcs_filter_en");
+    gtk_widget_set_size_request (fcs_filter_cb, 112, -1);
 
     if (airpcap_if_selected != NULL)
     {
-        airpcap_validation_type_combo_set_by_type(fcs_filter_cm,airpcap_if_selected->CrcValidationOn);
+        airpcap_validation_type_combo_set_by_type(fcs_filter_cb, airpcap_if_selected->CrcValidationOn);
     }
 
-    gtk_widget_show (fcs_filter_en);
-
     basic_parameters_frame_lb = gtk_label_new ("<b>Basic Parameters</b>");
     gtk_widget_set_name (basic_parameters_frame_lb,
                          "basic_parameters_frame_lb");
@@ -2250,11 +2036,11 @@ display_airpcap_advanced_cb(GtkWidget *w _U_, gpointer data)
         g_signal_connect (blink_bt, "clicked", G_CALLBACK(on_what_s_this_bt_clicked), airpcap_advanced_w);
     }
 
-    g_signal_connect (channel_en, "changed", G_CALLBACK(on_channel_en_changed), channel_offset_cb);
-    g_signal_connect (GTK_COMBO(channel_offset_cb)->entry, "changed", G_CALLBACK(on_channel_offset_cb_changed), NULL);
-    g_signal_connect (capture_type_en, "changed", G_CALLBACK(on_capture_type_en_changed), airpcap_advanced_w);
+    g_signal_connect (channel_cb, "changed", G_CALLBACK(airpcap_channel_changed_cb), channel_offset_cb);
+    g_signal_connect (channel_offset_cb, "changed", G_CALLBACK(airpcap_channel_offset_changed_cb), NULL);
+    g_signal_connect (capture_type_cb, "changed", G_CALLBACK(on_capture_type_cb_changed), airpcap_advanced_w);
     g_signal_connect (fcs_ck, "toggled", G_CALLBACK(on_fcs_ck_toggled), airpcap_advanced_w);
-    g_signal_connect (fcs_filter_en, "changed", G_CALLBACK(on_fcs_filter_en_changed), airpcap_advanced_w);
+    g_signal_connect (fcs_filter_cb, "changed", G_CALLBACK(on_fcs_filter_cb_changed), NULL);
     g_signal_connect (reset_configuration_bt, "clicked", G_CALLBACK(on_reset_configuration_bt_clicked), airpcap_advanced_w);
     g_signal_connect (apply_bt, "clicked", G_CALLBACK(on_advanced_apply_bt_clicked), airpcap_advanced_w);
     g_signal_connect (ok_bt,"clicked", G_CALLBACK(on_advanced_ok_bt_clicked), airpcap_advanced_w);
@@ -2267,10 +2053,10 @@ display_airpcap_advanced_cb(GtkWidget *w _U_, gpointer data)
 
     /* Store pointers to all widgets, for use by lookup_widget(). */
     g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_BLINK_KEY, blink_bt);
-    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_CHANNEL_KEY,channel_cm);
-    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_LINK_TYPE_KEY,capture_type_cm);
+    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_CHANNEL_KEY,channel_cb);
+    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_LINK_TYPE_KEY,capture_type_cb);
     g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_FCS_CHECK_KEY, fcs_ck);
-    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_FCS_FILTER_KEY, fcs_filter_cm);
+    g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_FCS_FILTER_KEY, fcs_filter_cb);
     g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_OK_KEY, ok_bt);
     g_object_set_data (G_OBJECT(airpcap_advanced_w), AIRPCAP_ADVANCED_CANCEL_KEY, cancel_bt);
 
@@ -2285,57 +2071,63 @@ display_airpcap_advanced_cb(GtkWidget *w _U_, gpointer data)
 }
 
 /*
- * Callback for the OK button 'clicked' in the Advanced Wireless Settings window.
+ * Callback for the Wireless Advanced Settings 'Apply' button.
  */
 void
-on_advanced_ok_bt_clicked(GtkWidget *button _U_, gpointer data)
+on_advanced_apply_bt_clicked(GtkWidget *button _U_, gpointer data _U_)
 {
-    PAirpcapHandle ad = NULL;
-    gchar ebuf[AIRPCAP_ERRBUF_SIZE];
-
-    /* Retrieve object data */
-    GtkWidget *airpcap_advanced_w;
-    GtkWidget *channel_combo;
-    GtkWidget *capture_combo;
-    GtkWidget *crc_check;
-    GtkWidget *wrong_crc_combo;
-    GtkWidget *blink_bt;
-    GtkWidget *interface_combo;
-    GtkWidget *cancel_bt;
-    GtkWidget *ok_bt;
+    /* advenced window */
+    GtkWidget	*airpcap_advanced_w;
 
     /* widgets in the toolbar */
     GtkWidget	*toolbar,
     *toolbar_if_lb,
-    *toolbar_channel_cm,
-	*toolbar_channel_offset_cb,
-    *toolbar_wrong_crc_cm,
-    *advanced_bt;
+    *toolbar_channel_cb,
+    *toolbar_channel_offset_cb,
+    *toolbar_fcs_filter_cb;
 
-    /* Retrieve the GUI object pointers */
-    airpcap_advanced_w			= GTK_WIDGET(data);
-    interface_combo				= GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_INTERFACE_KEY));
-    channel_combo				= GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_CHANNEL_KEY));
-    capture_combo				= GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_LINK_TYPE_KEY));
-    crc_check					= GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_FCS_CHECK_KEY));
-    wrong_crc_combo				= GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_FCS_FILTER_KEY));
-    blink_bt					= GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_BLINK_KEY));
-    cancel_bt					= GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_CANCEL_KEY));
-    ok_bt						= GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_OK_KEY));
-    advanced_bt					= GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_ADVANCED_KEY));
-
-    toolbar						= GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_TOOLBAR_KEY));
+    /* retrieve main window */
+    airpcap_advanced_w = GTK_WIDGET(data);
+
+    toolbar = GTK_WIDGET(g_object_get_data(G_OBJECT(airpcap_advanced_w),AIRPCAP_TOOLBAR_KEY));
 
     /* retrieve toolbar info */
-    toolbar_if_lb			= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
-    toolbar_channel_cm		= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
-    toolbar_channel_offset_cb	= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY));
-    toolbar_wrong_crc_cm	= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
+    toolbar_if_lb = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
+    toolbar_channel_cb = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
+    toolbar_channel_offset_cb = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY));
+    toolbar_fcs_filter_cb = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
+
+    /* Save the configuration (for all ) */
+    airpcap_save_selected_if_configuration(airpcap_if_selected);
+
+    /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
+    if ( g_ascii_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
+    {
+        gtk_label_set_text(GTK_LABEL(toolbar_if_lb), g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_selected)));
+        airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cb),airpcap_if_selected);
+        airpcap_update_channel_offset_combo(airpcap_if_selected, airpcap_if_selected->channelInfo.Frequency, toolbar_channel_offset_cb);
+        airpcap_validation_type_combo_set_by_type(toolbar_fcs_filter_cb,airpcap_if_selected->CrcValidationOn);
+    }
+}
+
+/*
+ * Callback for the OK button 'clicked' in the Advanced Wireless Settings window.
+ */
+void
+on_advanced_ok_bt_clicked(GtkWidget *button _U_, gpointer data)
+{
+    PAirpcapHandle ad = NULL;
+    gchar ebuf[AIRPCAP_ERRBUF_SIZE];
+
+    /* Retrieve object data */
+    GtkWidget *airpcap_advanced_w = GTK_WIDGET(data);
 
     if (airpcap_if_selected == NULL) { /* There's not much we can do. */
-		gtk_widget_destroy(airpcap_advanced_w);
-		return;
-	}
+        gtk_widget_destroy(airpcap_advanced_w);
+        return;
+    }
+
+    on_advanced_apply_bt_clicked(button, data);
 
     /* Stop blinking our LED */
     ad = airpcap_if_open(airpcap_if_selected->name, ebuf);
@@ -2348,18 +2140,9 @@ on_advanced_ok_bt_clicked(GtkWidget *button _U_, gpointer data)
         airpcap_if_close(ad);
     }
 
-    /* ??? - Ask if want to save configuration */
-
-    /* Save the configuration */
-    airpcap_save_selected_if_configuration(airpcap_if_selected);
     /* Remove GLIB timeout */
     g_source_remove(airpcap_if_selected->tag);
 
-    gtk_label_set_text(GTK_LABEL(toolbar_if_lb), g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_selected)));
-    airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);
-    airpcap_update_channel_offset_combo_entry(GTK_WIDGET(toolbar_channel_offset_cb),airpcap_if_selected->channelInfo.ExtChannel);
-    airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
-
     gtk_widget_destroy(airpcap_advanced_w);
 }
 
@@ -2386,8 +2169,8 @@ on_advanced_cancel_bt_clicked(GtkWidget *button _U_, gpointer data)
     /* widgets in the toolbar */
     GtkWidget	*toolbar,
     *toolbar_if_lb,
-    *toolbar_channel_cm,
-    *toolbar_wrong_crc_cm,
+    *toolbar_channel_cb,
+    *toolbar_wrong_crc_cb,
     *advanced_bt;
 
     /* Retrieve the GUI object pointers */
@@ -2406,8 +2189,8 @@ on_advanced_cancel_bt_clicked(GtkWidget *button _U_, gpointer data)
 
     /* retrieve toolbar info */
     toolbar_if_lb			= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_INTERFACE_KEY));
-    toolbar_channel_cm		= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
-    toolbar_wrong_crc_cm	= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
+    toolbar_channel_cb		= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_CHANNEL_KEY));
+    toolbar_wrong_crc_cb	= GTK_WIDGET(g_object_get_data(G_OBJECT(toolbar),AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
 
     /* Stop blinking ALL leds (go through the airpcap_if_list) */
     if (airpcap_if_selected != NULL)
@@ -2442,11 +2225,9 @@ display_airpcap_key_management_cb(GtkWidget *w _U_, gpointer data)
     GtkWidget *keys_fr;
     GtkWidget *keys_al;
     GtkWidget *keys_h_sub_box;
-    GtkWidget *enable_decryption_tb;
-    GtkWidget *enable_decryption_lb;
-    GtkWidget *enable_decryption_cb;
-    /*GList     *enable_decryption_cb_items = NULL;*/
-    GtkWidget *enable_decryption_en;
+    GtkWidget *decryption_mode_tb;
+    GtkWidget *decryption_mode_lb;
+    GtkWidget *decryption_mode_cb;
     GtkWidget *keys_v_sub_box;
     GtkWidget *keys_scrolled_w;
     GtkWidget *key_ls;
@@ -2529,38 +2310,32 @@ display_airpcap_key_management_cb(GtkWidget *w _U_, gpointer data)
     gtk_widget_show (keys_h_sub_box);
     gtk_container_add (GTK_CONTAINER (keys_al), keys_h_sub_box);
 
-    enable_decryption_tb = gtk_table_new (1, 2, FALSE);
-    gtk_widget_set_name (enable_decryption_tb, "enable_decryption_tb");
-    gtk_widget_show (enable_decryption_tb);
-    gtk_box_pack_start (GTK_BOX (keys_h_sub_box), enable_decryption_tb, FALSE,
+    decryption_mode_tb = gtk_table_new (1, 2, FALSE);
+    gtk_widget_set_name (decryption_mode_tb, "decryption_mode_tb");
+    gtk_widget_show (decryption_mode_tb);
+    gtk_box_pack_start (GTK_BOX (keys_h_sub_box), decryption_mode_tb, FALSE,
                         FALSE, 0);
-    gtk_table_set_col_spacings (GTK_TABLE (enable_decryption_tb), 6);
+    gtk_table_set_col_spacings (GTK_TABLE (decryption_mode_tb), 6);
 
-    enable_decryption_lb = gtk_label_new ("Select Decryption Mode");
-    gtk_widget_set_name (enable_decryption_lb, "enable_decryption_lb");
-    gtk_widget_show (enable_decryption_lb);
-    gtk_table_attach (GTK_TABLE (enable_decryption_tb), enable_decryption_lb, 1,
+    decryption_mode_lb = gtk_label_new ("Select Decryption Mode");
+    gtk_widget_set_name (decryption_mode_lb, "decryption_mode_lb");
+    gtk_widget_show (decryption_mode_lb);
+    gtk_table_attach (GTK_TABLE (decryption_mode_tb), decryption_mode_lb, 1,
                       2, 0, 1, (GtkAttachOptions) (GTK_FILL),
                       (GtkAttachOptions) (0), 0, 0);
-    gtk_misc_set_alignment (GTK_MISC (enable_decryption_lb), 0, 0.5);
+    gtk_misc_set_alignment (GTK_MISC (decryption_mode_lb), 0, 0.5);
 
-    enable_decryption_cb = gtk_combo_new ();
-    gtk_widget_set_name (enable_decryption_cb, "enable_decryption_cb");
-    gtk_widget_show (enable_decryption_cb);
-    gtk_table_attach (GTK_TABLE (enable_decryption_tb), enable_decryption_cb, 0,
+    decryption_mode_cb = gtk_combo_box_new_text();
+    update_decryption_mode_list(decryption_mode_cb);
+    gtk_widget_set_name (decryption_mode_cb, "decryption_mode_cb");
+    gtk_widget_show (decryption_mode_cb);
+    gtk_table_attach (GTK_TABLE (decryption_mode_tb), decryption_mode_cb, 0,
                       1, 0, 1, (GtkAttachOptions) (0), (GtkAttachOptions) (0),
                       0, 0);
-    gtk_widget_set_size_request (enable_decryption_cb, 83, -1);
-    update_decryption_mode_list(enable_decryption_cb);
-
-    enable_decryption_en = GTK_COMBO (enable_decryption_cb)->entry;
-    gtk_widget_set_name (enable_decryption_en, "enable_decryption_en");
-    gtk_widget_show (enable_decryption_en);
-    gtk_editable_set_editable (GTK_EDITABLE (enable_decryption_en), FALSE);
-    GTK_WIDGET_UNSET_FLAGS (enable_decryption_en, GTK_CAN_FOCUS);
+    gtk_widget_set_size_request (decryption_mode_cb, 83, -1);
 
     /* Set correct decryption mode!!!! */
-    update_decryption_mode_cm(enable_decryption_cb);
+    update_decryption_mode(decryption_mode_cb);
 
     keys_v_sub_box = gtk_hbox_new (FALSE, 0);
     gtk_widget_set_name (keys_v_sub_box, "keys_v_sub_box");
@@ -2712,7 +2487,7 @@ display_airpcap_key_management_cb(GtkWidget *w _U_, gpointer data)
     g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY,key_ls_selected_item);
 
     /* Store pointers to all widgets, for use by lookup_widget(). */
-    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_WEP_DECRYPTION_KEY, enable_decryption_en);
+    g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_DECRYPTION_MODE_KEY, decryption_mode_cb);
     g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_KEYLIST_KEY, key_ls);
     g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_OK_KEY, ok_bt);
     g_object_set_data (G_OBJECT(key_management_w), AIRPCAP_ADVANCED_CANCEL_KEY, cancel_bt);
@@ -2770,6 +2545,8 @@ on_key_management_ok_bt_clicked(GtkWidget *button, gpointer data)
 void
 on_key_management_cancel_bt_clicked(GtkWidget *button _U_, gpointer data)
 {
+    PAirpcapHandle ad = NULL;
+
     /* Retrieve object data */
     GtkWidget *key_management_w;
     GtkWidget *cancel_bt;
@@ -3075,7 +2852,7 @@ on_keep_bt_clicked (GtkWidget *button _U_, gpointer user_data)
 }
 
 void
-on_merge_bt_clicked (GtkWidget *button _U_, gpointer user_data)
+on_merge_bt_clicked (GtkWidget* button _U_, gpointer user_data)
 {
     GtkWidget *key_management_w;
     GtkWidget *keys_check_w;
@@ -3157,7 +2934,7 @@ on_merge_bt_clicked (GtkWidget *button _U_, gpointer user_data)
 
 
 void
-on_import_bt_clicked (GtkWidget *button _U_, gpointer user_data)
+on_import_bt_clicked (GtkWidget* button _U_, gpointer user_data)
 {
     GtkWidget *key_management_w;
     GtkWidget *keys_check_w;
@@ -3236,7 +3013,7 @@ on_import_bt_clicked (GtkWidget *button _U_, gpointer user_data)
 
 
 void
-on_ignore_bt_clicked (GtkWidget *button _U_, gpointer user_data)
+on_ignore_bt_clicked (GtkWidget* button _U_, gpointer user_data)
 {
     GtkWidget *key_management_w;
     GtkWidget *keys_check_w;
diff --git a/gtk/airpcap_dlg.h b/gtk/airpcap_dlg.h
index 0cc1de250a..36cd2b8ba9 100644
--- a/gtk/airpcap_dlg.h
+++ b/gtk/airpcap_dlg.h
@@ -142,13 +142,13 @@ on_reset_configuration_bt_clicked(GtkWidget *button, gpointer data _U_);
  * Turns the decryption on or off
  */
 void
-on_enable_decryption_en_changed(GtkWidget *w, gpointer data);
+on_decryption_mode_cb_changed(GtkWidget *w, gpointer data);
 
 /*
- * Will fill the given combo box with the current decryption mode string
+ * Selects the current decryption mode in the given combo box
  */
 void
-update_decryption_mode_cm(GtkWidget *w);
+update_decryption_mode(GtkWidget *w);
 
 /* 
  * Reset configuration
diff --git a/gtk/airpcap_gui_utils.c b/gtk/airpcap_gui_utils.c
index 033d47270e..471c6d716f 100644
--- a/gtk/airpcap_gui_utils.c
+++ b/gtk/airpcap_gui_utils.c
@@ -104,7 +104,7 @@ void
 airpcap_set_toolbar_start_capture(airpcap_if_info_t* if_info)
 {
     GtkWidget *airpcap_toolbar_label;
-    GtkWidget *airpcap_toolbar_channel;
+    GtkWidget *toolbar_channel_cb;
     GtkWidget *airpcap_toolbar_channel_lb;
     GtkWidget *airpcap_toolbar_channel_offset;
     GtkWidget *airpcap_toolbar_channel_offset_lb;
@@ -118,7 +118,7 @@ airpcap_set_toolbar_start_capture(airpcap_if_info_t* if_info)
     gchar *if_label_text;
 
     airpcap_toolbar_label    = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_INTERFACE_KEY);
-    airpcap_toolbar_channel  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY);
+    toolbar_channel_cb  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY);
     airpcap_toolbar_channel_lb  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY);
     airpcap_toolbar_channel_offset  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY);
     airpcap_toolbar_channel_offset_lb  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY);
@@ -134,7 +134,7 @@ airpcap_set_toolbar_start_capture(airpcap_if_info_t* if_info)
     {
 		gtk_widget_set_sensitive(airpcap_tb,TRUE);
 		gtk_widget_set_sensitive(airpcap_toolbar_label,TRUE);
-		gtk_widget_set_sensitive(airpcap_toolbar_channel,TRUE);
+		gtk_widget_set_sensitive(toolbar_channel_cb,TRUE);
 		gtk_widget_set_sensitive(airpcap_toolbar_channel_lb,TRUE);
 		gtk_widget_set_sensitive(airpcap_toolbar_channel_offset,TRUE);
 		gtk_widget_set_sensitive(airpcap_toolbar_channel_offset_lb,TRUE);
@@ -146,7 +146,7 @@ airpcap_set_toolbar_start_capture(airpcap_if_info_t* if_info)
 		gtk_widget_set_sensitive(airpcap_toolbar_decryption_lb,FALSE);
 		gtk_widget_set_sensitive(airpcap_toolbar_keys_button,FALSE);
 
-		/*decription check box*/
+		/*decryption check box*/
 		g_signal_handlers_block_by_func (airpcap_toolbar_decryption,airpcap_toolbar_encryption_cb, airpcap_tb);
 		if(if_info->DecryptionOn == AIRPCAP_DECRYPTION_ON)
 			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(airpcap_toolbar_decryption),TRUE);
@@ -164,22 +164,19 @@ airpcap_set_toolbar_start_capture(airpcap_if_info_t* if_info)
 			GList	  *channel_list = NULL;
 
 			for (; i<if_info->numSupportedChannels; i++){
-				channel_list = g_list_append(channel_list, ieee80211_mhz_to_str(if_info->pSupportedChannels[i].Frequency));
+				gtk_combo_box_append_text(GTK_COMBO_BOX(toolbar_channel_cb), ieee80211_mhz_to_str(if_info->pSupportedChannels[i].Frequency));
 			}
-			gtk_combo_set_popdown_strings( GTK_COMBO(airpcap_toolbar_channel), channel_list);
-			airpcap_free_channel_combo_list(channel_list);
 		}
 
-		airpcap_update_channel_offset_combo_entry(airpcap_toolbar_channel_offset, if_info->channelInfo.ExtChannel);
-		airpcap_update_channel_combo(GTK_WIDGET(airpcap_toolbar_channel),if_info);
-		airpcap_update_channel_offset_cb(if_info, if_info->channelInfo.Frequency, airpcap_toolbar_channel_offset);
+		airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cb),if_info);
+		airpcap_update_channel_offset_combo(if_info, if_info->channelInfo.Frequency, airpcap_toolbar_channel_offset);
 		change_airpcap_settings = TRUE;
     }
     else /* Current interface is NOT an AirPcap one... */
     {
 		gtk_widget_set_sensitive(airpcap_tb,FALSE);
 		gtk_widget_set_sensitive(airpcap_toolbar_label,FALSE);
-		gtk_widget_set_sensitive(airpcap_toolbar_channel,FALSE);
+		gtk_widget_set_sensitive(toolbar_channel_cb,FALSE);
 		gtk_widget_set_sensitive(airpcap_toolbar_channel_lb,FALSE);
 		gtk_widget_set_sensitive(airpcap_toolbar_channel_offset,FALSE);
 		gtk_widget_set_sensitive(airpcap_toolbar_channel_offset_lb,FALSE);
@@ -202,7 +199,7 @@ airpcap_set_toolbar_stop_capture(airpcap_if_info_t* if_info)
 {
     GtkWidget *airpcap_toolbar_crc_filter_combo;
     GtkWidget *airpcap_toolbar_label;
-    GtkWidget *airpcap_toolbar_channel;
+    GtkWidget *toolbar_channel_cb;
     GtkWidget *airpcap_toolbar_channel_lb;
     GtkWidget *airpcap_toolbar_channel_offset;
     GtkWidget *airpcap_toolbar_channel_offset_lb;
@@ -217,7 +214,7 @@ airpcap_set_toolbar_stop_capture(airpcap_if_info_t* if_info)
 
     airpcap_toolbar_crc_filter_combo = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_KEY);
     airpcap_toolbar_label    = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_INTERFACE_KEY);
-    airpcap_toolbar_channel  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY);
+    toolbar_channel_cb  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY);
     airpcap_toolbar_channel_lb  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY);
     airpcap_toolbar_channel_offset  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY);
     airpcap_toolbar_channel_offset_lb  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY);
@@ -233,7 +230,7 @@ airpcap_set_toolbar_stop_capture(airpcap_if_info_t* if_info)
     {
   		gtk_widget_set_sensitive(airpcap_tb,TRUE);
   		gtk_widget_set_sensitive(airpcap_toolbar_label,TRUE);
-  		gtk_widget_set_sensitive(airpcap_toolbar_channel,TRUE);
+  		gtk_widget_set_sensitive(toolbar_channel_cb,TRUE);
   		gtk_widget_set_sensitive(airpcap_toolbar_channel_lb,TRUE);
   		gtk_widget_set_sensitive(airpcap_toolbar_channel_offset,TRUE);
   		gtk_widget_set_sensitive(airpcap_toolbar_channel_offset_lb,TRUE);
@@ -244,7 +241,7 @@ airpcap_set_toolbar_stop_capture(airpcap_if_info_t* if_info)
   		gtk_widget_set_sensitive(airpcap_toolbar_decryption,TRUE);
   		gtk_widget_set_sensitive(airpcap_toolbar_decryption_lb,TRUE);
   		gtk_widget_set_sensitive(airpcap_toolbar_keys_button,TRUE);
-  		airpcap_validation_type_combo_set_by_type(GTK_WIDGET(airpcap_toolbar_crc_filter_combo),if_info->CrcValidationOn);
+  		airpcap_validation_type_combo_set_by_type(airpcap_toolbar_crc_filter_combo, if_info->CrcValidationOn);
 
   		/*decription check box*/
   		g_signal_handlers_block_by_func (airpcap_toolbar_decryption,airpcap_toolbar_encryption_cb, airpcap_tb);
@@ -264,22 +261,19 @@ airpcap_set_toolbar_stop_capture(airpcap_if_info_t* if_info)
   			GList	  *channel_list = NULL;
 
   			for (; i<if_info->numSupportedChannels; i++){
-  				channel_list = g_list_append(channel_list, ieee80211_mhz_to_str(if_info->pSupportedChannels[i].Frequency));
+  				gtk_combo_box_append_text(GTK_COMBO_BOX(toolbar_channel_cb), ieee80211_mhz_to_str(if_info->pSupportedChannels[i].Frequency));
   			}
-  			gtk_combo_set_popdown_strings( GTK_COMBO(airpcap_toolbar_channel), channel_list);
-  			airpcap_free_channel_combo_list(channel_list);
   		}
 
-  		airpcap_update_channel_combo(GTK_WIDGET(airpcap_toolbar_channel),if_info);
-  		airpcap_update_channel_offset_cb(if_info, if_info->channelInfo.Frequency, airpcap_toolbar_channel_offset);
-  		airpcap_update_channel_offset_combo_entry(airpcap_toolbar_channel_offset, if_info->channelInfo.ExtChannel);
+  		airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cb),if_info);
+  		airpcap_update_channel_offset_combo(if_info, if_info->channelInfo.Frequency, airpcap_toolbar_channel_offset);
   		change_airpcap_settings = TRUE;
   	}
     else
     {
   		gtk_widget_set_sensitive(airpcap_tb,TRUE);
   		gtk_widget_set_sensitive(airpcap_toolbar_label,FALSE);
-  		gtk_widget_set_sensitive(airpcap_toolbar_channel,FALSE);
+  		gtk_widget_set_sensitive(toolbar_channel_cb,FALSE);
   		gtk_widget_set_sensitive(airpcap_toolbar_channel_lb,FALSE);
   		gtk_widget_set_sensitive(airpcap_toolbar_channel_offset,FALSE);
   		gtk_widget_set_sensitive(airpcap_toolbar_channel_offset_lb,FALSE);
@@ -479,6 +473,26 @@ airpcap_get_validation_name(AirpcapValidationType vt)
 }
 
 /*
+ * Return an appropriate combo box entry number for the given an AirpcapValidationType,
+ * defaulting to 0
+ */
+gint
+airpcap_get_validation_combo_entry(AirpcapValidationType vt)
+{
+    switch (vt) {
+        case AIRPCAP_VT_ACCEPT_CORRECT_FRAMES:
+            return 1;
+            break;
+        case AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES:
+            return 2;
+            break;
+        default:
+            return 0;
+            break;
+    }
+}
+
+/*
  * Returns the AirpcapLinkType corresponding to the given string name.
  */
 AirpcapLinkType
@@ -545,38 +559,7 @@ airpcap_link_type_combo_get_type(GtkWidget* c)
 void
 airpcap_validation_type_combo_set_by_type(GtkWidget* c, AirpcapValidationType type)
 {
-    const gchar* s;
-
-    s = airpcap_get_validation_name(type);
-    gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(c)->entry),s);
-}
-
-/*
- * Retrieves the name in the validation combo entry.
- */
-AirpcapValidationType
-airpcap_validation_type_combo_get_type(GtkWidget* c)
-{
-    const gchar* s;
-
-    s = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(c)->entry));
-
-    return airpcap_get_validation_type(s);
-}
-
-/*
- * Retrieve the UINT corresponding to the given string (channel only, handle with care!)
- */
-ULONG
-airpcap_get_frequency_from_str(const gchar* s)
-{
-    ULONG ch_freq;
-
-    sscanf(s,"%ld",&ch_freq);
-
-    /* XXX - check for ch_num btween 1-14, and return -1 otherwise??? */
-
-    return ch_freq;
+    gtk_combo_box_set_active(GTK_COMBO_BOX(c), airpcap_get_validation_combo_entry(type));
 }
 
 /*
@@ -588,35 +571,21 @@ airpcap_get_channel_name(UINT n)
     return g_strdup_printf("%d",n);
 }
 
-/*
- * Free a channel combo list
- */
-static void
-free_channel_string(gpointer data, gpointer user_data _U_)
-{
-  g_free(data);
-}
-
-void
-airpcap_free_channel_combo_list(GList *channel_list)
-{
-  if (channel_list != NULL) {
-    g_list_foreach(channel_list, free_channel_string, NULL);
-    g_list_free(channel_list);
-  }
-}
 
 /*
- * Set the combo box entry string given an UINT channel number
+ * Set the combo box entry string given a channel frequency
  */
 void
-airpcap_channel_combo_set_by_number(GtkWidget* w,UINT chan_freq)
+airpcap_channel_combo_set_by_frequency(GtkWidget* cb, guint chan_freq)
 {
-	gchar *entry_text;
+    guint i;
 
-	entry_text = ieee80211_mhz_to_str(chan_freq);
-	gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),entry_text);
-	g_free(entry_text);
+    for (i = 0; i < airpcap_if_selected->numSupportedChannels; i++) {
+        if (airpcap_if_selected->pSupportedChannels[i].Frequency == chan_freq) {
+            gtk_combo_box_set_active(GTK_COMBO_BOX(cb), i);
+            break;
+        }
+    }
 }
 
 /*
@@ -642,51 +611,132 @@ airpcap_update_frequency_and_offset(airpcap_if_info_t* if_info)
 }
 
 /*
- * Update the channel offset of the given combobox
+ * Changed callback for the channel combobox
  */
 void
-airpcap_update_channel_offset_cb(airpcap_if_info_t* if_info, ULONG ch_freq, GtkWidget *channel_offset_cb)
+airpcap_channel_changed_cb(GtkWidget *channel_cb, gpointer channel_offset_cb)
 {
-	const gchar *current_offset;
-	gchar current_offset_copy[10];
-	gchar *new_offset_str;
-	ULONG chan_flags;
-
-  if (airpcap_if_is_any(if_info)){
-    gtk_widget_set_sensitive(GTK_WIDGET(channel_offset_cb),FALSE);
-    gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_offset_cb)->entry), "0");
-    return;
-  }
+    gint cur_chan_idx;
+
+    if (channel_cb && channel_offset_cb && change_airpcap_settings && airpcap_if_active) {
+        cur_chan_idx = gtk_combo_box_get_active(GTK_COMBO_BOX(channel_cb));
+        if (cur_chan_idx >= 0 && cur_chan_idx < (gint) airpcap_if_active->numSupportedChannels) {
+            airpcap_if_active->channelInfo.Frequency = airpcap_if_active->pSupportedChannels[cur_chan_idx].Frequency;
+            airpcap_update_channel_offset_combo(airpcap_if_active,
+                    airpcap_if_active->channelInfo.Frequency,
+                    GTK_WIDGET(channel_offset_cb));
+	}
+    }
+}
 
-	current_offset = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(channel_offset_cb)->entry));
-	g_strlcpy (current_offset_copy, current_offset, sizeof(current_offset_copy));
-	chan_flags = airpcap_load_channel_offset_cb(if_info, channel_offset_cb, ch_freq);
+static int
+airpcap_get_selected_channel_offset(GtkWidget *channel_offset_cb) {
+    int offset;
+    gchar *off_str;
+    int retval = 0;
+    
 
-	new_offset_str = current_offset_copy;
+    if (channel_offset_cb == NULL || !GTK_WIDGET_SENSITIVE(channel_offset_cb)) {
+        return 0;
+    }
+    
+    off_str = gtk_combo_box_get_active_text(GTK_COMBO_BOX(channel_offset_cb));
+    if (off_str && (g_ascii_strcasecmp("", off_str)))
+    {
+        if (airpcap_if_selected != NULL)
+        {
+            sscanf(off_str, "%d", &offset);
+            if (offset >= -1 && offset <= -1) {
+                retval = offset;
+            }
+        }
+    }
+    g_free(off_str);
+    return retval;
+}
 
-	/* If current_offset == -1 && new_offset cannot be -1 */
-	if (strcmp(current_offset_copy, "-1") == 0 && !(chan_flags & FLAG_CAN_BE_HIGH)){
-		if ((chan_flags & FLAG_CAN_BE_LOW)){
-			new_offset_str = "+1";
-		}else{
-			new_offset_str = "0";
-		}
-	}else if (strcmp(current_offset_copy, "+1") == 0 && !(chan_flags & FLAG_CAN_BE_LOW)){
-		if ((chan_flags & FLAG_CAN_BE_HIGH)){
-			new_offset_str = "-1";
-		}else{
-			new_offset_str = "0";
-		}
-	}
+/*
+ * Changed callback for the channel offset combobox
+ */
+void
+airpcap_channel_offset_changed_cb(GtkWidget *channel_offset_cb, gpointer data _U_)
+{
+    airpcap_if_selected->channelInfo.ExtChannel = airpcap_get_selected_channel_offset(channel_offset_cb);
+    airpcap_if_selected->saved = FALSE;
+}
+
+
+/*
+ * Update the channel offset of the given combobox according to the given frequency.
+ */
+void
+airpcap_update_channel_offset_combo(airpcap_if_info_t* if_info, ULONG chan_freq, GtkWidget *channel_offset_cb)
+{
+    gint current_offset;
+    gint new_offset;
+    guint i;
+    gint active_idx;
+    gint idx_count = -1;
+
+    if (!if_info || airpcap_if_is_any(if_info) || if_info->pSupportedChannels == NULL || if_info->numSupportedChannels < 1) {
+        gtk_widget_set_sensitive(GTK_WIDGET(channel_offset_cb),FALSE);
+        gtk_combo_box_set_active(GTK_COMBO_BOX(channel_offset_cb), -1);
+        return;
+    }
 
-  change_airpcap_settings = FALSE;
-  gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_offset_cb)->entry), new_offset_str);
-  change_airpcap_settings = TRUE;
+    new_offset = current_offset = airpcap_get_selected_channel_offset(channel_offset_cb);
+
+    /* Clear out the list */
+    while (gtk_tree_model_iter_n_children(gtk_combo_box_get_model(GTK_COMBO_BOX(channel_offset_cb)), NULL) > 0) {
+        gtk_combo_box_remove_text(GTK_COMBO_BOX(channel_offset_cb), 0);
+    }
+
+    for (i = 0; i < if_info->numSupportedChannels; i++) {
+        if (if_info->pSupportedChannels[i].Frequency == chan_freq) {
+
+            /* If we can't be low or high, nudge the offset to 0 */
+            if (current_offset == -1 && !(if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_LOW)) {
+                new_offset = 0;
+            } else if (current_offset == 1 && !(if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_HIGH)) {
+                new_offset = 0;
+            }
 
-  sscanf(new_offset_str,"%c",&(if_info->channelInfo.ExtChannel));
-  if (!airpcap_update_frequency_and_offset(if_info)){
-    simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Adapter failed to be set with the following settings: Frequency - %d   Extension Channel - %d", if_info->channelInfo.Frequency, if_info->channelInfo.ExtChannel);
-  }
+            if ((if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_LOW)) {
+                gtk_combo_box_append_text(GTK_COMBO_BOX(channel_offset_cb), "-1");
+                idx_count++;
+                if (new_offset == -1) {
+                    active_idx = idx_count;
+                }
+            }
+            gtk_combo_box_append_text(GTK_COMBO_BOX(channel_offset_cb), "0");
+            idx_count++;
+            if (new_offset == 0) {
+                active_idx = idx_count;
+            }
+            if ((if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_HIGH)){
+                gtk_combo_box_append_text(GTK_COMBO_BOX(channel_offset_cb), "+1");
+                idx_count++;
+                if (new_offset == 1) {
+                    active_idx = idx_count;
+                }
+            }
+            break;
+        }
+    }
+
+    gtk_combo_box_set_active(GTK_COMBO_BOX(channel_offset_cb), active_idx);
+
+
+    change_airpcap_settings = TRUE;
+
+    if_info->channelInfo.ExtChannel = new_offset;
+    if (!airpcap_update_frequency_and_offset(if_info)){
+        simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Adapter failed to be set with the following settings: Frequency - %ld   Extension Channel - %d", if_info->channelInfo.Frequency, if_info->channelInfo.ExtChannel);
+    }
+    
+    if (idx_count < 1) {
+        gtk_widget_set_sensitive(channel_offset_cb, FALSE);
+    }
 }
 
 /*
@@ -705,73 +755,33 @@ airpcap_if_is_any(airpcap_if_info_t* if_info)
  * Update channel combo box. If the airpcap interface is "Any", the combo box will be disabled.
  */
 void
-airpcap_update_channel_combo(GtkWidget* w, airpcap_if_info_t* if_info)
+airpcap_update_channel_combo(GtkWidget* channel_cb, airpcap_if_info_t* if_info)
 {
-    gchar* frequency_list;
-
-    if(airpcap_if_is_any(if_info))
+    if(!if_info || airpcap_if_is_any(if_info))
     {
-        frequency_list = airpcap_get_all_channels_list(if_info);
-        gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),frequency_list);
-        g_free(frequency_list);
+        gtk_combo_box_set_active(GTK_COMBO_BOX(channel_cb), -1);
         change_airpcap_settings = FALSE;
-        gtk_widget_set_sensitive(GTK_WIDGET(w),FALSE);
+        gtk_widget_set_sensitive(GTK_WIDGET(channel_cb),FALSE);
     }
     else
     {
-        airpcap_channel_combo_set_by_number(w,if_info->channelInfo.Frequency);
+        while (gtk_tree_model_iter_n_children(gtk_combo_box_get_model(GTK_COMBO_BOX(channel_cb)), NULL) > 0) {
+            gtk_combo_box_remove_text(GTK_COMBO_BOX(channel_cb), 0);
+        }
+        
+        if (if_info != NULL && if_info->pSupportedChannels != NULL && if_info->numSupportedChannels > 0){
+            guint i;
+            for (i = 0; i<(if_info->numSupportedChannels); i++){
+                gtk_combo_box_append_text(GTK_COMBO_BOX(channel_cb), ieee80211_mhz_to_str(airpcap_if_selected->pSupportedChannels[i].Frequency));
+            }
+        }    
+
+        airpcap_channel_combo_set_by_frequency(channel_cb, if_info->channelInfo.Frequency);
         change_airpcap_settings = TRUE;
-        gtk_widget_set_sensitive(GTK_WIDGET(w),TRUE);
+        gtk_widget_set_sensitive(GTK_WIDGET(channel_cb), TRUE);
     }
 }
 
-/*
- * Update channel offset combo box to 'offset'.
- */
-void
-airpcap_update_channel_offset_combo_entry(GtkWidget* w, gchar extChannel)
-{
-    gchar channel_offset_value[3];
-
-    if (extChannel > 0){
-        g_snprintf(channel_offset_value, sizeof(channel_offset_value), "+%d", extChannel);
-    }else{
-        g_snprintf(channel_offset_value, sizeof(channel_offset_value), "%d", extChannel);
-    }
-
-    gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry), channel_offset_value);
-}
-
-/*
- * Update channel offset combo box given the selected frequency. Return the flags from the given frequency.
- */
-ULONG
-airpcap_load_channel_offset_cb(airpcap_if_info_t* if_info, GtkWidget* channel_offset_cb, ULONG chan_freq)
-{
-    GList *channel_offset_list = NULL;
-
-    if (if_info != NULL && if_info->pSupportedChannels != NULL && if_info->numSupportedChannels > 0){
-        guint i = 0;
-
-        for (; i<if_info->numSupportedChannels; i++){
-            if (if_info->pSupportedChannels[i].Frequency == chan_freq){
-                if ((if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_HIGH)){
-                    channel_offset_list = g_list_append(channel_offset_list, "-1");
-                }
-                channel_offset_list = g_list_append(channel_offset_list, "0");
-                if ((if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_LOW)){
-                    channel_offset_list = g_list_append(channel_offset_list, "+1");
-                }
-                gtk_combo_set_popdown_strings( GTK_COMBO(channel_offset_cb), channel_offset_list) ;
-                gtk_widget_set_sensitive(channel_offset_cb, g_list_length(channel_offset_list) > 1);
-                g_list_free(channel_offset_list);
-                return if_info->pSupportedChannels[i].Flags;
-            }
-        }
-    }
-
-    return 0;
-}
 
 /*
  * Takes the keys from the GtkList widget, and add them to the interface list
@@ -1205,7 +1215,7 @@ airpcap_enable_toolbar_widgets(GtkWidget* w, gboolean en)
 {
     GtkWidget	*toolbar_tb,
 		*if_description_lb,
-		*channel_cb,
+		*toolbar_channel_cb,
 		*channel_lb,
 		*channel_offset_cb,
     *channel_offset_lb,
@@ -1220,7 +1230,7 @@ airpcap_enable_toolbar_widgets(GtkWidget* w, gboolean en)
 
     if_description_lb	= g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_INTERFACE_KEY);
     channel_lb			= g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY);
-    channel_cb			= g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY);
+    toolbar_channel_cb			= g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY);
     channel_offset_cb	= g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY);
     channel_offset_lb	= g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY);
     fcs_lb				= g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY);
@@ -1230,7 +1240,7 @@ airpcap_enable_toolbar_widgets(GtkWidget* w, gboolean en)
 
     if(if_description_lb != NULL)	gtk_widget_set_sensitive(if_description_lb,en);
     if(channel_lb != NULL)			gtk_widget_set_sensitive(channel_lb,en);
-    if(channel_cb != NULL)			gtk_widget_set_sensitive(channel_cb,en);
+    if(toolbar_channel_cb != NULL)		gtk_widget_set_sensitive(toolbar_channel_cb,en);
     if(channel_offset_cb != NULL)	gtk_widget_set_sensitive(channel_offset_cb,en);
     if(channel_offset_lb != NULL)	gtk_widget_set_sensitive(channel_offset_lb,en);
     if(fcs_lb != NULL)				gtk_widget_set_sensitive(fcs_lb,en);
@@ -1249,7 +1259,7 @@ airpcap_set_toolbar_no_if(GtkWidget* w)
 {
     GtkWidget	*toolbar_tb,
 		*if_description_lb,
-		*channel_cb,
+		*toolbar_channel_cb,
 		*channel_lb,
     *channel_offset_cb,
 		*channel_offset_lb,
@@ -1264,7 +1274,7 @@ airpcap_set_toolbar_no_if(GtkWidget* w)
 
     if_description_lb	    = g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_INTERFACE_KEY);
     channel_lb			      = g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY);
-    channel_cb			      = g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY);
+    toolbar_channel_cb			      = g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY);
     channel_offset_lb			= g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY);
     channel_offset_cb			= g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY);
     fcs_lb				        = g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY);
@@ -1272,7 +1282,7 @@ airpcap_set_toolbar_no_if(GtkWidget* w)
     advanced_bt			      = g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_ADVANCED_KEY);
 
     if(fcs_cb != NULL)				gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(fcs_cb)->entry),"");
-    if(channel_cb != NULL)			gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_cb)->entry),"");
+    if(toolbar_channel_cb != NULL)		gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(toolbar_channel_cb)->entry),"");
     if(channel_offset_cb != NULL)			gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_offset_cb)->entry),"");
     if(if_description_lb != NULL)	gtk_label_set_text(GTK_LABEL(if_description_lb),"Current Wireless Interface: None");
 
diff --git a/gtk/airpcap_gui_utils.h b/gtk/airpcap_gui_utils.h
index a158a513ed..d929b569ea 100644
--- a/gtk/airpcap_gui_utils.h
+++ b/gtk/airpcap_gui_utils.h
@@ -35,8 +35,12 @@
 
 #define AIRPCAP_LINK_TYPE_NAME_802_11_ONLY			"802.11 Only"
 #define AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO	"802.11 + Radio"
-#define AIRPCAP_LINK_TYPE_NAME_UNKNOWN				"Unknown"
 #define AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_PPI		"802.11 + PPI"
+#define AIRPCAP_LINK_TYPE_NAME_UNKNOWN				"Unknown"
+
+#define AIRPCAP_LINK_TYPE_NUM_802_11_ONLY			0
+#define AIRPCAP_LINK_TYPE_NUM_802_11_PLUS_RADIO	1
+#define AIRPCAP_LINK_TYPE_NUM_802_11_PLUS_PPI		2
 
 #define AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK "Wireshark"
 #define AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP   "Driver"
@@ -49,12 +53,12 @@
 extern gboolean change_airpcap_settings;
 
 /*
- * This structure is used because we need to store infos about the currently selected 
- * row in the key list. 
+ * This structure is used because we need to store infos about the currently selected
+ * row in the key list.
  */
 typedef struct{
-gint row;
-gint column;
+    gint row;
+    gint column;
 }airpcap_key_ls_selected_info_t;
 
 /* XXX Not used anywhere -> Delete??? */
@@ -118,6 +122,12 @@ gchar*
 airpcap_get_validation_name(AirpcapValidationType vt);
 
 /*
+ * Return an appropriate combo box entry number for the given an AirpcapValidationType.
+ */
+gint
+airpcap_get_validation_combo_entry(AirpcapValidationType vt);
+
+/*
  * Returns the AirpcapLinkType corresponding to the given string name.
  */
 AirpcapLinkType
@@ -148,22 +158,11 @@ void
 airpcap_validation_type_combo_set_by_type(GtkWidget* c,AirpcapValidationType type);
 
 /*
- * Retrieves the name in the validation combo entry.
- */
-AirpcapValidationType
-airpcap_validation_type_combo_get_type(GtkWidget* c);
-
-/*
  * Update channel offset combo box to 'offset'.
  */
 void
-airpcap_update_channel_offset_combo_entry(GtkWidget* w, gchar extChannel);
+airpcap_update_channel_offset_combo(airpcap_if_info_t* if_info, ULONG ch_freq, GtkWidget *channel_offset_cb);
 
-/*
- * Returns the string corresponding to the given UINT (1-14, for channel only)
- */
-ULONG
-airpcap_get_frequency_from_str(const gchar* s);
 
 /*
  * Retrieve the UINT corresponding to the given string (channel only, handle with care!)
@@ -175,13 +174,28 @@ airpcap_get_channel_name(UINT n);
  * Set the combo box entry string given an UINT channel number
  */
 void
-airpcap_channel_combo_set_by_number(GtkWidget* w,UINT channel);
+airpcap_channel_combo_set_by_frequency(GtkWidget* w,UINT channel);
 
-/*
- * Free a channel combo list
+/** Respond to the user changing the channel combo box.
+ * Update the active interface channel and update the offset
+ * combo box.
+ * Requires AirPcap globals.
+ *
+ * @param channel_cb The channel GtkComboBox
+ * @param channel_offset_cb The channel offset GtkComboBox
  */
 void
-airpcap_free_channel_combo_list(GList *channel_list);
+airpcap_channel_changed_cb(GtkWidget *channel_cb, gpointer channel_offset_cb);
+
+/** Respond to the user changing the channel offset combo box.
+ * Update the active interface channel offset.
+ * Requires AirPcap globals.
+ *
+ * @param channel_offset_cb The channel offset GtkComboBox
+ * @param data Unused
+ */
+void
+airpcap_channel_offset_changed_cb(GtkWidget *channel_offset_cb, gpointer data);
 
 /*
  * Returns '1' if this is the "Any" adapter, '0' otherwise
@@ -198,14 +212,14 @@ airpcap_update_frequency_and_offset(airpcap_if_info_t* if_info);
 /*
  * Takes the keys from the GtkList widget, and add them to the interface list
  */
-void 
+void
 airpcap_add_keys_from_list(GtkWidget *w, airpcap_if_info_t *if_info);
 
 /*
  * Update channel combo box. If the airpcap interface is "Any", the combo box will be disabled.
  */
 void
-airpcap_update_channel_combo(GtkWidget* w, airpcap_if_info_t* if_info);
+airpcap_update_channel_combo(GtkWidget* channel_cb, airpcap_if_info_t* if_info);
 
 /*
  * Update the channel offset of the given combobox
@@ -214,12 +228,6 @@ void
 airpcap_update_channel_offset_cb(airpcap_if_info_t* if_info, ULONG ch_freq, GtkWidget *channel_offset_cb);
 
 /*
- * Update channel offset combo box given the selected frequency. Return the flags from the given frequency.
- */
-ULONG
-airpcap_load_channel_offset_cb(airpcap_if_info_t* if_info, GtkWidget* channel_offset_cb, ULONG chan_freq);
-
-/*
  * This function will take the current keys (widget list), specified for the
  * current adapter, and save them as default for ALL the others.
  */
@@ -228,7 +236,7 @@ airpcap_read_and_save_decryption_keys_from_clist(GtkWidget* key_ls, airpcap_if_i
 
 /*
  * This function will load from the preferences file ALL the
- * keys (WEP, WPA and WPA_BIN) and will set them as default for 
+ * keys (WEP, WPA and WPA_BIN) and will set them as default for
  * each adapter. To do this, it will save the keys in the registry...
  */
 void
@@ -236,14 +244,14 @@ airpcap_load_decryption_keys(GList* if_list);
 
 /*
  * This function will load from the preferences file ALL the
- * keys (WEP, WPA and WPA_BIN) and will set them as default for 
+ * keys (WEP, WPA and WPA_BIN) and will set them as default for
  * each adapter. To do this, it will save the keys in the registry...
  */
 gboolean
 airpcap_check_decryption_keys(GList* if_list);
 
 /*
- * This function will set the gibven GList of decryption_key_t structures 
+ * This function will set the gibven GList of decryption_key_t structures
  * as the defoult for both Wireshark and the AirPcap adapters...
  */
 void
@@ -251,7 +259,7 @@ airpcap_save_decryption_keys(GList* key_list, GList* adapters_list);
 
 /*
  * This function is used to enable/disable the toolbar widgets
- * depending on the type of interface selected... 
+ * depending on the type of interface selected...
  */
 void
 airpcap_enable_toolbar_widgets(GtkWidget* w, gboolean en);
diff --git a/gtk/capture_dlg.c b/gtk/capture_dlg.c
index f725fc71d6..31673e0119 100644
--- a/gtk/capture_dlg.c
+++ b/gtk/capture_dlg.c
@@ -1466,7 +1466,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
                 *help_bt;
 #ifdef HAVE_AIRPCAP
   GtkWidget     *advanced_bt;
-  GtkWidget     *decryption_cm;
+  GtkWidget     *decryption_cb;
 #endif
 #ifdef HAVE_PCAP_REMOTE
   GtkWidget     *iftype_cb;
@@ -1555,8 +1555,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   /* load the airpcap interfaces */
   airpcap_if_list = get_airpcap_interface_list(&err, &err_str);
 
-  decryption_cm = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY);
-  update_decryption_mode_list(decryption_cm);
+  decryption_cb = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY);
+  update_decryption_mode_list(decryption_cb);
 
   if (airpcap_if_list == NULL && err == CANT_GET_AIRPCAP_INTERFACE_LIST) {
     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
diff --git a/gtk/capture_if_dlg.c b/gtk/capture_if_dlg.c
index 9d1877f152..47c75539d3 100644
--- a/gtk/capture_if_dlg.c
+++ b/gtk/capture_if_dlg.c
@@ -446,7 +446,7 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_)
 				*icon;
 
 #ifdef HAVE_AIRPCAP
-  GtkWidget		*decryption_cm;
+  GtkWidget		*decryption_cb;
 #endif
 
   GtkWidget     *if_tb;
@@ -500,8 +500,8 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_)
   if (airpcap_if_list == NULL)
     airpcap_if_active = airpcap_if_selected = NULL;
 
-  decryption_cm = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY);
-  update_decryption_mode_list(decryption_cm);
+  decryption_cb = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY);
+  update_decryption_mode_list(decryption_cb);
 
   if (airpcap_if_list == NULL && err == CANT_GET_AIRPCAP_INTERFACE_LIST) {
 #if 0
diff --git a/gtk/keys.h b/gtk/keys.h
index 5bed93d697..09205a5592 100644
--- a/gtk/keys.h
+++ b/gtk/keys.h
@@ -86,7 +86,7 @@
 #define AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY	"airpcap_advanced_edit_key_ssid_key"
 #define AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY	"airpcap_advanced_edit_key_key_label_key"
 #define AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY	"airpcap_advanced_edit_key_ssid_label_key"
-#define AIRPCAP_ADVANCED_WEP_DECRYPTION_KEY	"airpcap_advanced_wep_decryption_key"
+#define AIRPCAP_ADVANCED_DECRYPTION_MODE_KEY	"airpcap_advanced_decryption_mode_key"
 #define AIRPCAP_ADVANCED_WPA_DECRYPTION_KEY	"airpcap_advanced_wpa_decryption_key"
 #define AIRPCAP_ADVANCED_NOTEBOOK_KEY		"airpcap_advanced_notebook_key"
 #define AIRPCAP_ADVANCED_CANCEL_KEY	        "airpcap_advanced_cancel_key"
diff --git a/gtk/main_airpcap_toolbar.c b/gtk/main_airpcap_toolbar.c
index e38510e0dd..0c8ba89f4d 100644
--- a/gtk/main_airpcap_toolbar.c
+++ b/gtk/main_airpcap_toolbar.c
@@ -58,76 +58,30 @@ gboolean block_toolbar_signals = FALSE;
 static GtkWidget *driver_warning_dialog;
 
 
-
-/*
- * Changed callback for the channel combobox
- */
-static void
-airpcap_toolbar_channel_changed_cb(GtkWidget *w, gpointer data)
-{
-  const gchar *s;
-  ULONG ch_freq;
-
-  if ((data != NULL) && (w != NULL) && change_airpcap_settings) {
-	s = gtk_entry_get_text(GTK_ENTRY(w));
-    if ((g_ascii_strcasecmp("",s))) {
-      ch_freq = airpcap_get_frequency_from_str(s);
-      if (airpcap_if_active != NULL) {
-		airpcap_if_active->channelInfo.Frequency = ch_freq;
-		airpcap_update_channel_offset_cb(airpcap_if_active, ch_freq, GTK_WIDGET(data));
-      }
-    }
-  }
-}
-
-/*
- * Changed callback for the channel offset combobox
- */
-static void
-on_channel_offset_cb_changed(GtkWidget *w, gpointer data _U_)
-{
-    const gchar *s;
-    int offset;
-
-    if (w == NULL) {
-        return;
-    }
-
-    if (change_airpcap_settings)
-    {
-        s = gtk_entry_get_text(GTK_ENTRY(w));
-        if ((g_ascii_strcasecmp("",s)))
-        {
-            if (airpcap_if_active != NULL)
-            {
-                sscanf(s,"%d",&offset);
-                airpcap_if_active->channelInfo.ExtChannel = offset;
-                airpcap_update_frequency_and_offset(airpcap_if_active);
-            }
-        }
-    }
-}
-
 /*
  * Callback for the wrong crc combo
  */
 static void
-airpcap_toolbar_wrong_crc_combo_cb(GtkWidget *entry, gpointer user_data _U_)
+airpcap_toolbar_fcs_filter_combo_cb(GtkWidget *fcs_filter_cb, gpointer user_data _U_)
 {
-  gchar ebuf[AIRPCAP_ERRBUF_SIZE];
-  PAirpcapHandle ad;
-
-  if( !block_toolbar_signals && (airpcap_if_active != NULL)) {
-    ad = airpcap_if_open(airpcap_if_active->name, ebuf);
-
-    if (ad) {
-      airpcap_if_active->CrcValidationOn = airpcap_get_validation_type(gtk_entry_get_text(GTK_ENTRY(entry)));
-      airpcap_if_set_fcs_validation(ad,airpcap_if_active->CrcValidationOn);
-      /* Save configuration */
-      airpcap_if_store_cur_config_as_adapter_default(ad);
-      airpcap_if_close(ad);
+    PAirpcapHandle ad;
+    gchar ebuf[AIRPCAP_ERRBUF_SIZE];
+    gchar *fcs_filter_str;
+
+    if (fcs_filter_cb != NULL && !block_toolbar_signals && (airpcap_if_active != NULL)) {
+        fcs_filter_str = gtk_combo_box_get_active_text(GTK_COMBO_BOX(fcs_filter_cb));
+        ad = airpcap_if_open(airpcap_if_active->name, ebuf);
+
+        if (fcs_filter_str && (g_ascii_strcasecmp("", fcs_filter_str)) && ad) {
+            airpcap_if_selected->CrcValidationOn = airpcap_get_validation_type(fcs_filter_str);
+            airpcap_if_selected->saved = FALSE;
+	    airpcap_if_set_fcs_validation(ad,airpcap_if_active->CrcValidationOn);
+	    /* Save configuration */
+	    airpcap_if_store_cur_config_as_adapter_default(ad);
+	    airpcap_if_close(ad);
+        }
+        g_free(fcs_filter_str);
     }
-  }
 }
 
 void
@@ -231,21 +185,19 @@ GtkWidget *airpcap_toolbar_new()
     GtkWidget     *key_management_bt = NULL,
     		  *advanced_bt = NULL,
     		  *channel_lb = NULL,
-    		  *channel_cm = NULL,
+    		  *channel_cb = NULL,
     		  *channel_offset_lb = NULL,
     		  *channel_offset_cb = NULL,
-    		  *wrong_crc_lb = NULL,
-    		  *wrong_crc_cm = NULL;
+    		  *fcs_filter_lb = NULL,
+    		  *fcs_filter_cb = NULL;
     GtkWidget     *airpcap_tb;
 
-    GtkWidget     *enable_decryption_lb;
-    GtkWidget     *enable_decryption_cb;
-    GtkWidget     *enable_decryption_en;
+    GtkWidget     *decryption_mode_lb;
+    GtkWidget     *decryption_mode_cb;
 
-    GList	  *channel_list = NULL;
     GList	  *linktype_list = NULL;
     GtkTooltips	  *airpcap_tooltips;
-    gchar         *chan_str;
+    gint	   cur_chan_idx = -1;
 
     /* airpcap toolbar */
     airpcap_tooltips = gtk_tooltips_new();
@@ -280,35 +232,20 @@ GtkWidget *airpcap_toolbar_new()
     gtk_widget_set_size_request(channel_lb, 85, 28);
 
     /* Create the channel combo box */
-    channel_cm = gtk_combo_new();
-    gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(channel_cm)->entry),FALSE);
-    g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY,channel_cm);
-
-    if (airpcap_if_active != NULL && airpcap_if_active->pSupportedChannels != NULL && airpcap_if_active->numSupportedChannels > 0){
-        guint i = 0;
-        for (; i<airpcap_if_active->numSupportedChannels; i++){
-            channel_list = g_list_append(channel_list, ieee80211_mhz_to_str(airpcap_if_active->pSupportedChannels[i].Frequency));
-        }
-        gtk_combo_set_popdown_strings( GTK_COMBO(channel_cm), channel_list);
-        airpcap_free_channel_combo_list(channel_list);
-    }
+    channel_cb = gtk_combo_box_new_text();
+    g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY,channel_cb);
 
-    gtk_tooltips_set_tip(airpcap_tooltips, GTK_WIDGET(GTK_COMBO(channel_cm)->entry),
+    /* Select the current channel */
+    airpcap_update_channel_combo(GTK_WIDGET(channel_cb), airpcap_if_selected);
+
+    gtk_tooltips_set_tip(airpcap_tooltips, GTK_WIDGET(channel_cb),
 		"Change the 802.11 RF channel", NULL);
 
-    gtk_widget_set_size_request(channel_cm, 120, 28);
+    gtk_widget_set_size_request(channel_cb, 120, 28);
 
-    if(airpcap_if_active != NULL) {
-        chan_str = ieee80211_mhz_to_str(airpcap_if_active->channelInfo.Frequency);
-        gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_cm)->entry), chan_str);
-        g_free(chan_str);
-    }
-    else {
-        gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_cm)->entry),"");
-    }
-    gtk_widget_show(channel_cm);
+    gtk_widget_show(channel_cb);
 
-    gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), channel_cm,
+    gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), channel_cb,
                               "802.11 Channel", "Private");
 
     /* gtk_toolbar_append_space(GTK_TOOLBAR(airpcap_tb)); */
@@ -323,15 +260,13 @@ GtkWidget *airpcap_toolbar_new()
     gtk_widget_set_size_request(channel_offset_lb, 80, 28);
 
     /* Start: Channel offset combo box */
-    channel_offset_cb = gtk_combo_new();
-    gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(channel_offset_cb)->entry),FALSE);
+    channel_offset_cb = gtk_combo_box_new_text();
     g_object_set_data(G_OBJECT(airpcap_tb), AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY, channel_offset_cb);
 
     if(airpcap_if_active != NULL){
-		airpcap_update_channel_offset_cb(airpcap_if_active, airpcap_if_active->channelInfo.Frequency, channel_offset_cb);
-		airpcap_update_channel_offset_combo_entry(channel_offset_cb, airpcap_if_active->channelInfo.ExtChannel);
+        airpcap_update_channel_offset_combo(airpcap_if_active, airpcap_if_active->channelInfo.Frequency, channel_offset_cb);
     } else {
-        gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_offset_cb)->entry),"");
+        gtk_combo_box_set_active(GTK_COMBO_BOX(channel_offset_cb), -1);
     }
 
     gtk_tooltips_set_tip(airpcap_tooltips, GTK_WIDGET(GTK_COMBO(channel_offset_cb)->entry),
@@ -347,74 +282,66 @@ GtkWidget *airpcap_toolbar_new()
     gtk_toolbar_append_space(GTK_TOOLBAR(airpcap_tb));
 
     /* callback for channel combo box */
-    g_signal_connect(GTK_COMBO(channel_cm)->entry,"changed", G_CALLBACK(airpcap_toolbar_channel_changed_cb), channel_offset_cb);
+    g_signal_connect(channel_cb,"changed", G_CALLBACK(airpcap_channel_changed_cb), channel_offset_cb);
     /* callback for channel offset combo box */
-    g_signal_connect(GTK_COMBO(channel_offset_cb)->entry,"changed", G_CALLBACK(on_channel_offset_cb_changed), NULL);
+    g_signal_connect(GTK_COMBO(channel_offset_cb)->entry,"changed", G_CALLBACK(airpcap_channel_offset_changed_cb), NULL);
     /* End: Channel offset combo box */
 
     /* Wrong CRC Label */
-    wrong_crc_lb = gtk_label_new(" FCS Filter: ");
-    g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY,wrong_crc_lb);
-    gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), wrong_crc_lb,
+    fcs_filter_lb = gtk_label_new(" FCS Filter: ");
+    g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY,fcs_filter_lb);
+    gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), fcs_filter_lb,
                               "", "Private");
-    gtk_widget_show(wrong_crc_lb);
+    gtk_widget_show(fcs_filter_lb);
 
-    /* Wrong CRC combo */
-    wrong_crc_cm = gtk_combo_new();
-    gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(wrong_crc_cm)->entry),FALSE);
-    g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_KEY,wrong_crc_cm);
-    gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), wrong_crc_cm,
+    /* FCS filter combo */
+    fcs_filter_cb = gtk_combo_box_new_text();
+    g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_KEY,fcs_filter_cb);
+    gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), fcs_filter_cb,
                               "", "Private");
 
-    gtk_widget_set_size_request(wrong_crc_cm, 100, -1);
+    gtk_widget_set_size_request(fcs_filter_cb, 100, -1);
 
-    linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_ALL);
-    linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRECT);
-    linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT);
+    gtk_combo_box_append_text(GTK_COMBO_BOX(fcs_filter_cb), airpcap_get_validation_name(AIRPCAP_VT_ACCEPT_EVERYTHING));
+    gtk_combo_box_append_text(GTK_COMBO_BOX(fcs_filter_cb), airpcap_get_validation_name(AIRPCAP_VT_ACCEPT_CORRECT_FRAMES));
+    gtk_combo_box_append_text(GTK_COMBO_BOX(fcs_filter_cb), airpcap_get_validation_name(AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES));
+    gtk_combo_box_set_active(GTK_COMBO_BOX(fcs_filter_cb), 0);
 
-    gtk_combo_set_popdown_strings( GTK_COMBO(wrong_crc_cm), linktype_list) ;
-    g_list_free(linktype_list);
-    gtk_tooltips_set_tip(airpcap_tooltips, GTK_WIDGET(GTK_COMBO(wrong_crc_cm)->entry),
+    gtk_tooltips_set_tip(airpcap_tooltips, GTK_WIDGET(fcs_filter_cb),
 	"Select the 802.11 FCS filter that the wireless adapter will apply.",
         NULL);
 
-    if(airpcap_if_active != NULL)
-        gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_cm)->entry), airpcap_get_validation_name(airpcap_if_active->CrcValidationOn));
-    else
-        gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_cm)->entry),"");
+    if (airpcap_if_selected != NULL)
+    {
+        airpcap_validation_type_combo_set_by_type(fcs_filter_cb, airpcap_if_selected->CrcValidationOn);
+    }
 
-    g_signal_connect(GTK_COMBO(wrong_crc_cm)->entry,"changed",G_CALLBACK(airpcap_toolbar_wrong_crc_combo_cb),airpcap_tb);
-    gtk_widget_show(wrong_crc_cm);
+    g_signal_connect (fcs_filter_cb, "changed", G_CALLBACK(airpcap_toolbar_fcs_filter_combo_cb), NULL);
+    gtk_widget_show(fcs_filter_cb);
 
     gtk_toolbar_append_space(GTK_TOOLBAR(airpcap_tb));
 
     /* Decryption mode combo box */
-    enable_decryption_lb = gtk_label_new ("Decryption Mode: ");
-    g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY,enable_decryption_lb);
-    gtk_widget_set_name (enable_decryption_lb, "enable_decryption_lb");
-    gtk_widget_show (enable_decryption_lb);
-    gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), enable_decryption_lb,
+    decryption_mode_lb = gtk_label_new ("Decryption Mode: ");
+    g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY,decryption_mode_lb);
+    gtk_widget_set_name (decryption_mode_lb, "decryption_mode_lb");
+    gtk_widget_show (decryption_mode_lb);
+    gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), decryption_mode_lb,
         NULL, "Private");
 
-    enable_decryption_cb = gtk_combo_new ();
-    gtk_widget_set_name (enable_decryption_cb, "enable_decryption_cb");
-    gtk_widget_show (enable_decryption_cb);
-    gtk_widget_set_size_request(enable_decryption_cb, 83, -1);
-    update_decryption_mode_list(enable_decryption_cb);
-
-    enable_decryption_en = GTK_COMBO (enable_decryption_cb)->entry;
-    gtk_widget_set_name (enable_decryption_en, "enable_decryption_en");
-    gtk_widget_show (enable_decryption_en);
-    gtk_editable_set_editable (GTK_EDITABLE (enable_decryption_en), FALSE);
-    GTK_WIDGET_UNSET_FLAGS (enable_decryption_en, GTK_CAN_FOCUS);
+    decryption_mode_cb = gtk_combo_box_new_text();
+    gtk_widget_set_name (decryption_mode_cb, "decryption_mode_cb");
+    gtk_widget_show (decryption_mode_cb);
+    gtk_widget_set_size_request(decryption_mode_cb, 83, -1);
+    update_decryption_mode_list(decryption_mode_cb);
 
-    gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), enable_decryption_cb,
+    gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), decryption_mode_cb,
         "Choose a Decryption Mode", "Private");
 
     /* Set current decryption mode!!!! */
-    update_decryption_mode_cm(enable_decryption_cb);
-    g_signal_connect(enable_decryption_en, "changed", G_CALLBACK(on_enable_decryption_en_changed), airpcap_tb);
-    g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY,enable_decryption_cb);
+    update_decryption_mode(decryption_mode_cb);
+    g_signal_connect(decryption_mode_cb, "changed", G_CALLBACK(on_decryption_mode_cb_changed), airpcap_tb);
+    g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY,decryption_mode_cb);
 
     gtk_toolbar_append_space(GTK_TOOLBAR(airpcap_tb));