Start getting rid of the uses of compat_macro.h's macros.

svn path=/trunk/; revision=24860

10 files changed, 507 insertions, 507 deletions

diff --git a/gtk/about_dlg.c b/gtk/about_dlg.c
index 87d30c20e6..dca1701a1d 100644
--- a/gtk/about_dlg.c
+++ b/gtk/about_dlg.c
@@ -86,7 +86,7 @@ splash_update_label(GtkWidget *win, const char *message)
 
     if (win == NULL) return;
 
-    main_lb = OBJECT_GET_DATA(win, "splash_label");
+    main_lb = g_object_get_data(G_OBJECT(win), "splash_label");
     gtk_label_set_text(GTK_LABEL(main_lb), message);
 
     /* Process all pending GUI events before continuing, so that
@@ -121,23 +121,23 @@ splash_new(const char *message)
 
     main_lb = gtk_label_new(message);
     gtk_container_add(GTK_CONTAINER(main_vb), main_lb);
-    OBJECT_SET_DATA(win, "splash_label", main_lb);
+    g_object_set_data(G_OBJECT(win), "splash_label", main_lb);
 
     main_lb = gtk_label_new("");
     gtk_container_add(GTK_CONTAINER(main_vb), main_lb);
-    OBJECT_SET_DATA(win, "protocol_label", main_lb);
+    g_object_set_data(G_OBJECT(win), "protocol_label", main_lb);
 
     percentage_hb = gtk_hbox_new(FALSE, 1);
     gtk_box_pack_start(GTK_BOX(main_vb), percentage_hb, TRUE, TRUE, 3);
 
     prog_bar = gtk_progress_bar_new();
     gtk_box_pack_start(GTK_BOX(percentage_hb), prog_bar, TRUE, TRUE, 3);
-    OBJECT_SET_DATA(win, "progress_bar", prog_bar);
+    g_object_set_data(G_OBJECT(win), "progress_bar", prog_bar);
 
     percentage_lb = gtk_label_new("  0%");
     gtk_misc_set_alignment(GTK_MISC(percentage_lb), 0.0, 0.0);
     gtk_box_pack_start(GTK_BOX(percentage_hb), percentage_lb, FALSE, TRUE, 3);
-    OBJECT_SET_DATA(win, "percentage_label", percentage_lb);
+    g_object_set_data(G_OBJECT(win), "percentage_label", percentage_lb);
 
     gtk_widget_show_all(win);
 
@@ -226,7 +226,7 @@ splash_update(register_action_e action, const char *message, gpointer client_dat
 					  registering plugins, handingoff plugins,
 					  preferences and configuration */
 
-    main_lb = OBJECT_GET_DATA(win, "protocol_label");
+    main_lb = g_object_get_data(G_OBJECT(win), "protocol_label");
     /* make_dissector_reg.py changed -
        so we need to strip off the leading elements to get back to the protocol */
     if(message) {
@@ -245,10 +245,10 @@ splash_update(register_action_e action, const char *message, gpointer client_dat
     ul_percentage = (gulong)(percentage * 100);
 
     /* update progress bar */
-    prog_bar = OBJECT_GET_DATA(win, "progress_bar");
+    prog_bar = g_object_get_data(G_OBJECT(win), "progress_bar");
     gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(prog_bar), percentage);
 
-    percentage_lb = OBJECT_GET_DATA(win, "percentage_label");
+    percentage_lb = g_object_get_data(G_OBJECT(win), "percentage_label");
     g_snprintf(tmp, sizeof(tmp), "%lu%%", ul_percentage);
     gtk_label_set_text((GtkLabel*)percentage_lb, tmp);
 
@@ -470,20 +470,20 @@ about_wireshark_cb( GtkWidget *w _U_, gpointer data _U_ )
   license_page = about_license_page_new();
   page_lb = gtk_label_new("License");
   /* set a minmum width to avoid a lot of line breaks at the wrong places */
-  WIDGET_SET_SIZE(license_page, 600, -1);
+  gtk_widget_set_size_request(license_page, 600, -1);
   gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), license_page, page_lb);
 
   /* Button row */
   bbox = dlg_button_row_new(GTK_STOCK_OK, NULL);
   gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0);
 
-  ok_btn = OBJECT_GET_DATA(bbox, GTK_STOCK_OK);
+  ok_btn = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
   gtk_widget_grab_focus(ok_btn);
   gtk_widget_grab_default(ok_btn);
   window_set_cancel_button(about_wireshark_w, ok_btn, window_cancel_button_cb);
 
-  SIGNAL_CONNECT(about_wireshark_w, "delete_event", window_delete_event_cb, NULL);
-  SIGNAL_CONNECT(about_wireshark_w, "destroy", about_wireshark_destroy_cb, NULL);
+  g_signal_connect(about_wireshark_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+  g_signal_connect(about_wireshark_w, "destroy", G_CALLBACK(about_wireshark_destroy_cb), NULL);
 
   gtk_widget_show_all(about_wireshark_w);
   window_present(about_wireshark_w);
diff --git a/gtk/afp_stat.c b/gtk/afp_stat.c
index 3efcd68679..7a337d2626 100644
--- a/gtk/afp_stat.c
+++ b/gtk/afp_stat.c
@@ -187,11 +187,11 @@ gtk_afpstat_init(const char *optarg, void *userdata _U_)
 	bbox = dlg_button_row_new(GTK_STOCK_CLOSE, NULL);
 	gtk_box_pack_end(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
 
-	close_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_CLOSE);
+	close_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
 	window_set_cancel_button(ss->win, close_bt, window_cancel_button_cb);
 
-	SIGNAL_CONNECT(ss->win, "delete_event", window_delete_event_cb, NULL);
-	SIGNAL_CONNECT(ss->win, "destroy", win_destroy_cb, ss);
+	g_signal_connect(ss->win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+	g_signal_connect(ss->win, "destroy", G_CALLBACK(win_destroy_cb), ss);
 
 	gtk_widget_show_all(ss->win);
 	window_present(ss->win);
diff --git a/gtk/airpcap_dlg.c b/gtk/airpcap_dlg.c
index 8999d70f92..d0bc483d13 100644
--- a/gtk/airpcap_dlg.c
+++ b/gtk/airpcap_dlg.c
@@ -152,7 +152,7 @@ on_key_ls_select_row(GtkWidget *widget,
 {
     airpcap_key_ls_selected_info_t*  selected_item;
 
-    selected_item = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
+    selected_item = g_object_get_data(GTK_WIDGET(data),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
 
     selected_item->row = row;
     selected_item->column = column;
@@ -170,7 +170,7 @@ on_key_ls_unselect_row(GtkWidget *widget,
 {
     airpcap_key_ls_selected_info_t*  selected_item;
 
-    selected_item = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
+    selected_item = g_object_get_data(GTK_WIDGET(data),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
 
     selected_item->row = NO_ROW_SELECTED;
     selected_item->column = NO_COLUMN_SELECTED;
@@ -225,9 +225,9 @@ on_edit_type_en_changed(GtkWidget *w, gpointer data)
     edit_key_w = GTK_WIDGET(data);
     type_te    = w;
 
-    edit_ssid_te = OBJECT_GET_DATA(edit_key_w,AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY);
-    key_lb = OBJECT_GET_DATA(edit_key_w,AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY);
-    ssid_lb = OBJECT_GET_DATA(edit_key_w,AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY);
+    edit_ssid_te = g_object_get_data(edit_key_w,AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY);
+    key_lb = g_object_get_data(edit_key_w,AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY);
+    ssid_lb = g_object_get_data(edit_key_w,AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY);
 
     type_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(type_te)));
 
@@ -293,9 +293,9 @@ on_add_type_en_changed(GtkWidget *w, gpointer data)
     add_key_w = GTK_WIDGET(data);
     type_te    = w;
 
-    add_ssid_te = OBJECT_GET_DATA(add_key_w,AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY);
-    key_lb = OBJECT_GET_DATA(add_key_w,AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY);
-    ssid_lb = OBJECT_GET_DATA(add_key_w,AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY);
+    add_ssid_te = g_object_get_data(add_key_w,AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY);
+    key_lb = g_object_get_data(add_key_w,AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY);
+    ssid_lb = g_object_get_data(add_key_w,AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY);
 
     type_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(type_te)));
 
@@ -545,10 +545,10 @@ on_key_management_destroy(GtkWidget *w _U_, gpointer data _U_)
     /* Retrieve the GUI object pointers */
     airpcap_advanced_w  = GTK_WIDGET(data);
 
-    toolbar	= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY));
+    toolbar	= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY));
 
     /* ... */
-    from_widget	= (gint*)OBJECT_GET_DATA(toolbar,AIRPCAP_ADVANCED_FROM_KEY);
+    from_widget	= (gint*)g_object_get_data(toolbar,AIRPCAP_ADVANCED_FROM_KEY);
     /* gray out the toolbar (if we came here from the toolbar advanced button)*/
     if ( *from_widget == AIRPCAP_ADVANCED_FROM_TOOLBAR)
         gtk_widget_set_sensitive(toolbar,TRUE);
@@ -581,10 +581,10 @@ on_airpcap_advanced_destroy(GtkWidget *w _U_, gpointer data _U_)
     /* Retrieve the GUI object pointers */
     airpcap_advanced_w  = GTK_WIDGET(data);
 
-    toolbar	= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY));
+    toolbar	= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY));
 
     /* ... */
-    from_widget	= (gint*)OBJECT_GET_DATA(toolbar,AIRPCAP_ADVANCED_FROM_KEY);
+    from_widget	= (gint*)g_object_get_data(toolbar,AIRPCAP_ADVANCED_FROM_KEY);
     /* gray out the toolbar (if we came here from the toolbar advanced button)*/
     if ( *from_widget == AIRPCAP_ADVANCED_FROM_TOOLBAR)
         gtk_widget_set_sensitive(toolbar,TRUE);
@@ -626,10 +626,10 @@ on_key_management_apply_bt_clicked(GtkWidget *button _U_, gpointer data)
 
     /* retrieve main window */
     key_management_w      = GTK_WIDGET(data);
-    decryption_en         = GTK_WIDGET(OBJECT_GET_DATA(key_management_w,AIRPCAP_ADVANCED_WEP_DECRYPTION_KEY));
-    key_ls                = GTK_WIDGET(OBJECT_GET_DATA(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
-    toolbar               = GTK_WIDGET(OBJECT_GET_DATA(key_management_w,AIRPCAP_TOOLBAR_KEY));
-    toolbar_cm            = GTK_WIDGET(OBJECT_GET_DATA(key_management_w,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+    decryption_en         = GTK_WIDGET(g_object_get_data(key_management_w,AIRPCAP_ADVANCED_WEP_DECRYPTION_KEY));
+    key_ls                = GTK_WIDGET(g_object_get_data(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
+    toolbar               = GTK_WIDGET(g_object_get_data(key_management_w,AIRPCAP_TOOLBAR_KEY));
+    toolbar_cm            = GTK_WIDGET(g_object_get_data(key_management_w,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
 
 #define CANT_SAVE_ERR_STR "Cannot save configuration!\n" \
 	"In order to store the configuration in the registry you must:\n\n" \
@@ -680,13 +680,13 @@ on_advanced_apply_bt_clicked(GtkWidget *button, gpointer data _U_)
     /* retrieve main window */
     main_w = GTK_WIDGET(data);
 
-    toolbar = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_TOOLBAR_KEY));
+    toolbar = GTK_WIDGET(g_object_get_data(main_w,AIRPCAP_TOOLBAR_KEY));
 
     /* retrieve toolbar info */
-    toolbar_if_lb				= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
-    toolbar_channel_cm			= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
-    toolbar_channel_offset_cb	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY));
-    toolbar_wrong_crc_cm		= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
+    toolbar_if_lb				= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+    toolbar_channel_cm			= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+    toolbar_channel_offset_cb	= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY));
+    toolbar_wrong_crc_cm		= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
 
     /* Save the configuration (for all ) */
     airpcap_save_selected_if_configuration(airpcap_if_selected);
@@ -722,15 +722,15 @@ airpcap_advanced_ok_cb(GtkWidget *w, gpointer data _U_)
     /* retrieve main window */
     main_w = GTK_WIDGET(data);
 
-    toolbar = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_TOOLBAR_KEY));
+    toolbar = GTK_WIDGET(g_object_get_data(main_w,AIRPCAP_TOOLBAR_KEY));
 
-    key_ls	= GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
+    key_ls	= GTK_WIDGET(g_object_get_data(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
 
     /* retrieve toolbar info */
-    toolbar_if_lb			= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
-    toolbar_channel_cm		= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
-    toolbar_wrong_crc_cm	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
-    toolbar_decryption_ck	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+    toolbar_if_lb			= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+    toolbar_channel_cm		= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+    toolbar_wrong_crc_cm	= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
+    toolbar_decryption_ck	= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
 
     /* Save the configuration */
     airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
@@ -792,11 +792,11 @@ on_add_key_ok_bt_clicked(GtkWidget *widget, gpointer data _U_)
     gint r = NO_ROW_SELECTED;
     gint c = NO_COLUMN_SELECTED;
 
-    key_ls = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_LIST_KEY);
-    selected_item = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
-    type_cm = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY);
-    key_en = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_KEY_KEY);
-    ssid_en = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY);
+    key_ls = g_object_get_data(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_LIST_KEY);
+    selected_item = g_object_get_data(GTK_WIDGET(data),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
+    type_cm = g_object_get_data(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY);
+    key_en = g_object_get_data(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_KEY_KEY);
+    ssid_en = g_object_get_data(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY);
 
     r = selected_item->row;
     c = selected_item->column;
@@ -1000,11 +1000,11 @@ on_edit_key_ok_bt_clicked(GtkWidget *widget, gpointer data _U_)
     gint r = NO_ROW_SELECTED;
     gint c = NO_COLUMN_SELECTED;
 
-    key_ls = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_LIST_KEY);
-    selected_item = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_SELECTED_KEY);
-    type_cm = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY);
-    key_en = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_KEY_KEY);
-    ssid_en = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY);
+    key_ls = g_object_get_data(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_LIST_KEY);
+    selected_item = g_object_get_data(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_SELECTED_KEY);
+    type_cm = g_object_get_data(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY);
+    key_en = g_object_get_data(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_KEY_KEY);
+    ssid_en = g_object_get_data(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY);
 
     r = selected_item->row;
     c = selected_item->column;
@@ -1218,13 +1218,13 @@ on_add_new_key_bt_clicked(GtkWidget *button, gpointer data _U_)
     airpcap_advanced_w = GTK_WIDGET(data);
 
     /* Retrieve the selected item... if no row is selected, this is null... */
-    selected_item = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
+    selected_item = g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
 
     r = selected_item->row;
     c = selected_item->column;
 
     /* Retrieve the key list widget pointer, and add it to the add_key_w */
-    key_ls = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
+    key_ls = g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
 
     keys_in_list = GTK_CLIST(key_ls)->rows;
 
@@ -1356,20 +1356,20 @@ on_add_new_key_bt_clicked(GtkWidget *button, gpointer data _U_)
     gtk_label_set_use_markup (GTK_LABEL (add_frame_lb), TRUE);
 
     /* Add callbacks */
-    SIGNAL_CONNECT(ok_bt, "clicked", on_add_key_ok_bt_clicked, add_key_window );
-    SIGNAL_CONNECT(cancel_bt, "clicked", window_cancel_button_cb, add_key_window );
-    SIGNAL_CONNECT(add_type_en, "changed",on_add_type_en_changed, add_key_window);
-    SIGNAL_CONNECT(add_key_window, "delete_event",window_delete_event_cb, add_key_window);
-    SIGNAL_CONNECT(add_key_window, "destroy",on_add_key_w_destroy, data);
+    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_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 */
-    OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_LIST_KEY,key_ls);
-    OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY,selected_item);
-    OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY,add_type_cm);
-    OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_KEY_KEY,add_key_te);
-    OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY,add_ssid_te);
-    OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY,add_key_lb);
-    OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY,add_ssid_lb);
+    g_object_set_data(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_LIST_KEY,key_ls);
+    g_object_set_data(add_key_window,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY,selected_item);
+    g_object_set_data(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY,add_type_cm);
+    g_object_set_data(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_KEY_KEY,add_key_te);
+    g_object_set_data(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY,add_ssid_te);
+    g_object_set_data(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY,add_key_lb);
+    g_object_set_data(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY,add_ssid_lb);
 
     gtk_widget_show(add_key_window);
 }
@@ -1432,8 +1432,8 @@ on_remove_key_bt_clicked(GtkWidget *button, gpointer data _U_)
     airpcap_advanced_w = GTK_WIDGET(data);
 
     /* retrieve needed stuff */
-    key_ls        = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
-    selected_item = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
+    key_ls        = g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
+    selected_item = g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
 
     /*
      * Better to store the selected_item data in two new variables, because maybe some
@@ -1501,13 +1501,13 @@ on_edit_key_bt_clicked(GtkWidget *button, gpointer data _U_)
     airpcap_advanced_w = GTK_WIDGET(data);
 
     /* Retrieve the selected item... if no row is selected, this is null... */
-    selected_item = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
+    selected_item = g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
 
     r = selected_item->row;
     c = selected_item->column;
 
     /* Retrieve the key list widget pointer, and add it to the edit_key_w */
-    key_ls = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
+    key_ls = g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
 
     if ((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED))
     {
@@ -1652,20 +1652,20 @@ on_edit_key_bt_clicked(GtkWidget *button, gpointer data _U_)
         gtk_label_set_use_markup (GTK_LABEL (edit_frame_lb), TRUE);
 
         /* Add callbacks */
-        SIGNAL_CONNECT(ok_bt, "clicked", on_edit_key_ok_bt_clicked, edit_key_window );
-        SIGNAL_CONNECT(cancel_bt, "clicked", window_cancel_button_cb, edit_key_window );
-        SIGNAL_CONNECT(edit_type_en, "changed",on_edit_type_en_changed, edit_key_window);
-        SIGNAL_CONNECT(edit_key_window, "delete_event",window_delete_event_cb, edit_key_window);
-        SIGNAL_CONNECT(edit_key_window, "destroy",on_edit_key_w_destroy, data);
+        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_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 */
-        OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_LIST_KEY,key_ls);
-        OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_SELECTED_KEY,selected_item);
-        OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY,edit_type_cm);
-        OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_KEY_KEY,edit_key_te);
-        OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY,edit_ssid_te);
-        OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY,edit_key_lb);
-        OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY,edit_ssid_lb);
+        g_object_set_data(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_LIST_KEY,key_ls);
+        g_object_set_data(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_SELECTED_KEY,selected_item);
+        g_object_set_data(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY,edit_type_cm);
+        g_object_set_data(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_KEY_KEY,edit_key_te);
+        g_object_set_data(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY,edit_ssid_te);
+        g_object_set_data(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY,edit_key_lb);
+        g_object_set_data(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY,edit_ssid_lb);
 
         gtk_widget_show(edit_key_window);
     }
@@ -1690,8 +1690,8 @@ on_move_key_up_bt_clicked(GtkWidget *button, gpointer data _U_)
     airpcap_advanced_w = GTK_WIDGET(data);
 
     /* retrieve needed stuff */
-    key_ls        = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
-    selected_item = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
+    key_ls        = g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
+    selected_item = g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
 
     /*
      * Better to store the selected_item data in two new variables, because maybe some
@@ -1740,8 +1740,8 @@ on_move_key_down_bt_clicked(GtkWidget *button, gpointer data _U_)
     airpcap_advanced_w = GTK_WIDGET(data);
 
     /* retrieve needed stuff */
-    key_ls        = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
-    selected_item = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
+    key_ls        = g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
+    selected_item = g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);
 
     /*
      * Better to store the selected_item data in two new variables, because maybe some
@@ -1950,9 +1950,9 @@ display_airpcap_advanced_cb(GtkWidget *w, gpointer data)
 
     /* user data - RETRIEVE pointers of toolbar widgets */
     toolbar				= GTK_WIDGET(data);
-    toolbar_if_lb		= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
-    toolbar_channel_cm	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
-    toolbar_wrong_crc_cm= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
+    toolbar_if_lb		= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+    toolbar_channel_cm	= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+    toolbar_wrong_crc_cm= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
 
     /* gray out the toolbar */
     gtk_widget_set_sensitive(toolbar,FALSE);
@@ -2261,32 +2261,32 @@ display_airpcap_advanced_cb(GtkWidget *w, gpointer data)
     gtk_button_box_set_layout (GTK_BUTTON_BOX (right_h_button_box),
                                GTK_BUTTONBOX_END);
 
-    ok_bt = OBJECT_GET_DATA(right_h_button_box, GTK_STOCK_OK);
-    apply_bt = OBJECT_GET_DATA(right_h_button_box, GTK_STOCK_APPLY);
-    cancel_bt = OBJECT_GET_DATA(right_h_button_box, GTK_STOCK_CANCEL);
+    ok_bt = g_object_get_data(right_h_button_box, GTK_STOCK_OK);
+    apply_bt = g_object_get_data(right_h_button_box, GTK_STOCK_APPLY);
+    cancel_bt = g_object_get_data(right_h_button_box, GTK_STOCK_CANCEL);
 
     /* Connect the callbacks */
-    SIGNAL_CONNECT (airpcap_advanced_w, "delete_event", window_delete_event_cb, airpcap_advanced_w);
-    SIGNAL_CONNECT (airpcap_advanced_w, "destroy", on_airpcap_advanced_destroy, airpcap_advanced_w);
+    g_signal_connect (airpcap_advanced_w, "delete_event", G_CALLBACK(window_delete_event_cb), airpcap_advanced_w);
+    g_signal_connect (airpcap_advanced_w, "destroy", G_CALLBACK(on_airpcap_advanced_destroy), airpcap_advanced_w);
 
     if (!airpcap_if_is_any(airpcap_if_selected))
     {
-        SIGNAL_CONNECT (blink_bt, "clicked", on_blink_bt_clicked, airpcap_advanced_w);
+	g_signal_connect (blink_bt, "clicked", G_CALLBACK(on_blink_bt_clicked), airpcap_advanced_w);
     }
     else
     {
-        SIGNAL_CONNECT (blink_bt, "clicked", on_what_s_this_bt_clicked, airpcap_advanced_w);
+        g_signal_connect (blink_bt, "clicked", G_CALLBACK(on_what_s_this_bt_clicked), airpcap_advanced_w);
     }
 
-    SIGNAL_CONNECT (channel_en, "changed",on_channel_en_changed, channel_offset_cb);
-    SIGNAL_CONNECT (GTK_COMBO(channel_offset_cb)->entry, "changed",on_channel_offset_cb_changed, airpcap_advanced_w);
-    SIGNAL_CONNECT (capture_type_en, "changed",on_capture_type_en_changed, airpcap_advanced_w);
-    SIGNAL_CONNECT (fcs_ck, "toggled",on_fcs_ck_toggled, airpcap_advanced_w);
-    SIGNAL_CONNECT (fcs_filter_en, "changed",on_fcs_filter_en_changed, airpcap_advanced_w);
-    SIGNAL_CONNECT (reset_configuration_bt, "clicked",on_reset_configuration_bt_clicked, airpcap_advanced_w);
-    SIGNAL_CONNECT (apply_bt, "clicked",on_advanced_apply_bt_clicked, airpcap_advanced_w);
-    SIGNAL_CONNECT (ok_bt,"clicked",on_advanced_ok_bt_clicked,airpcap_advanced_w);
-    SIGNAL_CONNECT (cancel_bt,"clicked",on_advanced_cancel_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), airpcap_advanced_w);
+    g_signal_connect (capture_type_en, "changed", G_CALLBACK(on_capture_type_en_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 (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);
+    g_signal_connect (cancel_bt,"clicked", G_CALLBACK(on_advanced_cancel_bt_clicked), airpcap_advanced_w);
 
     /* Different because the window will be closed ... */
     /*window_set_cancel_button(airpcap_advanced_w, ok_bt, window_cancel_button_cb);
@@ -2294,19 +2294,19 @@ display_airpcap_advanced_cb(GtkWidget *w, gpointer data)
 
 
     /* Store pointers to all widgets, for use by lookup_widget(). */
-    OBJECT_SET_DATA (airpcap_advanced_w, AIRPCAP_ADVANCED_BLINK_KEY, blink_bt);
-    OBJECT_SET_DATA (airpcap_advanced_w, AIRPCAP_ADVANCED_CHANNEL_KEY,channel_cm);
-    OBJECT_SET_DATA (airpcap_advanced_w, AIRPCAP_ADVANCED_LINK_TYPE_KEY,capture_type_cm);
-    OBJECT_SET_DATA (airpcap_advanced_w, AIRPCAP_ADVANCED_FCS_CHECK_KEY, fcs_ck);
-    OBJECT_SET_DATA (airpcap_advanced_w, AIRPCAP_ADVANCED_FCS_FILTER_KEY, fcs_filter_cm);
-    OBJECT_SET_DATA (airpcap_advanced_w, AIRPCAP_ADVANCED_OK_KEY, ok_bt);
-    OBJECT_SET_DATA (airpcap_advanced_w, AIRPCAP_ADVANCED_CANCEL_KEY, cancel_bt);
+    g_object_set_data (airpcap_advanced_w, AIRPCAP_ADVANCED_BLINK_KEY, blink_bt);
+    g_object_set_data (airpcap_advanced_w, AIRPCAP_ADVANCED_CHANNEL_KEY,channel_cm);
+    g_object_set_data (airpcap_advanced_w, AIRPCAP_ADVANCED_LINK_TYPE_KEY,capture_type_cm);
+    g_object_set_data (airpcap_advanced_w, AIRPCAP_ADVANCED_FCS_CHECK_KEY, fcs_ck);
+    g_object_set_data (airpcap_advanced_w, AIRPCAP_ADVANCED_FCS_FILTER_KEY, fcs_filter_cm);
+    g_object_set_data (airpcap_advanced_w, AIRPCAP_ADVANCED_OK_KEY, ok_bt);
+    g_object_set_data (airpcap_advanced_w, AIRPCAP_ADVANCED_CANCEL_KEY, cancel_bt);
 
     /*
      * I will need the toolbar and the main widget in some callback,
      * so I will add the toolbar pointer to the airpcap_advanced_w
      */
-    OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY,toolbar);
+    g_object_set_data(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY,toolbar);
 
     /* At the end, so that it appears completely all together ... */
     gtk_widget_show (airpcap_advanced_w);
@@ -2342,23 +2342,23 @@ on_advanced_ok_bt_clicked(GtkWidget *button, gpointer data _U_)
 
     /* Retrieve the GUI object pointers */
     airpcap_advanced_w			= GTK_WIDGET(data);
-    interface_combo				= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_INTERFACE_KEY));
-    channel_combo				= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CHANNEL_KEY));
-    capture_combo				= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY));
-    crc_check					= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_FCS_CHECK_KEY));
-    wrong_crc_combo				= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_FCS_FILTER_KEY));
-    blink_bt					= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_BLINK_KEY));
-    cancel_bt					= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CANCEL_KEY));
-    ok_bt						= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_OK_KEY));
-    advanced_bt					= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEY));
-
-    toolbar						= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY));
+    interface_combo				= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_INTERFACE_KEY));
+    channel_combo				= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_CHANNEL_KEY));
+    capture_combo				= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY));
+    crc_check					= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_FCS_CHECK_KEY));
+    wrong_crc_combo				= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_FCS_FILTER_KEY));
+    blink_bt					= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_BLINK_KEY));
+    cancel_bt					= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_CANCEL_KEY));
+    ok_bt						= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_OK_KEY));
+    advanced_bt					= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_KEY));
+
+    toolbar						= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY));
 
     /* retrieve toolbar info */
-    toolbar_if_lb			= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
-    toolbar_channel_cm		= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
-    toolbar_channel_offset_cb	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY));
-    toolbar_wrong_crc_cm	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
+    toolbar_if_lb			= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+    toolbar_channel_cm		= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+    toolbar_channel_offset_cb	= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY));
+    toolbar_wrong_crc_cm	= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
 
     /* Stop blinking ALL leds (go through the airpcap_if_list) */
     if (airpcap_if_selected != NULL)
@@ -2432,22 +2432,22 @@ on_advanced_cancel_bt_clicked(GtkWidget *button, gpointer data _U_)
 
     /* Retrieve the GUI object pointers */
     airpcap_advanced_w  = GTK_WIDGET(data);
-    interface_combo		= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_INTERFACE_KEY));
-    channel_combo		= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CHANNEL_KEY));
-    capture_combo		= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY));
-    crc_check			= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_FCS_CHECK_KEY));
-    wrong_crc_combo		= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_FCS_FILTER_KEY));
-    blink_bt			= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_BLINK_KEY));
-    cancel_bt			= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CANCEL_KEY));
-    ok_bt				= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_OK_KEY));
-    advanced_bt			= GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEY));
-
-    toolbar = GTK_WIDGET(OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY));
+    interface_combo		= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_INTERFACE_KEY));
+    channel_combo		= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_CHANNEL_KEY));
+    capture_combo		= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY));
+    crc_check			= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_FCS_CHECK_KEY));
+    wrong_crc_combo		= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_FCS_FILTER_KEY));
+    blink_bt			= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_BLINK_KEY));
+    cancel_bt			= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_CANCEL_KEY));
+    ok_bt				= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_OK_KEY));
+    advanced_bt			= GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_ADVANCED_KEY));
+
+    toolbar = GTK_WIDGET(g_object_get_data(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY));
 
     /* retrieve toolbar info */
-    toolbar_if_lb			= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
-    toolbar_channel_cm		= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
-    toolbar_wrong_crc_cm	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
+    toolbar_if_lb			= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+    toolbar_channel_cm		= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+    toolbar_wrong_crc_cm	= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_FCS_FILTER_KEY));
 
     /* Stop blinking ALL leds (go through the airpcap_if_list) */
     if (airpcap_if_selected != NULL)
@@ -2524,7 +2524,7 @@ display_airpcap_key_management_cb(GtkWidget *w, gpointer data)
 
     /* user data - RETRIEVE pointers of toolbar widgets */
     toolbar				  = GTK_WIDGET(data);
-    toolbar_decryption_ck = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+    toolbar_decryption_ck = GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
 
     /* gray out the toolbar */
     gtk_widget_set_sensitive(toolbar,FALSE);
@@ -2665,31 +2665,31 @@ display_airpcap_key_management_cb(GtkWidget *w, gpointer data)
     gtk_box_pack_start (GTK_BOX (keys_v_sub_box), key_v_button_box, FALSE, TRUE,
                         0);
 
-    add_new_key_bt = BUTTON_NEW_FROM_STOCK(GTK_STOCK_NEW);
+    add_new_key_bt = gtk_button_new_from_stock(GTK_STOCK_NEW);
     gtk_widget_set_name (add_new_key_bt, "add_new_key_bt");
     gtk_widget_show (add_new_key_bt);
     gtk_container_add (GTK_CONTAINER (key_v_button_box), add_new_key_bt);
     GTK_WIDGET_SET_FLAGS (add_new_key_bt, GTK_CAN_DEFAULT);
 
-    edit_key_bt = BUTTON_NEW_FROM_STOCK(WIRESHARK_STOCK_EDIT);
+    edit_key_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_EDIT);
     gtk_widget_set_name (edit_key_bt, "edit_key_bt");
     gtk_widget_show (edit_key_bt);
     gtk_container_add (GTK_CONTAINER (key_v_button_box), edit_key_bt);
     GTK_WIDGET_SET_FLAGS (edit_key_bt, GTK_CAN_DEFAULT);
 
-    remove_key_bt = BUTTON_NEW_FROM_STOCK(GTK_STOCK_DELETE);
+    remove_key_bt = gtk_button_new_from_stock(GTK_STOCK_DELETE);
     gtk_widget_set_name (remove_key_bt, "remove_key_bt");
     gtk_widget_show (remove_key_bt);
     gtk_container_add (GTK_CONTAINER (key_v_button_box), remove_key_bt);
     GTK_WIDGET_SET_FLAGS (remove_key_bt, GTK_CAN_DEFAULT);
 
-    move_key_up_bt = BUTTON_NEW_FROM_STOCK(GTK_STOCK_GO_UP);
+    move_key_up_bt = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
     gtk_widget_set_name (move_key_up_bt, "move_key_up_bt");
     gtk_widget_show (move_key_up_bt);
     gtk_container_add (GTK_CONTAINER (key_v_button_box), move_key_up_bt);
     GTK_WIDGET_SET_FLAGS (move_key_up_bt, GTK_CAN_DEFAULT);
 
-    move_key_down_bt = BUTTON_NEW_FROM_STOCK(GTK_STOCK_GO_DOWN);
+    move_key_down_bt = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
     gtk_widget_set_name (move_key_down_bt, "move_key_down_bt");
     gtk_widget_show (move_key_down_bt);
     gtk_container_add (GTK_CONTAINER (key_v_button_box), move_key_down_bt);
@@ -2728,44 +2728,44 @@ display_airpcap_key_management_cb(GtkWidget *w, gpointer data)
     gtk_button_box_set_layout (GTK_BUTTON_BOX (right_h_button_box),
                                GTK_BUTTONBOX_END);
 
-    ok_bt = OBJECT_GET_DATA(right_h_button_box, GTK_STOCK_OK);
-    apply_bt = OBJECT_GET_DATA(right_h_button_box, GTK_STOCK_APPLY);
-    cancel_bt = OBJECT_GET_DATA(right_h_button_box, GTK_STOCK_CANCEL);
+    ok_bt = g_object_get_data(right_h_button_box, GTK_STOCK_OK);
+    apply_bt = g_object_get_data(right_h_button_box, GTK_STOCK_APPLY);
+    cancel_bt = g_object_get_data(right_h_button_box, GTK_STOCK_CANCEL);
 
     /* Connect the callbacks */
-    SIGNAL_CONNECT (key_management_w, "delete_event", window_delete_event_cb, key_management_w);
-    SIGNAL_CONNECT (key_management_w, "destroy", on_key_management_destroy, key_management_w);
-    SIGNAL_CONNECT (add_new_key_bt, "clicked",on_add_new_key_bt_clicked, key_management_w);
-    SIGNAL_CONNECT (remove_key_bt, "clicked",on_remove_key_bt_clicked, key_management_w);
-    SIGNAL_CONNECT (edit_key_bt, "clicked",on_edit_key_bt_clicked, key_management_w);
-    SIGNAL_CONNECT (move_key_up_bt, "clicked",on_move_key_up_bt_clicked, key_management_w);
-    SIGNAL_CONNECT (move_key_down_bt, "clicked",on_move_key_down_bt_clicked, key_management_w);
-    SIGNAL_CONNECT (reset_configuration_bt, "clicked",on_reset_configuration_bt_clicked, key_management_w);
-    SIGNAL_CONNECT (apply_bt, "clicked",on_key_management_apply_bt_clicked, key_management_w);
-    SIGNAL_CONNECT (ok_bt, "clicked",on_key_management_ok_bt_clicked, key_management_w);
-    SIGNAL_CONNECT (cancel_bt, "clicked",on_key_management_cancel_bt_clicked, key_management_w);
-    SIGNAL_CONNECT (key_ls, "select_row",on_key_ls_select_row, key_management_w);
-    SIGNAL_CONNECT (key_ls, "unselect_row",on_key_ls_unselect_row, key_management_w);
-    SIGNAL_CONNECT (key_ls, "click_column",on_key_ls_click_column, key_management_w);
+    g_signal_connect (key_management_w, "delete_event", G_CALLBACK(window_delete_event_cb), key_management_w);
+    g_signal_connect (key_management_w, "destroy", G_CALLBACK(on_key_management_destroy), key_management_w);
+    g_signal_connect (add_new_key_bt, "clicked", G_CALLBACK(on_add_new_key_bt_clicked), key_management_w);
+    g_signal_connect (remove_key_bt, "clicked", G_CALLBACK(on_remove_key_bt_clicked), key_management_w);
+    g_signal_connect (edit_key_bt, "clicked", G_CALLBACK(on_edit_key_bt_clicked), key_management_w);
+    g_signal_connect (move_key_up_bt, "clicked", G_CALLBACK(on_move_key_up_bt_clicked), key_management_w);
+    g_signal_connect (move_key_down_bt, "clicked", G_CALLBACK(on_move_key_down_bt_clicked), key_management_w);
+    g_signal_connect (reset_configuration_bt, "clicked", G_CALLBACK(on_reset_configuration_bt_clicked), key_management_w);
+    g_signal_connect (apply_bt, "clicked", G_CALLBACK(on_key_management_apply_bt_clicked), key_management_w);
+    g_signal_connect (ok_bt, "clicked", G_CALLBACK(on_key_management_ok_bt_clicked), key_management_w);
+    g_signal_connect (cancel_bt, "clicked", G_CALLBACK(on_key_management_cancel_bt_clicked), key_management_w);
+    g_signal_connect (key_ls, "select_row", G_CALLBACK(on_key_ls_select_row), key_management_w);
+    g_signal_connect (key_ls, "unselect_row", G_CALLBACK(on_key_ls_unselect_row), key_management_w);
+    g_signal_connect (key_ls, "click_column", G_CALLBACK(on_key_ls_click_column), key_management_w);
 
     /* Different because the window will be closed ... */
     /*window_set_cancel_button(key_management_w, ok_bt, window_cancel_button_cb);
     window_set_cancel_button(key_management_w, cancel_bt, window_cancel_button_cb);*/
 
-    OBJECT_SET_DATA (key_management_w, AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY,key_ls_selected_item);
+    g_object_set_data (key_management_w, AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY,key_ls_selected_item);
 
     /* Store pointers to all widgets, for use by lookup_widget(). */
-    OBJECT_SET_DATA (key_management_w, AIRPCAP_ADVANCED_WEP_DECRYPTION_KEY, enable_decryption_en);
-    OBJECT_SET_DATA (key_management_w, AIRPCAP_ADVANCED_KEYLIST_KEY, key_ls);
-    OBJECT_SET_DATA (key_management_w, AIRPCAP_ADVANCED_OK_KEY, ok_bt);
-    OBJECT_SET_DATA (key_management_w, AIRPCAP_ADVANCED_CANCEL_KEY, cancel_bt);
+    g_object_set_data (key_management_w, AIRPCAP_ADVANCED_WEP_DECRYPTION_KEY, enable_decryption_en);
+    g_object_set_data (key_management_w, AIRPCAP_ADVANCED_KEYLIST_KEY, key_ls);
+    g_object_set_data (key_management_w, AIRPCAP_ADVANCED_OK_KEY, ok_bt);
+    g_object_set_data (key_management_w, AIRPCAP_ADVANCED_CANCEL_KEY, cancel_bt);
 
     /*
      * I will need the toolbar and the main widget in some callback,
      * so I will add the toolbar pointer to the key_management_w
      */
-    OBJECT_SET_DATA(key_management_w,AIRPCAP_TOOLBAR_KEY,toolbar);
-    OBJECT_SET_DATA (key_management_w, AIRPCAP_TOOLBAR_DECRYPTION_KEY, toolbar_decryption_ck);
+    g_object_set_data(key_management_w,AIRPCAP_TOOLBAR_KEY,toolbar);
+    g_object_set_data (key_management_w, AIRPCAP_TOOLBAR_DECRYPTION_KEY, toolbar_decryption_ck);
 
     /* FIRST OF ALL, CHECK THE KEY COLLECTIONS */
     /*
@@ -2847,18 +2847,18 @@ on_key_management_cancel_bt_clicked(GtkWidget *button, gpointer data _U_)
 
     /* Retrieve the GUI object pointers */
     key_management_w	= GTK_WIDGET(data);
-    cancel_bt			= GTK_WIDGET(OBJECT_GET_DATA(key_management_w,AIRPCAP_ADVANCED_CANCEL_KEY));
-    ok_bt				= GTK_WIDGET(OBJECT_GET_DATA(key_management_w,AIRPCAP_ADVANCED_OK_KEY));
-    key_ls				= GTK_WIDGET(OBJECT_GET_DATA(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
-    key_management_bt   = GTK_WIDGET(OBJECT_GET_DATA(key_management_w,AIRPCAP_ADVANCED_KEY));
+    cancel_bt			= GTK_WIDGET(g_object_get_data(key_management_w,AIRPCAP_ADVANCED_CANCEL_KEY));
+    ok_bt				= GTK_WIDGET(g_object_get_data(key_management_w,AIRPCAP_ADVANCED_OK_KEY));
+    key_ls				= GTK_WIDGET(g_object_get_data(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
+    key_management_bt   = GTK_WIDGET(g_object_get_data(key_management_w,AIRPCAP_ADVANCED_KEY));
 
-    toolbar = GTK_WIDGET(OBJECT_GET_DATA(key_management_w,AIRPCAP_TOOLBAR_KEY));
+    toolbar = GTK_WIDGET(g_object_get_data(key_management_w,AIRPCAP_TOOLBAR_KEY));
 
     /* retrieve toolbar info */
-    toolbar_decryption_ck	= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+    toolbar_decryption_ck	= GTK_WIDGET(g_object_get_data(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
 
     /* Retrieve the selected row item pointer... */
-    selected_item			= (airpcap_key_ls_selected_info_t*)(OBJECT_GET_DATA(key_management_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY));
+    selected_item			= (airpcap_key_ls_selected_info_t*)(g_object_get_data(key_management_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY));
     /* And free it */
     g_free(selected_item);
 
@@ -3008,17 +3008,17 @@ airpcap_keys_check_w(GtkWidget *w, gpointer data)
     GTK_WIDGET_SET_FLAGS (cancel_bt, GTK_CAN_DEFAULT);
 
     /* Store pointers to all widgets, for use by lookup_widget(). */
-    SIGNAL_CONNECT (ok_bt, "clicked", on_keys_check_ok_bt_clicked, keys_check_w);
-    SIGNAL_CONNECT (cancel_bt, "clicked", on_keys_check_cancel_bt_clicked, keys_check_w);
-    SIGNAL_CONNECT (keys_check_w, "destroy", on_keys_check_w_destroy, keys_check_w);
+    g_signal_connect (ok_bt, "clicked", G_CALLBACK(on_keys_check_ok_bt_clicked), keys_check_w);
+    g_signal_connect (cancel_bt, "clicked", G_CALLBACK(on_keys_check_cancel_bt_clicked), keys_check_w);
+    g_signal_connect (keys_check_w, "destroy", G_CALLBACK(on_keys_check_w_destroy), keys_check_w);
 
     /* Store pointers to all widgets, for use by lookup_widget(). */
-    OBJECT_SET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY,w);
-    OBJECT_SET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_MERGE_KEY,merge_rb);
-    OBJECT_SET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_KEEP_KEY,keep_rb);
-    OBJECT_SET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_IMPORT_KEY,import_rb);
-    OBJECT_SET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_IGNORE_KEY,ignore_rb);
-    OBJECT_SET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_GROUP_KEY,radio_bt_group);
+    g_object_set_data(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY,w);
+    g_object_set_data(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_MERGE_KEY,merge_rb);
+    g_object_set_data(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_KEEP_KEY,keep_rb);
+    g_object_set_data(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_IMPORT_KEY,import_rb);
+    g_object_set_data(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_IGNORE_KEY,ignore_rb);
+    g_object_set_data(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_GROUP_KEY,radio_bt_group);
 
     gtk_widget_set_sensitive(top_level,FALSE);
     gtk_widget_show(keys_check_w);
@@ -3033,14 +3033,14 @@ on_keys_check_cancel_bt_clicked (GtkWidget *button, gpointer user_data)
 
     keys_check_w = GTK_WIDGET(user_data);
 
-    key_management_w = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);
+    key_management_w = g_object_get_data(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);
 
     /* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,
        and is not NULL if it was called when the Key Management widget has been clicked */
     if (key_management_w != NULL)
     {
         /*  ... */
-        key_ls = OBJECT_GET_DATA(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
+        key_ls = g_object_get_data(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
         airpcap_fill_key_list(key_ls);
         gtk_widget_show (key_management_w);
     }
@@ -3061,11 +3061,11 @@ on_keys_check_ok_bt_clicked (GtkWidget *button, gpointer user_data)
 
     keys_check_w = GTK_WIDGET(user_data);
 
-    key_management_w = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);
-    merge_rb  = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_MERGE_KEY);
-    keep_rb   = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_KEEP_KEY);
-    import_rb = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_IMPORT_KEY);
-    ignore_rb = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_IGNORE_KEY);
+    key_management_w = g_object_get_data(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);
+    merge_rb  = g_object_get_data(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_MERGE_KEY);
+    keep_rb   = g_object_get_data(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_KEEP_KEY);
+    import_rb = g_object_get_data(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_IMPORT_KEY);
+    ignore_rb = g_object_get_data(keys_check_w,AIRPCAP_CHECK_WINDOW_RADIO_IGNORE_KEY);
 
     /* Find out which radio button is selected and call the correct function */
     if (GTK_TOGGLE_BUTTON(merge_rb)->active) on_merge_bt_clicked (merge_rb,keys_check_w);
@@ -3100,7 +3100,7 @@ on_keep_bt_clicked (GtkWidget *button, gpointer user_data)
 
     keys_check_w = GTK_WIDGET(user_data);
 
-    key_management_w = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);
+    key_management_w = g_object_get_data(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);
 
     n_adapters = g_list_length(airpcap_if_list);
 
@@ -3129,7 +3129,7 @@ on_keep_bt_clicked (GtkWidget *button, gpointer user_data)
     if (key_management_w != NULL)
     {
         /*  ... */
-        key_ls = OBJECT_GET_DATA(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
+        key_ls = g_object_get_data(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
         airpcap_fill_key_list(key_ls);
         gtk_widget_show (key_management_w);
     }
@@ -3160,7 +3160,7 @@ on_merge_bt_clicked (GtkWidget * button, gpointer user_data)
 
     keys_check_w = GTK_WIDGET(user_data);
 
-    key_management_w = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);
+    key_management_w = g_object_get_data(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);
 
     n_adapters = g_list_length(airpcap_if_list);
 
@@ -3210,7 +3210,7 @@ on_merge_bt_clicked (GtkWidget * button, gpointer user_data)
     if (key_management_w != NULL)
     {
         /*  ... */
-        key_ls = OBJECT_GET_DATA(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
+        key_ls = g_object_get_data(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
         airpcap_fill_key_list(key_ls);
         gtk_widget_show (key_management_w);
     }
@@ -3242,7 +3242,7 @@ on_import_bt_clicked (GtkWidget * button, gpointer user_data)
 
     keys_check_w = GTK_WIDGET(user_data);
 
-    key_management_w = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);
+    key_management_w = g_object_get_data(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);
 
     n_adapters = g_list_length(airpcap_if_list);
 
@@ -3289,7 +3289,7 @@ on_import_bt_clicked (GtkWidget * button, gpointer user_data)
     if (key_management_w != NULL)
     {
         /*  ... */
-        key_ls = OBJECT_GET_DATA(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
+        key_ls = g_object_get_data(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
         airpcap_fill_key_list(key_ls);
         gtk_widget_show (key_management_w);
     }
@@ -3305,14 +3305,14 @@ on_ignore_bt_clicked (GtkWidget * button, gpointer user_data)
 
     keys_check_w = GTK_WIDGET(user_data);
 
-    key_management_w = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);
+    key_management_w = g_object_get_data(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);
 
     /* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,
        and is not NULL if it was called when the Key Management widget has been clicked */
     if (key_management_w != NULL)
     {
         /*  ... */
-        key_ls = OBJECT_GET_DATA(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
+        key_ls = g_object_get_data(key_management_w,AIRPCAP_ADVANCED_KEYLIST_KEY);
         airpcap_fill_key_list(key_ls);
         gtk_widget_show (key_management_w);
     }
diff --git a/gtk/airpcap_gui_utils.c b/gtk/airpcap_gui_utils.c
index 881515ee05..b61c6e4aff 100644
--- a/gtk/airpcap_gui_utils.c
+++ b/gtk/airpcap_gui_utils.c
@@ -122,17 +122,17 @@ airpcap_set_toolbar_start_capture(airpcap_if_info_t* if_info)
 
     gchar *if_label_text;
 
-    airpcap_toolbar_label    = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_INTERFACE_KEY);
-    airpcap_toolbar_channel  = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_KEY);
-    airpcap_toolbar_channel_lb  = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY);
-    airpcap_toolbar_channel_offset  = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY);
-    airpcap_toolbar_channel_offset_lb  = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY);
-    airpcap_toolbar_fcs  = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_FCS_FILTER_KEY);
-    airpcap_toolbar_fcs_lb  = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY);
-    airpcap_toolbar_button   = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_ADVANCED_KEY);
-    airpcap_toolbar_decryption = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_DECRYPTION_KEY);
-    airpcap_toolbar_decryption_lb = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY);
-    airpcap_toolbar_keys_button = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_KEY_MANAGEMENT_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);
+    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);
+    airpcap_toolbar_fcs  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_KEY);
+    airpcap_toolbar_fcs_lb  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY);
+    airpcap_toolbar_button   = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_ADVANCED_KEY);
+    airpcap_toolbar_decryption = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY);
+    airpcap_toolbar_decryption_lb = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY);
+    airpcap_toolbar_keys_button = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_KEY_MANAGEMENT_KEY);
 
     /* The current interface is an airpcap interface */
     if(if_info != NULL)
@@ -220,18 +220,18 @@ airpcap_set_toolbar_stop_capture(airpcap_if_info_t* if_info)
 
     gchar *if_label_text;
 
-    airpcap_toolbar_crc_filter_combo = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_FCS_FILTER_KEY);
-    airpcap_toolbar_label    = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_INTERFACE_KEY);
-    airpcap_toolbar_channel  = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_KEY);
-    airpcap_toolbar_channel_lb  = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY);
-    airpcap_toolbar_channel_offset  = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY);
-    airpcap_toolbar_channel_offset_lb  = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY);
-    airpcap_toolbar_fcs  = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_FCS_FILTER_KEY);
-    airpcap_toolbar_fcs_lb  = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY);
-    airpcap_toolbar_button   = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_ADVANCED_KEY);
-    airpcap_toolbar_decryption = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_DECRYPTION_KEY);
-    airpcap_toolbar_decryption_lb = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY);
-    airpcap_toolbar_keys_button = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_KEY_MANAGEMENT_KEY);
+    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);
+    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);
+    airpcap_toolbar_fcs  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_KEY);
+    airpcap_toolbar_fcs_lb  = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY);
+    airpcap_toolbar_button   = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_ADVANCED_KEY);
+    airpcap_toolbar_decryption = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY);
+    airpcap_toolbar_decryption_lb = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY);
+    airpcap_toolbar_keys_button = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_KEY_MANAGEMENT_KEY);
 
     /* The current interface is an airpcap interface */
     if(if_info != NULL)
@@ -1227,14 +1227,14 @@ airpcap_enable_toolbar_widgets(GtkWidget* w, gboolean en)
 
     toolbar_tb = w;
 
-    if_description_lb	= OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_INTERFACE_KEY);
-    channel_lb			= OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY);
-    channel_cb			= OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_CHANNEL_KEY);
-    channel_offset_cb	= OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY);
-    channel_offset_lb	= OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY);
-    fcs_lb				= OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY);
-    fcs_cb				= OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_FCS_FILTER_KEY);
-    advanced_bt			= OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_ADVANCED_KEY);
+    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);
+    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);
+    fcs_cb				= g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_FCS_FILTER_KEY);
+    advanced_bt			= g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_ADVANCED_KEY);
 
 
     if(if_description_lb != NULL)	gtk_widget_set_sensitive(if_description_lb,en);
@@ -1271,14 +1271,14 @@ airpcap_set_toolbar_no_if(GtkWidget* w)
 
     toolbar_tb = w;
 
-    if_description_lb	    = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_INTERFACE_KEY);
-    channel_lb			      = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY);
-    channel_cb			      = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_CHANNEL_KEY);
-    channel_offset_lb			= OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY);
-    channel_offset_cb			= OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY);
-    fcs_lb				        = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY);
-    fcs_cb				        = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_FCS_FILTER_KEY);
-    advanced_bt			      = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_ADVANCED_KEY);
+    if_description_lb	    = g_object_get_data(G_OBJECT(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);
+    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);
+    fcs_cb				        = g_object_get_data(G_OBJECT(toolbar_tb),AIRPCAP_TOOLBAR_FCS_FILTER_KEY);
+    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),"");
diff --git a/gtk/ansi_a_stat.c b/gtk/ansi_a_stat.c
index 927970a4a9..bf3745d92e 100644
--- a/gtk/ansi_a_stat.c
+++ b/gtk/ansi_a_stat.c
@@ -346,17 +346,17 @@ ansi_a_stat_gtk_win_create(
     gtk_clist_column_titles_show(GTK_CLIST(dlg_p->table));
     gtk_container_add(GTK_CONTAINER(dlg_p->scrolled_win), dlg_p->table);
 
-    SIGNAL_CONNECT(dlg_p->table, "click-column", ansi_a_stat_gtk_click_column_cb, col_arrows);
+    g_signal_connect(dlg_p->table, "click-column", G_CALLBACK(ansi_a_stat_gtk_click_column_cb), col_arrows);
 
 	/* Button row. */
     bbox = dlg_button_row_new(GTK_STOCK_CLOSE, NULL);
     gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
 
-    bt_close = OBJECT_GET_DATA(bbox, GTK_STOCK_CLOSE);
+    bt_close = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
     window_set_cancel_button(dlg_p->win, bt_close, window_cancel_button_cb);
 
-    SIGNAL_CONNECT(dlg_p->win, "delete_event", window_delete_event_cb, NULL);
-    SIGNAL_CONNECT(dlg_p->win, "destroy", ansi_a_stat_gtk_win_destroy_cb, dlg_p);
+    g_signal_connect(dlg_p->win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+    g_signal_connect(dlg_p->win, "destroy", G_CALLBACK(ansi_a_stat_gtk_win_destroy_cb), dlg_p);
 
     gtk_widget_show_all(dlg_p->win);
     window_present(dlg_p->win);
diff --git a/gtk/ansi_map_stat.c b/gtk/ansi_map_stat.c
index b045e9c8c1..5ee14936a3 100644
--- a/gtk/ansi_map_stat.c
+++ b/gtk/ansi_map_stat.c
@@ -351,18 +351,18 @@ ansi_map_stat_gtk_win_create(
     gtk_clist_column_titles_show(GTK_CLIST(dlg_p->table));
     gtk_container_add(GTK_CONTAINER(dlg_p->scrolled_win), dlg_p->table);
 
-    SIGNAL_CONNECT(dlg_p->table, "click-column", ansi_map_stat_gtk_click_column_cb, col_arrows);
+    g_signal_connect(dlg_p->table, "click-column", G_CALLBACK(ansi_map_stat_gtk_click_column_cb), col_arrows);
 
     /* Button row. */
     bbox = dlg_button_row_new(GTK_STOCK_CLOSE, NULL);
 	gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
 
-    bt_close = OBJECT_GET_DATA(bbox, GTK_STOCK_CLOSE);
+    bt_close = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
 
     window_set_cancel_button(dlg_p->win, bt_close, window_cancel_button_cb);
 
-    SIGNAL_CONNECT(dlg_p->win, "delete_event", window_delete_event_cb, NULL);
-    SIGNAL_CONNECT(dlg_p->win, "destroy", ansi_map_stat_gtk_win_destroy_cb, dlg_p);
+    g_signal_connect(dlg_p->win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+    g_signal_connect(dlg_p->win, "destroy", G_CALLBACK(ansi_map_stat_gtk_win_destroy_cb), dlg_p);
 
     gtk_widget_show_all(dlg_p->win);
     window_present(dlg_p->win);
diff --git a/gtk/bootp_stat.c b/gtk/bootp_stat.c
index 6ed8edea9a..80eff1ec87 100644
--- a/gtk/bootp_stat.c
+++ b/gtk/bootp_stat.c
@@ -257,11 +257,11 @@ dhcpstat_init(const char *optarg, void *userdata _U_)
 	bbox = dlg_button_row_new(GTK_STOCK_CLOSE, NULL);
 	gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
 
-	bt_close = OBJECT_GET_DATA(bbox, GTK_STOCK_CLOSE);
+	bt_close = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
 	window_set_cancel_button(sp->win, bt_close, window_cancel_button_cb);
 
-	SIGNAL_CONNECT(sp->win, "delete_event", window_delete_event_cb, NULL);
-	SIGNAL_CONNECT(sp->win, "destroy", win_destroy_cb, sp);
+	g_signal_connect(sp->win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+	g_signal_connect(sp->win, "destroy", G_CALLBACK(win_destroy_cb), sp);
 
 	gtk_widget_show_all(sp->win);
 
diff --git a/gtk/camel_counter.c b/gtk/camel_counter.c
index 038f60f262..d84a1d6021 100644
--- a/gtk/camel_counter.c
+++ b/gtk/camel_counter.c
@@ -208,11 +208,11 @@ static void gtk_camelcounter_init(const char *optarg, void *userdata _U_)
   bbox = dlg_button_row_new(GTK_STOCK_CLOSE, NULL);
   gtk_box_pack_end(GTK_BOX(p_camelcounter->vbox), bbox, FALSE, FALSE, 0);
 
-  close_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_CLOSE);
+  close_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
   window_set_cancel_button(p_camelcounter->win, close_bt, window_cancel_button_cb);
 
-  SIGNAL_CONNECT(p_camelcounter->win, "delete_event", window_delete_event_cb, NULL);
-  SIGNAL_CONNECT(p_camelcounter->win, "destroy", win_destroy_cb, p_camelcounter);
+  g_signal_connect(p_camelcounter->win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+  g_signal_connect(p_camelcounter->win, "destroy", G_CALLBACK(win_destroy_cb), p_camelcounter);
 
   gtk_widget_show_all(p_camelcounter->win);
   window_present(p_camelcounter->win);
diff --git a/gtk/camel_srt.c b/gtk/camel_srt.c
index fba748f6ee..9966adb96a 100644
--- a/gtk/camel_srt.c
+++ b/gtk/camel_srt.c
@@ -226,11 +226,11 @@ static void gtk_camelsrt_init(const char *optarg, void *userdata _U_)
   bbox = dlg_button_row_new(GTK_STOCK_CLOSE, NULL);
   gtk_box_pack_end(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
   
-  close_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_CLOSE);
+  close_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
   window_set_cancel_button(p_camelsrt->win, close_bt, window_cancel_button_cb);
   
-  SIGNAL_CONNECT(p_camelsrt->win, "delete_event", window_delete_event_cb, NULL);
-  SIGNAL_CONNECT(p_camelsrt->win, "destroy", win_destroy_cb, p_camelsrt);
+  g_signal_connect(p_camelsrt->win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+  g_signal_connect(p_camelsrt->win, "destroy", G_CALLBACK(win_destroy_cb), p_camelsrt);
 
   gtk_widget_show_all(p_camelsrt->win);
   window_present(p_camelsrt->win);
diff --git a/gtk/capture_dlg.c b/gtk/capture_dlg.c
index 53bd70011e..3042bdd213 100644
--- a/gtk/capture_dlg.c
+++ b/gtk/capture_dlg.c
@@ -219,7 +219,7 @@ set_link_type_list(GtkWidget *linktype_om, GtkWidget *entry)
   data_link_info_t *data_link_info;
   gchar *linktype_menu_label;
   guint num_supported_link_types;
-  GtkWidget *linktype_lb = OBJECT_GET_DATA(linktype_om, E_CAP_LT_OM_LABEL_KEY);
+  GtkWidget *linktype_lb = g_object_get_data(G_OBJECT(linktype_om), E_CAP_LT_OM_LABEL_KEY);
   GtkWidget *if_ip_lb;
   GString *ip_str = g_string_new("IP address: ");
   int ips = 0;
@@ -242,7 +242,7 @@ set_link_type_list(GtkWidget *linktype_om, GtkWidget *entry)
 #ifdef HAVE_AIRPCAP
   /* is it an airpcap interface??? */
   /* retrieve the advanced button pointer */
-  advanced_bt = OBJECT_GET_DATA(entry,AIRPCAP_OPTIONS_ADVANCED_KEY);
+  advanced_bt = g_object_get_data(G_OBJECT(entry),AIRPCAP_OPTIONS_ADVANCED_KEY);
   airpcap_if_selected = get_airpcap_if_from_name(airpcap_if_list,if_name);
   airpcap_enable_toolbar_widgets(airpcap_tb,FALSE);
   if( airpcap_if_selected != NULL)
@@ -324,8 +324,8 @@ set_link_type_list(GtkWidget *linktype_om, GtkWidget *entry)
     data_link_info = lt_entry->data;
     if (data_link_info->description != NULL) {
       lt_menu_item = gtk_menu_item_new_with_label(data_link_info->description);
-      OBJECT_SET_DATA(lt_menu_item, E_CAP_LT_OM_KEY, linktype_om);
-      SIGNAL_CONNECT(lt_menu_item, "activate", select_link_type_cb,
+      g_object_set_data(G_OBJECT(lt_menu_item), E_CAP_LT_OM_KEY, linktype_om);
+      g_signal_connect(lt_menu_item, "activate", G_CALLBACK(select_link_type_cb),
                      GINT_TO_POINTER(data_link_info->dlt));
       num_supported_link_types++;
     } else {
@@ -346,7 +346,7 @@ set_link_type_list(GtkWidget *linktype_om, GtkWidget *entry)
   gtk_widget_set_sensitive(linktype_om, num_supported_link_types >= 2);
   /* Restore the menu to the last index used */
   gtk_option_menu_set_history(GTK_OPTION_MENU(linktype_om),linktype_history);
-  if_ip_lb = OBJECT_GET_DATA(linktype_om, E_CAP_IFACE_KEY);
+  if_ip_lb = g_object_get_data(G_OBJECT(linktype_om), E_CAP_IFACE_KEY);
   if(ips == 0) {
     g_string_append(ip_str, "unknown");
   }
@@ -380,7 +380,7 @@ static GtkWidget *time_unit_option_menu_new(guint32 value) {
 	menu=gtk_menu_new();
 	for(i=0;i<MAX_TIME_UNITS;i++){
 		menu_item=gtk_menu_item_new_with_label(time_unit_name[i]);
-		OBJECT_SET_DATA(menu_item, "time_unit", GINT_TO_POINTER(i));
+		g_object_set_data(G_OBJECT(menu_item), "time_unit", GINT_TO_POINTER(i));
 		gtk_menu_append(GTK_MENU(menu), menu_item);
 	}
 
@@ -442,7 +442,7 @@ guint32 value)
 
     menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(unit_om));
     menu_item = gtk_menu_get_active(GTK_MENU(menu));
-    unit = GPOINTER_TO_INT(OBJECT_GET_DATA(menu_item, "time_unit"));
+    unit = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu_item), "time_unit"));
 
 
     switch(unit) {
@@ -481,7 +481,7 @@ static GtkWidget *size_unit_option_menu_new(guint32 value) {
 	menu=gtk_menu_new();
 	for(i=0;i<MAX_SIZE_UNITS;i++){
 		menu_item=gtk_menu_item_new_with_label(size_unit_name[i]);
-		OBJECT_SET_DATA(menu_item, "size_unit", GINT_TO_POINTER(i));
+		g_object_set_data(G_OBJECT(menu_item), "size_unit", GINT_TO_POINTER(i));
 		gtk_menu_append(GTK_MENU(menu), menu_item);
 	}
 
@@ -533,7 +533,7 @@ guint32 value)
 
     menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(unit_om));
     menu_item = gtk_menu_get_active(GTK_MENU(menu));
-    unit = GPOINTER_TO_INT(OBJECT_GET_DATA(menu_item, "size_unit"));
+    unit = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu_item), "size_unit"));
 
 
     switch(unit) {
@@ -568,7 +568,7 @@ int *from_widget;
 
 from_widget = (gint*)g_malloc(sizeof(gint));
 *from_widget = AIRPCAP_ADVANCED_FROM_OPTIONS;
-OBJECT_SET_DATA(airpcap_tb,AIRPCAP_ADVANCED_FROM_KEY,from_widget);
+g_object_set_data(G_OBJECT(airpcap_tb),AIRPCAP_ADVANCED_FROM_KEY,from_widget);
 
 airpcap_if_active = airpcap_if_selected;
 airpcap_enable_toolbar_widgets(airpcap_tb,FALSE);
@@ -602,8 +602,8 @@ iftype_option_menu_new(capture_source value)
     for (i = 0; i < sizeof(iftype) / sizeof(iftype[0]); i++)
     {
         menu_item = gtk_menu_item_new_with_label(iftype[i].name);
-        OBJECT_SET_DATA(menu_item, E_CAP_IFTYPE_OM_KEY, iftype_om);
-        SIGNAL_CONNECT(menu_item, "activate", select_if_type_cb,
+        g_object_set_data(G_OBJECT(menu_item), E_CAP_IFTYPE_OM_KEY, iftype_om);
+        g_signal_connect(menu_item, "activate", G_CALLBACK(select_if_type_cb),
                        GINT_TO_POINTER((int)iftype[i].id));
         gtk_menu_append(GTK_MENU(menu), menu_item);
         if (value == iftype[i].id)
@@ -629,7 +629,7 @@ update_interface_list()
     if (cap_open_w == NULL)
         return;
 
-    if_cb = (GtkWidget *)OBJECT_GET_DATA(cap_open_w, E_CAP_IFACE_KEY);
+    if_cb = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
 
     if (capture_opts->src_type == CAPTURE_IFREMOTE)
         if_list = get_remote_interface_list(capture_opts->remote_host,
@@ -665,14 +665,14 @@ capture_remote_adjust_sensitivity(GtkWidget *tb _U_, gpointer parent_w)
               *passwd_lb, *passwd_te;
     gboolean  state;
 
-    auth_passwd_rb = (GtkWidget *)OBJECT_GET_DATA(parent_w,
+    auth_passwd_rb = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w),
                                                   E_REMOTE_AUTH_PASSWD_KEY);
-    username_lb = (GtkWidget *)OBJECT_GET_DATA(parent_w,
+    username_lb = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w),
                                                 E_REMOTE_USERNAME_LB_KEY);
-    username_te = (GtkWidget *)OBJECT_GET_DATA(parent_w,
+    username_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w),
                                                 E_REMOTE_USERNAME_TE_KEY);
-    passwd_lb = (GtkWidget *)OBJECT_GET_DATA(parent_w, E_REMOTE_PASSWD_LB_KEY);
-    passwd_te = (GtkWidget *)OBJECT_GET_DATA(parent_w, E_REMOTE_PASSWD_TE_KEY);
+    passwd_lb = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_REMOTE_PASSWD_LB_KEY);
+    passwd_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_REMOTE_PASSWD_TE_KEY);
 
     state =  gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(auth_passwd_rb));
     gtk_widget_set_sensitive(GTK_WIDGET(username_lb), state);
@@ -687,8 +687,8 @@ capture_remote_destroy_cb(GtkWidget *win, gpointer user_data _U_)
 {
     GtkWidget *caller;
 
-    caller = OBJECT_GET_DATA(win, E_CAP_REMOTE_CALLER_PTR_KEY);
-    OBJECT_SET_DATA(caller, E_CAP_REMOTE_DIALOG_PTR_KEY, NULL);
+    caller = g_object_get_data(G_OBJECT(win), E_CAP_REMOTE_CALLER_PTR_KEY);
+    g_object_set_data(G_OBJECT(caller), E_CAP_REMOTE_DIALOG_PTR_KEY, NULL);
 }
 
 /* user requested to accept remote interface options */
@@ -701,15 +701,15 @@ capture_remote_ok_cb(GtkWidget *win _U_, GtkWidget *remote_w)
     if (remote_w == NULL)
         return;
 
-    host_te = (GtkWidget *)OBJECT_GET_DATA(remote_w, E_REMOTE_HOST_TE_KEY);
-    port_te = (GtkWidget *)OBJECT_GET_DATA(remote_w, E_REMOTE_PORT_TE_KEY);
-    auth_pwd_rb = (GtkWidget *)OBJECT_GET_DATA(remote_w,
+    host_te = (GtkWidget *)g_object_get_data(G_OBJECT(remote_w), E_REMOTE_HOST_TE_KEY);
+    port_te = (GtkWidget *)g_object_get_data(G_OBJECT(remote_w), E_REMOTE_PORT_TE_KEY);
+    auth_pwd_rb = (GtkWidget *)g_object_get_data(G_OBJECT(remote_w),
                                                   E_REMOTE_AUTH_PASSWD_KEY);
-    username_te = (GtkWidget *)OBJECT_GET_DATA(remote_w,
+    username_te = (GtkWidget *)g_object_get_data(G_OBJECT(remote_w),
                                                 E_REMOTE_USERNAME_TE_KEY);
-    passwd_te = (GtkWidget *)OBJECT_GET_DATA(remote_w, E_REMOTE_PASSWD_TE_KEY);
-    auth_null_rb = (GtkWidget *) OBJECT_GET_DATA(remote_w, E_REMOTE_AUTH_NULL_KEY);
-    auth_passwd_rb = (GtkWidget *) OBJECT_GET_DATA(remote_w, E_REMOTE_AUTH_PASSWD_KEY);
+    passwd_te = (GtkWidget *)g_object_get_data(G_OBJECT(remote_w), E_REMOTE_PASSWD_TE_KEY);
+    auth_null_rb = (GtkWidget *) g_object_get_data(G_OBJECT(remote_w), E_REMOTE_AUTH_NULL_KEY);
+    auth_passwd_rb = (GtkWidget *) g_object_get_data(G_OBJECT(remote_w), E_REMOTE_AUTH_PASSWD_KEY);
 
     g_free(capture_opts->remote_host);
     capture_opts->remote_host = g_strdup(gtk_entry_get_text(GTK_ENTRY(host_te)));
@@ -750,7 +750,7 @@ capture_remote_cb(GtkWidget *w _U_, gpointer d _U_)
     GSList      *auth_group;
 
     caller = gtk_widget_get_toplevel(w);
-    remote_w = OBJECT_GET_DATA(caller, E_CAP_REMOTE_DIALOG_PTR_KEY);
+    remote_w = g_object_get_data(G_OBJECT(caller), E_CAP_REMOTE_DIALOG_PTR_KEY);
     if (remote_w != NULL)
     {
         reactivate_window(remote_w);
@@ -759,8 +759,8 @@ capture_remote_cb(GtkWidget *w _U_, gpointer d _U_)
 
     title = create_user_window_title("Wireshark: Remote Interface");
     remote_w = dlg_window_new(title);
-    OBJECT_SET_DATA(remote_w, E_CAP_REMOTE_CALLER_PTR_KEY, caller);
-    OBJECT_SET_DATA(caller, E_CAP_REMOTE_DIALOG_PTR_KEY, remote_w);
+    g_object_set_data(G_OBJECT(remote_w), E_CAP_REMOTE_CALLER_PTR_KEY, caller);
+    g_object_set_data(G_OBJECT(caller), E_CAP_REMOTE_DIALOG_PTR_KEY, remote_w);
     g_free(title);
 
     tooltips = gtk_tooltips_new();
@@ -815,8 +815,8 @@ capture_remote_cb(GtkWidget *w _U_, gpointer d _U_)
     auth_passwd_rb = gtk_radio_button_new_with_label(auth_group,
                                             "Password authentication");
     gtk_box_pack_start(GTK_BOX(auth_vb), auth_passwd_rb, TRUE, TRUE, 0);
-    SIGNAL_CONNECT(auth_passwd_rb, "toggled", capture_remote_adjust_sensitivity,
-                   remote_w);
+    g_signal_connect(auth_passwd_rb, "toggled",
+		   G_CALLBACK(capture_remote_adjust_sensitivity), remote_w);
 
     auth_passwd_tb = gtk_table_new(2, 2, FALSE);
     gtk_table_set_row_spacings(GTK_TABLE(auth_passwd_tb), 3);
@@ -844,30 +844,30 @@ capture_remote_cb(GtkWidget *w _U_, gpointer d _U_)
     bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, NULL);
     gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 5);
 
-    ok_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_OK);
-    SIGNAL_CONNECT(ok_bt, "clicked", capture_remote_ok_cb, remote_w);
+    ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
+    g_signal_connect(ok_bt, "clicked", G_CALLBACK(capture_remote_ok_cb), remote_w);
     gtk_tooltips_set_tip(tooltips, ok_bt,
                          "Accept remote host parameters and lookup "
                          "remote interfaces.", NULL);
 
-    cancel_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_CANCEL);
+    cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
     gtk_tooltips_set_tip(tooltips, cancel_bt,
                          "Cancel and exit dialog.", NULL);
     window_set_cancel_button(remote_w, cancel_bt, window_cancel_button_cb);
 
     gtk_widget_grab_default(ok_bt);
 
-    SIGNAL_CONNECT(remote_w, "delete_event", window_delete_event_cb, NULL);
-    SIGNAL_CONNECT(remote_w, "destroy", capture_remote_destroy_cb, NULL);
+    g_signal_connect(remote_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+    g_signal_connect(remote_w, "destroy", G_CALLBACK(capture_remote_destroy_cb), NULL);
 
-    OBJECT_SET_DATA(remote_w, E_REMOTE_HOST_TE_KEY, host_te);
-    OBJECT_SET_DATA(remote_w, E_REMOTE_PORT_TE_KEY, port_te);
-    OBJECT_SET_DATA(remote_w, E_REMOTE_AUTH_NULL_KEY, auth_null_rb);
-    OBJECT_SET_DATA(remote_w, E_REMOTE_AUTH_PASSWD_KEY, auth_passwd_rb);
-    OBJECT_SET_DATA(remote_w, E_REMOTE_USERNAME_LB_KEY, user_lb);
-    OBJECT_SET_DATA(remote_w, E_REMOTE_USERNAME_TE_KEY, user_te);
-    OBJECT_SET_DATA(remote_w, E_REMOTE_PASSWD_LB_KEY, passwd_lb);
-    OBJECT_SET_DATA(remote_w, E_REMOTE_PASSWD_TE_KEY, passwd_te);
+    g_object_set_data(G_OBJECT(remote_w), E_REMOTE_HOST_TE_KEY, host_te);
+    g_object_set_data(G_OBJECT(remote_w), E_REMOTE_PORT_TE_KEY, port_te);
+    g_object_set_data(G_OBJECT(remote_w), E_REMOTE_AUTH_NULL_KEY, auth_null_rb);
+    g_object_set_data(G_OBJECT(remote_w), E_REMOTE_AUTH_PASSWD_KEY, auth_passwd_rb);
+    g_object_set_data(G_OBJECT(remote_w), E_REMOTE_USERNAME_LB_KEY, user_lb);
+    g_object_set_data(G_OBJECT(remote_w), E_REMOTE_USERNAME_TE_KEY, user_te);
+    g_object_set_data(G_OBJECT(remote_w), E_REMOTE_PASSWD_LB_KEY, passwd_lb);
+    g_object_set_data(G_OBJECT(remote_w), E_REMOTE_PASSWD_TE_KEY, passwd_te);
 
     if (capture_opts->auth_type == CAPTURE_AUTH_PWD)
         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(auth_passwd_rb), TRUE);
@@ -989,7 +989,7 @@ 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 = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_DECRYPTION_KEY);
+  decryption_cm = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY);
   update_decryption_mode_list(decryption_cm);
 
   if (airpcap_if_list == NULL && err == CANT_GET_AIRPCAP_INTERFACE_LIST) {
@@ -1092,11 +1092,11 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   gtk_box_pack_start(GTK_BOX(linktype_hb), linktype_lb, FALSE, FALSE, 6);
 
   linktype_om = gtk_option_menu_new();
-  OBJECT_SET_DATA(linktype_om, E_CAP_LT_OM_LABEL_KEY, linktype_lb);
+  g_object_set_data(G_OBJECT(linktype_om), E_CAP_LT_OM_LABEL_KEY, linktype_lb);
   /* Default to "use the default" */
   /* Datalink menu index is not resetted, it will be restored with last used value */
-  /* OBJECT_SET_DATA(linktype_om, E_CAP_OM_LT_VALUE_KEY, GINT_TO_POINTER(-1)); */
-  OBJECT_SET_DATA(linktype_om, E_CAP_IFACE_KEY, if_ip_lb);
+  /* g_object_set_data(G_OBJECT(linktype_om), E_CAP_OM_LT_VALUE_KEY, GINT_TO_POINTER(-1)); */
+  g_object_set_data(G_OBJECT(linktype_om), E_CAP_IFACE_KEY, if_ip_lb);
   dl_hdr_menu=NULL;
   set_link_type_list(linktype_om, GTK_COMBO(if_cb)->entry);
   /*
@@ -1117,8 +1117,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   gtk_tooltips_set_tip(tooltips, linktype_om,
     "The selected interface supports multiple link-layer types; select the desired one.", NULL);
   gtk_box_pack_start (GTK_BOX(linktype_hb), linktype_om, FALSE, FALSE, 0);
-  SIGNAL_CONNECT(GTK_ENTRY(GTK_COMBO(if_cb)->entry), "changed",
-                 capture_prep_interface_changed_cb, linktype_om);
+  g_signal_connect(GTK_ENTRY(GTK_COMBO(if_cb)->entry), "changed",
+                 G_CALLBACK(capture_prep_interface_changed_cb), linktype_om);
 
 #ifdef _WIN32
   buffer_size_lb = gtk_label_new("Buffer size:");
@@ -1129,7 +1129,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   buffer_size_sb = gtk_spin_button_new (buffer_size_adj, 0, 0);
   gtk_spin_button_set_value(GTK_SPIN_BUTTON (buffer_size_sb), (gfloat) capture_opts->buffer_size);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (buffer_size_sb), TRUE);
-  WIDGET_SET_SIZE(buffer_size_sb, 80, -1);
+  gtk_widget_set_size_request(buffer_size_sb, 80, -1);
   gtk_tooltips_set_tip(tooltips, buffer_size_sb,
     "The memory buffer size used while capturing. If you notice packet drops, you can try to increase this size.", NULL);
   gtk_box_pack_start (GTK_BOX(linktype_hb), buffer_size_sb, FALSE, FALSE, 0);
@@ -1139,8 +1139,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
 #endif
 
   /* Promiscuous mode row */
-  promisc_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
-      "Capture packets in _promiscuous mode", accel_group);
+  promisc_cb = gtk_check_button_new_with_mnemonic(
+      "Capture packets in _promiscuous mode");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(promisc_cb),
 		capture_opts->promisc_mode);
   gtk_tooltips_set_tip(tooltips, promisc_cb,
@@ -1151,14 +1151,14 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
 
 #ifdef HAVE_PCAP_REMOTE
   /* RPCAP-related flags */
-  nocap_rpcap_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
-      "Do not capture RPCAP own traffic", accel_group);
+  nocap_rpcap_cb = gtk_check_button_new_with_mnemonic(
+      "Do not capture RPCAP own traffic");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(nocap_rpcap_cb),
           capture_opts->nocap_rpcap);
   gtk_container_add(GTK_CONTAINER(capture_vb), nocap_rpcap_cb);
 
-  datatx_udp_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
-      "Use UDP for RPCAP data transfer", accel_group);
+  datatx_udp_cb = gtk_check_button_new_with_mnemonic(
+      "Use UDP for RPCAP data transfer");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(datatx_udp_cb),
           capture_opts->datatx_udp);
   gtk_container_add(GTK_CONTAINER(capture_vb), datatx_udp_cb);
@@ -1168,10 +1168,10 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   snap_hb = gtk_hbox_new(FALSE, 3);
   gtk_container_add(GTK_CONTAINER(capture_vb), snap_hb);
 
-  snap_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC("_Limit each packet to", accel_group);
+  snap_cb = gtk_check_button_new_with_mnemonic("_Limit each packet to");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(snap_cb),
 		capture_opts->has_snaplen);
-  SIGNAL_CONNECT(snap_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
+  g_signal_connect(snap_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_tooltips_set_tip(tooltips, snap_cb,
     "Limit the maximum number of bytes to be captured from each packet. This size includes the "
     "link-layer header and all subsequent headers. ", NULL);
@@ -1181,7 +1181,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
     MIN_PACKET_SIZE, WTAP_MAX_PACKET_SIZE, 1.0, 10.0, 0.0);
   snap_sb = gtk_spin_button_new (snap_adj, 0, 0);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (snap_sb), TRUE);
-  WIDGET_SET_SIZE(snap_sb, 80, -1);
+  gtk_widget_set_size_request(snap_sb, 80, -1);
   gtk_box_pack_start (GTK_BOX(snap_hb), snap_sb, FALSE, FALSE, 0);
 
   snap_lb = gtk_label_new("bytes");
@@ -1192,9 +1192,9 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   filter_hb = gtk_hbox_new(FALSE, 3);
   gtk_box_pack_start(GTK_BOX(capture_vb), filter_hb, FALSE, FALSE, 0);
 
-  filter_bt = BUTTON_NEW_FROM_STOCK(WIRESHARK_STOCK_CAPTURE_FILTER_ENTRY);
-  SIGNAL_CONNECT(filter_bt, "clicked", capture_filter_construct_cb, NULL);
-  SIGNAL_CONNECT(filter_bt, "destroy", filter_button_destroy_cb, NULL);
+  filter_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_CAPTURE_FILTER_ENTRY);
+  g_signal_connect(filter_bt, "clicked", G_CALLBACK(capture_filter_construct_cb), NULL);
+  g_signal_connect(filter_bt, "destroy", G_CALLBACK(filter_button_destroy_cb), NULL);
   gtk_tooltips_set_tip(tooltips, filter_bt,
     "Select a capture filter to reduce the amount of packets to be captured. "
     "See \"Capture Filters\" in the online help for further information how to use it.",
@@ -1204,11 +1204,11 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   /* Create the capture filter combo */
   filter_cm = gtk_combo_new();
 
-  cfilter_list = OBJECT_GET_DATA(top_level, E_CFILTER_FL_KEY);
+  cfilter_list = g_object_get_data(G_OBJECT(top_level), E_CFILTER_FL_KEY);
   gtk_combo_disable_activate(GTK_COMBO(filter_cm));
   gtk_combo_set_case_sensitive(GTK_COMBO(filter_cm), TRUE);
-  OBJECT_SET_DATA(top_level, E_CFILTER_FL_KEY, cfilter_list);
-  OBJECT_SET_DATA(top_level, E_CFILTER_CM_KEY, filter_cm);
+  g_object_set_data(G_OBJECT(top_level), E_CFILTER_FL_KEY, cfilter_list);
+  g_object_set_data(G_OBJECT(top_level), E_CFILTER_CM_KEY, filter_cm);
   filter_te = GTK_COMBO(filter_cm)->entry;
 
   if (cfilter_list != NULL)
@@ -1219,7 +1219,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
     "Enter a capture filter to reduce the amount of packets to be captured. "
     "See \"Capture Filters\" in the online help for further information how to use it.",
     NULL);
-  WIDGET_SET_SIZE(filter_cm, 400, -1);
+  gtk_widget_set_size_request(filter_cm, 400, -1);
   gtk_box_pack_start(GTK_BOX(filter_hb), filter_cm, FALSE, FALSE, 3);
   main_hb = gtk_hbox_new(FALSE, 5);
   gtk_container_border_width(GTK_CONTAINER(main_hb), 0);
@@ -1234,7 +1234,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   gtk_box_pack_start(GTK_BOX(main_hb), right_vb, FALSE, FALSE, 0);
 
   /* let an eventually capture filters dialog know the text entry to fill in */
-  OBJECT_SET_DATA(filter_bt, E_FILT_TE_PTR_KEY, filter_te);
+  g_object_set_data(G_OBJECT(filter_bt), E_FILT_TE_PTR_KEY, filter_te);
 
   /* advanced row */
 #ifdef HAVE_AIRPCAP
@@ -1248,8 +1248,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   gtk_button_set_label(GTK_BUTTON(advanced_bt), "Wireless Settings");
 
   /* Both the callback and the data are global */
-  SIGNAL_CONNECT(advanced_bt,"clicked",options_airpcap_advanced_cb,airpcap_tb);
-  OBJECT_SET_DATA(GTK_ENTRY(GTK_COMBO(if_cb)->entry),AIRPCAP_OPTIONS_ADVANCED_KEY,advanced_bt);
+  g_signal_connect(advanced_bt,"clicked", G_CALLBACK(options_airpcap_advanced_cb),airpcap_tb);
+  g_object_set_data(G_OBJECT(GTK_ENTRY(GTK_COMBO(if_cb)->entry)),AIRPCAP_OPTIONS_ADVANCED_KEY,advanced_bt);
 
   if(airpcap_if_selected != NULL)
 	{
@@ -1288,14 +1288,14 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
     NULL);
   gtk_box_pack_start(GTK_BOX(file_hb), file_te, TRUE, TRUE, 3);
 
-  file_bt = BUTTON_NEW_FROM_STOCK(WIRESHARK_STOCK_BROWSE);
+  file_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_BROWSE);
   gtk_tooltips_set_tip(tooltips, file_bt,
     "Select a file to which captured data will be written, "
     "instead of entering the file name directly. ",
     NULL);
   gtk_box_pack_start(GTK_BOX(file_hb), file_bt, FALSE, FALSE, 3);
 
-  SIGNAL_CONNECT(file_bt, "clicked", capture_prep_file_cb, file_te);
+  g_signal_connect(file_bt, "clicked", G_CALLBACK(capture_prep_file_cb), file_te);
 
   /* multiple files table */
   multi_tb = gtk_table_new(5, 3, FALSE);
@@ -1305,10 +1305,10 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   row = 0;
 
   /* multiple files row */
-  multi_files_on_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC("Use _multiple files", accel_group);
+  multi_files_on_cb = gtk_check_button_new_with_mnemonic("Use _multiple files");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(multi_files_on_cb),
 		capture_opts->multi_files_on);
-  SIGNAL_CONNECT(multi_files_on_cb, "toggled", capture_prep_adjust_sensitivity,
+  g_signal_connect(multi_files_on_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity),
                  cap_open_w);
   gtk_tooltips_set_tip(tooltips, multi_files_on_cb,
     "Instead of using a single capture file, multiple files will be created. "
@@ -1320,7 +1320,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   ring_filesize_cb = gtk_check_button_new_with_label("Next file every");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(ring_filesize_cb),
 		capture_opts->has_autostop_filesize);
-  SIGNAL_CONNECT(ring_filesize_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
+  g_signal_connect(ring_filesize_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_tooltips_set_tip(tooltips, ring_filesize_cb,
     "If the selected file size is exceeded, capturing switches to the next file.\n"
     "PLEASE NOTE: at least one of the \"Next file every\" options MUST be selected.",
@@ -1331,7 +1331,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
     1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
   ring_filesize_sb = gtk_spin_button_new (ring_filesize_adj, 0, 0);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (ring_filesize_sb), TRUE);
-  WIDGET_SET_SIZE(ring_filesize_sb, 80, -1);
+  gtk_widget_set_size_request(ring_filesize_sb, 80, -1);
   gtk_table_attach_defaults(GTK_TABLE(multi_tb), ring_filesize_sb, 1, 2, row, row+1);
 
   ring_filesize_om = size_unit_option_menu_new(capture_opts->autostop_filesize);
@@ -1346,8 +1346,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   file_duration_cb = gtk_check_button_new_with_label("Next file every");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(file_duration_cb),
 			      capture_opts->has_file_duration);
-  SIGNAL_CONNECT(file_duration_cb, "toggled",
-		 capture_prep_adjust_sensitivity, cap_open_w);
+  g_signal_connect(file_duration_cb, "toggled",
+		 G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_tooltips_set_tip(tooltips, file_duration_cb,
     "If the selected duration is exceeded, capturing switches to the next file.\n"
     "PLEASE NOTE: at least one of the \"Next file every\" options MUST be selected.",
@@ -1358,7 +1358,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
     1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
   file_duration_sb = gtk_spin_button_new (file_duration_adj, 0, 0);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (file_duration_sb), TRUE);
-  WIDGET_SET_SIZE(file_duration_sb, 80, -1);
+  gtk_widget_set_size_request(file_duration_sb, 80, -1);
   gtk_table_attach_defaults(GTK_TABLE(multi_tb), file_duration_sb, 1, 2, row, row+1);
 
   file_duration_om = time_unit_option_menu_new(capture_opts->file_duration);
@@ -1372,7 +1372,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   ringbuffer_nbf_cb = gtk_check_button_new_with_label("Ring buffer with");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(ringbuffer_nbf_cb),
 		capture_opts->has_ring_num_files);
-  SIGNAL_CONNECT(ringbuffer_nbf_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
+  g_signal_connect(ringbuffer_nbf_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_tooltips_set_tip(tooltips, ringbuffer_nbf_cb,
     "After capturing has switched to the next file and the given number of files has exceeded, "
     "the oldest file will be removed.",
@@ -1383,8 +1383,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
     2/*RINGBUFFER_MIN_NUM_FILES*/, RINGBUFFER_MAX_NUM_FILES, 1.0, 10.0, 0.0);
   ringbuffer_nbf_sb = gtk_spin_button_new (ringbuffer_nbf_adj, 0, 0);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (ringbuffer_nbf_sb), TRUE);
-  WIDGET_SET_SIZE(ringbuffer_nbf_sb, 80, -1);
-  SIGNAL_CONNECT(ringbuffer_nbf_sb, "changed", capture_prep_adjust_sensitivity, cap_open_w);
+  gtk_widget_set_size_request(ringbuffer_nbf_sb, 80, -1);
+  g_signal_connect(ringbuffer_nbf_sb, "changed", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_table_attach_defaults(GTK_TABLE(multi_tb), ringbuffer_nbf_sb, 1, 2, row, row+1);
 
   ringbuffer_nbf_lb = gtk_label_new("files");
@@ -1396,7 +1396,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   stop_files_cb = gtk_check_button_new_with_label("Stop capture after");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(stop_files_cb),
 		capture_opts->has_autostop_files);
-  SIGNAL_CONNECT(stop_files_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
+  g_signal_connect(stop_files_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_tooltips_set_tip(tooltips, stop_files_cb,
     "Stop capturing after the given number of \"file switches\" have been done.", NULL);
   gtk_table_attach_defaults(GTK_TABLE(multi_tb), stop_files_cb, 0, 1, row, row+1);
@@ -1405,7 +1405,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
     1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
   stop_files_sb = gtk_spin_button_new (stop_files_adj, 0, 0);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_files_sb), TRUE);
-  WIDGET_SET_SIZE(stop_files_sb, 80, -1);
+  gtk_widget_set_size_request(stop_files_sb, 80, -1);
   gtk_table_attach_defaults(GTK_TABLE(multi_tb), stop_files_sb, 1, 2, row, row+1);
 
   stop_files_lb = gtk_label_new("file(s)");
@@ -1432,7 +1432,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   stop_packets_cb = gtk_check_button_new_with_label("... after");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(stop_packets_cb),
 		capture_opts->has_autostop_packets);
-  SIGNAL_CONNECT(stop_packets_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
+  g_signal_connect(stop_packets_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_tooltips_set_tip(tooltips, stop_packets_cb,
     "Stop capturing after the given number of packets have been captured.", NULL);
   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_packets_cb, 0, 1, row, row+1);
@@ -1441,7 +1441,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
     1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
   stop_packets_sb = gtk_spin_button_new (stop_packets_adj, 0, 0);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_packets_sb), TRUE);
-  WIDGET_SET_SIZE(stop_packets_sb, 80, -1);
+  gtk_widget_set_size_request(stop_packets_sb, 80, -1);
   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_packets_sb, 1, 2, row, row+1);
 
   stop_packets_lb = gtk_label_new("packet(s)");
@@ -1453,7 +1453,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   stop_filesize_cb = gtk_check_button_new_with_label("... after");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(stop_filesize_cb),
 		capture_opts->has_autostop_filesize);
-  SIGNAL_CONNECT(stop_filesize_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
+  g_signal_connect(stop_filesize_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_tooltips_set_tip(tooltips, stop_filesize_cb,
     "Stop capturing after the given amount of capture data has been captured.", NULL);
   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_filesize_cb, 0, 1, row, row+1);
@@ -1462,7 +1462,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
     1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
   stop_filesize_sb = gtk_spin_button_new (stop_filesize_adj, 0, 0);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_filesize_sb), TRUE);
-  WIDGET_SET_SIZE(stop_filesize_sb, 80, -1);
+  gtk_widget_set_size_request(stop_filesize_sb, 80, -1);
   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_filesize_sb, 1, 2, row, row+1);
 
   stop_filesize_om = size_unit_option_menu_new(capture_opts->autostop_filesize);
@@ -1477,7 +1477,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   stop_duration_cb = gtk_check_button_new_with_label("... after");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(stop_duration_cb),
 		capture_opts->has_autostop_duration);
-  SIGNAL_CONNECT(stop_duration_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
+  g_signal_connect(stop_duration_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_tooltips_set_tip(tooltips, stop_duration_cb,
     "Stop capturing after the given time is exceeded.", NULL);
   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_duration_cb, 0, 1, row, row+1);
@@ -1486,7 +1486,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
     1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
   stop_duration_sb = gtk_spin_button_new (stop_duration_adj, 0, 0);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_duration_sb), TRUE);
-  WIDGET_SET_SIZE(stop_duration_sb, 80, -1);
+  gtk_widget_set_size_request(stop_duration_sb, 80, -1);
   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_duration_sb, 1, 2, row, row+1);
 
   stop_duration_om = time_unit_option_menu_new(capture_opts->autostop_duration);
@@ -1514,8 +1514,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   samp_none_rb = gtk_radio_button_new_with_label(NULL, "None");
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(samp_none_rb),
                      (capture_opts->sampling_method == CAPTURE_SAMP_NONE));
-  SIGNAL_CONNECT(samp_none_rb, "toggled",
-                 capture_prep_adjust_sensitivity, cap_open_w);
+  g_signal_connect(samp_none_rb, "toggled",
+                 G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_table_attach_defaults(GTK_TABLE(sampling_tb), samp_none_rb, 0, 1, 0, 1);
 
   /* "Sampling by counter" row */
@@ -1523,8 +1523,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   samp_count_rb = gtk_radio_button_new_with_label(samp_group, "1 of");
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(samp_none_rb),
                      (capture_opts->sampling_method == CAPTURE_SAMP_BY_COUNT));
-  SIGNAL_CONNECT(samp_count_rb, "toggled",
-                 capture_prep_adjust_sensitivity, cap_open_w);
+  g_signal_connect(samp_count_rb, "toggled",
+                 G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_table_attach_defaults(GTK_TABLE(sampling_tb), samp_count_rb, 0, 1, 1, 2);
 
   samp_count_adj = (GtkAdjustment *) gtk_adjustment_new(
@@ -1543,8 +1543,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   samp_timer_rb = gtk_radio_button_new_with_label(samp_group, "1 every");
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(samp_none_rb),
                      (capture_opts->sampling_method == CAPTURE_SAMP_BY_TIMER));
-  SIGNAL_CONNECT(samp_timer_rb, "toggled",
-                 capture_prep_adjust_sensitivity, cap_open_w);
+  g_signal_connect(samp_timer_rb, "toggled",
+                 G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_table_attach_defaults(GTK_TABLE(sampling_tb), samp_timer_rb, 0, 1, 2, 3);
 
   samp_timer_adj = (GtkAdjustment *) gtk_adjustment_new(
@@ -1568,19 +1568,19 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   gtk_container_add(GTK_CONTAINER(display_fr), display_vb);
 
   /* "Update display in real time" row */
-  sync_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
-      "_Update list of packets in real time", accel_group);
+  sync_cb = gtk_check_button_new_with_mnemonic(
+      "_Update list of packets in real time");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sync_cb),
 		capture_opts->real_time_mode);
-  SIGNAL_CONNECT(sync_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
+  g_signal_connect(sync_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
   gtk_tooltips_set_tip(tooltips, sync_cb,
     "Using this option will show the captured packets immediately on the main screen. "
     "Please note: this will slow down capturing, so increased packet drops might appear.", NULL);
   gtk_container_add(GTK_CONTAINER(display_vb), sync_cb);
 
   /* "Auto-scroll live update" row */
-  auto_scroll_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
-		"_Automatic scrolling in live capture", accel_group);
+  auto_scroll_cb = gtk_check_button_new_with_mnemonic(
+		"_Automatic scrolling in live capture");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(auto_scroll_cb), auto_scroll_live);
   gtk_tooltips_set_tip(tooltips, auto_scroll_cb,
     "This will scroll the \"Packet List\" automatically to the latest captured packet, "
@@ -1588,8 +1588,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   gtk_container_add(GTK_CONTAINER(display_vb), auto_scroll_cb);
 
   /* "Hide capture info" row */
-  hide_info_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
-		"_Hide capture info dialog", accel_group);
+  hide_info_cb = gtk_check_button_new_with_mnemonic(
+		"_Hide capture info dialog");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(hide_info_cb), !capture_opts->show_info);
   gtk_tooltips_set_tip(tooltips, hide_info_cb,
     "Hide the capture info dialog while capturing.", NULL);
@@ -1603,24 +1603,24 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   gtk_container_border_width(GTK_CONTAINER(resolv_vb), 5);
   gtk_container_add(GTK_CONTAINER(resolv_fr), resolv_vb);
 
-  m_resolv_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
-		"Enable _MAC name resolution", accel_group);
+  m_resolv_cb = gtk_check_button_new_with_mnemonic(
+		"Enable _MAC name resolution");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(m_resolv_cb),
 		g_resolv_flags & RESOLV_MAC);
   gtk_tooltips_set_tip(tooltips, m_resolv_cb,
     "Perform MAC layer name resolution while capturing.", NULL);
   gtk_container_add(GTK_CONTAINER(resolv_vb), m_resolv_cb);
 
-  n_resolv_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
-		"Enable _network name resolution", accel_group);
+  n_resolv_cb = gtk_check_button_new_with_mnemonic(
+		"Enable _network name resolution");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(n_resolv_cb),
 		g_resolv_flags & RESOLV_NETWORK);
   gtk_tooltips_set_tip(tooltips, n_resolv_cb,
     "Perform network layer name resolution while capturing.", NULL);
   gtk_container_add(GTK_CONTAINER(resolv_vb), n_resolv_cb);
 
-  t_resolv_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
-		"Enable _transport name resolution", accel_group);
+  t_resolv_cb = gtk_check_button_new_with_mnemonic(
+		"Enable _transport name resolution");
   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(t_resolv_cb),
 		g_resolv_flags & RESOLV_TRANSPORT);
   gtk_tooltips_set_tip(tooltips, t_resolv_cb,
@@ -1631,74 +1631,74 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   bbox = dlg_button_row_new(WIRESHARK_STOCK_CAPTURE_START, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL);
   gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 5);
 
-  ok_bt = OBJECT_GET_DATA(bbox, WIRESHARK_STOCK_CAPTURE_START);
-  SIGNAL_CONNECT(ok_bt, "clicked", capture_start_cb, cap_open_w);
+  ok_bt = g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_CAPTURE_START);
+  g_signal_connect(ok_bt, "clicked", G_CALLBACK(capture_start_cb), cap_open_w);
   gtk_tooltips_set_tip(tooltips, ok_bt,
     "Start the capture process.", NULL);
 
-  cancel_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_CANCEL);
+  cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
   gtk_tooltips_set_tip(tooltips, cancel_bt,
     "Cancel and exit dialog.", NULL);
   window_set_cancel_button(cap_open_w, cancel_bt, window_cancel_button_cb);
 
-  help_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_HELP);
+  help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
   gtk_tooltips_set_tip(tooltips, help_bt,
     "Show help about capturing.", NULL);
-  SIGNAL_CONNECT(help_bt, "clicked", topic_cb, HELP_CAPTURE_OPTIONS_DIALOG);
+  g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_CAPTURE_OPTIONS_DIALOG);
 
   gtk_widget_grab_default(ok_bt);
 
   /* Attach pointers to needed widgets to the capture prefs window/object */
-  OBJECT_SET_DATA(cap_open_w, E_CAP_IFACE_KEY, if_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY, if_cb);
 #ifdef HAVE_PCAP_REMOTE
-  OBJECT_SET_DATA(cap_open_w, E_CAP_IFTYPE_OM_KEY, iftype_om);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_REMOTE_DIALOG_PTR_KEY, NULL);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_NOCAP_RPCAP_CB_KEY, nocap_rpcap_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_DATATX_UDP_CB_KEY, datatx_udp_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_IFTYPE_OM_KEY, iftype_om);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_REMOTE_DIALOG_PTR_KEY, NULL);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_NOCAP_RPCAP_CB_KEY, nocap_rpcap_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_DATATX_UDP_CB_KEY, datatx_udp_cb);
 #endif
-  OBJECT_SET_DATA(cap_open_w, E_CAP_SNAP_CB_KEY, snap_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_SNAP_SB_KEY, snap_sb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_LT_OM_KEY, linktype_om);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_SNAP_CB_KEY, snap_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_SNAP_SB_KEY, snap_sb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_LT_OM_KEY, linktype_om);
 #ifdef _WIN32
-  OBJECT_SET_DATA(cap_open_w, E_CAP_BUFFER_SIZE_SB_KEY, buffer_size_sb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_BUFFER_SIZE_SB_KEY, buffer_size_sb);
 #endif
-  OBJECT_SET_DATA(cap_open_w, E_CAP_PROMISC_KEY, promisc_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_FILT_KEY,  filter_te);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_FILE_TE_KEY,  file_te);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_MULTI_FILES_ON_CB_KEY,  multi_files_on_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_RING_NBF_CB_KEY,  ringbuffer_nbf_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_RING_NBF_SB_KEY,  ringbuffer_nbf_sb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_RING_NBF_LB_KEY,  ringbuffer_nbf_lb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_RING_FILESIZE_CB_KEY,  ring_filesize_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_RING_FILESIZE_SB_KEY,  ring_filesize_sb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_RING_FILESIZE_OM_KEY,  ring_filesize_om);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_FILE_DURATION_CB_KEY,  file_duration_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_FILE_DURATION_SB_KEY,  file_duration_sb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_FILE_DURATION_OM_KEY,  file_duration_om);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_SYNC_KEY,  sync_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_AUTO_SCROLL_KEY, auto_scroll_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_HIDE_INFO_KEY, hide_info_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_PACKETS_CB_KEY, stop_packets_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_PACKETS_SB_KEY, stop_packets_sb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_PACKETS_LB_KEY, stop_packets_lb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_FILESIZE_CB_KEY, stop_filesize_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_FILESIZE_SB_KEY, stop_filesize_sb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_FILESIZE_OM_KEY, stop_filesize_om);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_DURATION_CB_KEY,  stop_duration_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_DURATION_SB_KEY,  stop_duration_sb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_DURATION_OM_KEY,  stop_duration_om);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_FILES_CB_KEY, stop_files_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_FILES_SB_KEY, stop_files_sb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_FILES_LB_KEY, stop_files_lb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_M_RESOLVE_KEY,  m_resolv_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_N_RESOLVE_KEY,  n_resolv_cb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_T_RESOLVE_KEY,  t_resolv_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_PROMISC_KEY, promisc_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_FILT_KEY,  filter_te);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_FILE_TE_KEY,  file_te);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_MULTI_FILES_ON_CB_KEY,  multi_files_on_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_RING_NBF_CB_KEY,  ringbuffer_nbf_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_RING_NBF_SB_KEY,  ringbuffer_nbf_sb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_RING_NBF_LB_KEY,  ringbuffer_nbf_lb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_RING_FILESIZE_CB_KEY,  ring_filesize_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_RING_FILESIZE_SB_KEY,  ring_filesize_sb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_RING_FILESIZE_OM_KEY,  ring_filesize_om);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_FILE_DURATION_CB_KEY,  file_duration_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_FILE_DURATION_SB_KEY,  file_duration_sb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_FILE_DURATION_OM_KEY,  file_duration_om);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_SYNC_KEY,  sync_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_AUTO_SCROLL_KEY, auto_scroll_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_HIDE_INFO_KEY, hide_info_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_PACKETS_CB_KEY, stop_packets_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_PACKETS_SB_KEY, stop_packets_sb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_PACKETS_LB_KEY, stop_packets_lb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_FILESIZE_CB_KEY, stop_filesize_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_FILESIZE_SB_KEY, stop_filesize_sb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_FILESIZE_OM_KEY, stop_filesize_om);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_DURATION_CB_KEY,  stop_duration_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_DURATION_SB_KEY,  stop_duration_sb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_DURATION_OM_KEY,  stop_duration_om);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_FILES_CB_KEY, stop_files_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_FILES_SB_KEY, stop_files_sb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_FILES_LB_KEY, stop_files_lb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_M_RESOLVE_KEY,  m_resolv_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_N_RESOLVE_KEY,  n_resolv_cb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_T_RESOLVE_KEY,  t_resolv_cb);
 #ifdef HAVE_PCAP_SETSAMPLING
-  OBJECT_SET_DATA(cap_open_w, E_CAP_SAMP_NONE_RB_KEY, samp_none_rb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_SAMP_COUNT_RB_KEY, samp_count_rb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_SAMP_COUNT_SB_KEY, samp_count_sb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_SAMP_TIMER_RB_KEY, samp_timer_rb);
-  OBJECT_SET_DATA(cap_open_w, E_CAP_SAMP_TIMER_SB_KEY, samp_timer_sb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_SAMP_NONE_RB_KEY, samp_none_rb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_SAMP_COUNT_RB_KEY, samp_count_rb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_SAMP_COUNT_SB_KEY, samp_count_sb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_SAMP_TIMER_RB_KEY, samp_timer_rb);
+  g_object_set_data(G_OBJECT(cap_open_w), E_CAP_SAMP_TIMER_SB_KEY, samp_timer_sb);
 #endif
 
   /* Set the sensitivity of various widgets as per the settings of other
@@ -1736,8 +1736,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
     in it; and it now appears that you simply *can't* make a combo box
     get the initial focus, at least not in the obvious fashion. Sigh.... */
 
-  SIGNAL_CONNECT(cap_open_w, "delete_event", window_delete_event_cb, NULL);
-  SIGNAL_CONNECT(cap_open_w, "destroy", capture_prep_destroy_cb, NULL);
+  g_signal_connect(cap_open_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
+  g_signal_connect(cap_open_w, "destroy", G_CALLBACK(capture_prep_destroy_cb), NULL);
 
   /* Give the initial focus to the "Filter" entry box. */
   gtk_widget_grab_focus(filter_te);
@@ -1853,14 +1853,14 @@ static void
 select_link_type_cb(GtkWidget *w, gpointer data)
 {
   int new_linktype = GPOINTER_TO_INT(data);
-  GtkWidget *linktype_om = OBJECT_GET_DATA(w, E_CAP_LT_OM_KEY);
-  int old_linktype = GPOINTER_TO_INT(OBJECT_GET_DATA(linktype_om, E_CAP_OM_LT_VALUE_KEY));
+  GtkWidget *linktype_om = g_object_get_data(G_OBJECT(w), E_CAP_LT_OM_KEY);
+  int old_linktype = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(linktype_om), E_CAP_OM_LT_VALUE_KEY));
 
   /* If the link is changed, update the menu and store the index and the value
      to reuse later when the dialog window will be reopened */
   if (old_linktype != new_linktype) {
-    OBJECT_SET_DATA(linktype_om, E_CAP_OM_LT_VALUE_KEY, GINT_TO_POINTER(new_linktype));
-    capture_opts->linktype = GPOINTER_TO_INT(OBJECT_GET_DATA(linktype_om, E_CAP_OM_LT_VALUE_KEY));
+    g_object_set_data(G_OBJECT(linktype_om), E_CAP_OM_LT_VALUE_KEY, GINT_TO_POINTER(new_linktype));
+    capture_opts->linktype = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(linktype_om), E_CAP_OM_LT_VALUE_KEY));
     linktype_history=MAX(gtk_option_menu_get_history(GTK_OPTION_MENU(linktype_om)), 0);
 
   }
@@ -1872,13 +1872,13 @@ static void
 select_if_type_cb(GtkWidget *w, gpointer data)
 {
     int new_iftype = GPOINTER_TO_INT(data);
-    GtkWidget *iftype_om = OBJECT_GET_DATA(w, E_CAP_IFTYPE_OM_KEY);
-    int old_iftype = GPOINTER_TO_INT(OBJECT_GET_DATA(iftype_om,
+    GtkWidget *iftype_om = g_object_get_data(G_OBJECT(w), E_CAP_IFTYPE_OM_KEY);
+    int old_iftype = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(iftype_om),
                                             E_CAP_OM_IFTYPE_VALUE_KEY));
 
     if (old_iftype != new_iftype)
     {
-        OBJECT_SET_DATA(iftype_om, E_CAP_OM_IFTYPE_VALUE_KEY,
+        g_object_set_data(G_OBJECT(iftype_om), E_CAP_OM_IFTYPE_VALUE_KEY,
                         GINT_TO_POINTER(new_iftype));
     }
     if (new_iftype == CAPTURE_IFREMOTE)
@@ -1933,53 +1933,53 @@ capture_dlg_prep(gpointer parent_w) {
   gchar *dirname;
   gint32 tmp;
 
-  if_cb     = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_IFACE_KEY);
+  if_cb     = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_IFACE_KEY);
 #ifdef HAVE_PCAP_REMOTE
-  iftype_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_IFTYPE_OM_KEY);
-  datatx_udp_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_DATATX_UDP_CB_KEY);
-  nocap_rpcap_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_NOCAP_RPCAP_CB_KEY);
+  iftype_om = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_IFTYPE_OM_KEY);
+  datatx_udp_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_DATATX_UDP_CB_KEY);
+  nocap_rpcap_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_NOCAP_RPCAP_CB_KEY);
 #endif
-  snap_cb   = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SNAP_CB_KEY);
-  snap_sb   = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SNAP_SB_KEY);
-  linktype_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_LT_OM_KEY);
+  snap_cb   = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SNAP_CB_KEY);
+  snap_sb   = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SNAP_SB_KEY);
+  linktype_om = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_LT_OM_KEY);
 #ifdef _WIN32
-  buffer_size_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_BUFFER_SIZE_SB_KEY);
+  buffer_size_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_BUFFER_SIZE_SB_KEY);
 #endif
-  promisc_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_PROMISC_KEY);
-  filter_cm = OBJECT_GET_DATA(top_level, E_CFILTER_CM_KEY);
+  promisc_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_PROMISC_KEY);
+  filter_cm = g_object_get_data(G_OBJECT(top_level), E_CFILTER_CM_KEY);
   filter_te = GTK_COMBO(filter_cm)->entry;
-  file_te   = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_TE_KEY);
-  multi_files_on_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_MULTI_FILES_ON_CB_KEY);
-  ringbuffer_nbf_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_NBF_CB_KEY);
-  ringbuffer_nbf_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_NBF_SB_KEY);
-  ring_filesize_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_FILESIZE_CB_KEY);
-  ring_filesize_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_FILESIZE_SB_KEY);
-  ring_filesize_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_FILESIZE_OM_KEY);
-  file_duration_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_DURATION_CB_KEY);
-  file_duration_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_DURATION_SB_KEY);
-  file_duration_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_DURATION_OM_KEY);
-  sync_cb   = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SYNC_KEY);
-  auto_scroll_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_AUTO_SCROLL_KEY);
-  hide_info_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_HIDE_INFO_KEY);
-  stop_packets_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_PACKETS_CB_KEY);
-  stop_packets_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_PACKETS_SB_KEY);
-  stop_filesize_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILESIZE_CB_KEY);
-  stop_filesize_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILESIZE_SB_KEY);
-  stop_filesize_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILESIZE_OM_KEY);
-  stop_duration_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_DURATION_CB_KEY);
-  stop_duration_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_DURATION_SB_KEY);
-  stop_duration_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_DURATION_OM_KEY);
-  stop_files_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILES_CB_KEY);
-  stop_files_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILES_SB_KEY);
-  m_resolv_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_M_RESOLVE_KEY);
-  n_resolv_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_N_RESOLVE_KEY);
-  t_resolv_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_T_RESOLVE_KEY);
+  file_te   = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_TE_KEY);
+  multi_files_on_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_MULTI_FILES_ON_CB_KEY);
+  ringbuffer_nbf_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_NBF_CB_KEY);
+  ringbuffer_nbf_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_NBF_SB_KEY);
+  ring_filesize_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_FILESIZE_CB_KEY);
+  ring_filesize_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_FILESIZE_SB_KEY);
+  ring_filesize_om = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_FILESIZE_OM_KEY);
+  file_duration_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_DURATION_CB_KEY);
+  file_duration_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_DURATION_SB_KEY);
+  file_duration_om = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_DURATION_OM_KEY);
+  sync_cb   = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SYNC_KEY);
+  auto_scroll_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_AUTO_SCROLL_KEY);
+  hide_info_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_HIDE_INFO_KEY);
+  stop_packets_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_PACKETS_CB_KEY);
+  stop_packets_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_PACKETS_SB_KEY);
+  stop_filesize_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILESIZE_CB_KEY);
+  stop_filesize_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILESIZE_SB_KEY);
+  stop_filesize_om = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILESIZE_OM_KEY);
+  stop_duration_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_DURATION_CB_KEY);
+  stop_duration_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_DURATION_SB_KEY);
+  stop_duration_om = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_DURATION_OM_KEY);
+  stop_files_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILES_CB_KEY);
+  stop_files_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILES_SB_KEY);
+  m_resolv_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_M_RESOLVE_KEY);
+  n_resolv_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_N_RESOLVE_KEY);
+  t_resolv_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_T_RESOLVE_KEY);
 #ifdef HAVE_PCAP_SETSAMPLING
-  samp_none_rb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SAMP_NONE_RB_KEY);
-  samp_count_rb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SAMP_COUNT_RB_KEY);
-  samp_timer_rb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SAMP_TIMER_RB_KEY);
-  samp_count_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SAMP_COUNT_SB_KEY);
-  samp_timer_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SAMP_TIMER_SB_KEY);
+  samp_none_rb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_NONE_RB_KEY);
+  samp_count_rb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_COUNT_RB_KEY);
+  samp_timer_rb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_TIMER_RB_KEY);
+  samp_count_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_COUNT_SB_KEY);
+  samp_timer_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_TIMER_SB_KEY);
 #endif
 
   entry_text =
@@ -2002,11 +2002,11 @@ capture_dlg_prep(gpointer parent_w) {
   /* The Linktype will be stored when the interface will be changed, or if not, not datalink option is used,
      the acquisition will be performed on the default datalink for the device */
   /*  capture_opts->linktype =
-      GPOINTER_TO_INT(OBJECT_GET_DATA(linktype_om, E_CAP_OM_LT_VALUE_KEY)); */
+      GPOINTER_TO_INT(g_object_get_data(G_OBJECT(linktype_om), E_CAP_OM_LT_VALUE_KEY)); */
 
 #ifdef HAVE_PCAP_REMOTE
   capture_opts->src_type = (capture_source)
-      GPOINTER_TO_INT(OBJECT_GET_DATA(iftype_om, E_CAP_OM_IFTYPE_VALUE_KEY));
+      GPOINTER_TO_INT(g_object_get_data(G_OBJECT(iftype_om), E_CAP_OM_IFTYPE_VALUE_KEY));
   capture_opts->datatx_udp =
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(datatx_udp_cb));
   capture_opts->nocap_rpcap =
@@ -2205,7 +2205,7 @@ capture_prep_destroy_cb(GtkWidget *win, gpointer user_data _U_)
 
   /* Is there a file selection dialog associated with this
      Capture Options dialog? */
-  fs = OBJECT_GET_DATA(win, E_FILE_SEL_DIALOG_PTR_KEY);
+  fs = g_object_get_data(G_OBJECT(win), E_FILE_SEL_DIALOG_PTR_KEY);
 
   if (fs != NULL) {
     /* Yes.  Destroy it. */
@@ -2221,7 +2221,7 @@ capture_prep_destroy_cb(GtkWidget *win, gpointer user_data _U_)
 #endif
 
 #ifdef HAVE_PCAP_REMOTE
-  remote_w = OBJECT_GET_DATA(win, E_CAP_REMOTE_DIALOG_PTR_KEY);
+  remote_w = g_object_get_data(G_OBJECT(win), E_CAP_REMOTE_DIALOG_PTR_KEY);
   if (remote_w != NULL)
       window_destroy(remote_w);
 #endif
@@ -2234,8 +2234,8 @@ capture_prep_interface_changed_cb(GtkWidget *entry, gpointer argp)
   GtkWidget *linktype_om = argp;
   set_link_type_list(linktype_om, entry);
   /* Default to "use the default" */
-  OBJECT_SET_DATA(linktype_om, E_CAP_OM_LT_VALUE_KEY, GINT_TO_POINTER(-1));
-  capture_opts->linktype = GPOINTER_TO_INT(OBJECT_GET_DATA(linktype_om, E_CAP_OM_LT_VALUE_KEY));
+  g_object_set_data(G_OBJECT(linktype_om), E_CAP_OM_LT_VALUE_KEY, GINT_TO_POINTER(-1));
+  capture_opts->linktype = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(linktype_om), E_CAP_OM_LT_VALUE_KEY));
   linktype_history=0;
 }
 
@@ -2262,39 +2262,39 @@ capture_prep_adjust_sensitivity(GtkWidget *tb _U_, gpointer parent_w)
 #endif
 
 
-  if_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_IFACE_KEY);
-  snap_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SNAP_CB_KEY);
-  snap_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SNAP_SB_KEY);
-  multi_files_on_cb  = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_MULTI_FILES_ON_CB_KEY);
-  ringbuffer_nbf_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_NBF_CB_KEY);
-  ringbuffer_nbf_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_NBF_SB_KEY);
-  ringbuffer_nbf_lb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_NBF_LB_KEY);
-  ring_filesize_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_FILESIZE_CB_KEY);
-  ring_filesize_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_FILESIZE_SB_KEY);
-  ring_filesize_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_FILESIZE_OM_KEY);
-  file_duration_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_DURATION_CB_KEY);
-  file_duration_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_DURATION_SB_KEY);
-  file_duration_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_DURATION_OM_KEY);
-  sync_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SYNC_KEY);
-  auto_scroll_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_AUTO_SCROLL_KEY);
-  hide_info_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_HIDE_INFO_KEY);
-  stop_packets_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_PACKETS_CB_KEY);
-  stop_packets_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_PACKETS_SB_KEY);
-  stop_packets_lb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_PACKETS_LB_KEY);
-  stop_filesize_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILESIZE_CB_KEY);
-  stop_filesize_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILESIZE_SB_KEY);
-  stop_filesize_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILESIZE_OM_KEY);
-  stop_duration_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_DURATION_CB_KEY);
-  stop_duration_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_DURATION_SB_KEY);
-  stop_duration_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_DURATION_OM_KEY);
-  stop_files_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILES_CB_KEY);
-  stop_files_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILES_SB_KEY);
-  stop_files_lb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILES_LB_KEY);
+  if_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_IFACE_KEY);
+  snap_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SNAP_CB_KEY);
+  snap_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SNAP_SB_KEY);
+  multi_files_on_cb  = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_MULTI_FILES_ON_CB_KEY);
+  ringbuffer_nbf_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_NBF_CB_KEY);
+  ringbuffer_nbf_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_NBF_SB_KEY);
+  ringbuffer_nbf_lb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_NBF_LB_KEY);
+  ring_filesize_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_FILESIZE_CB_KEY);
+  ring_filesize_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_FILESIZE_SB_KEY);
+  ring_filesize_om = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_FILESIZE_OM_KEY);
+  file_duration_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_DURATION_CB_KEY);
+  file_duration_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_DURATION_SB_KEY);
+  file_duration_om = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_DURATION_OM_KEY);
+  sync_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SYNC_KEY);
+  auto_scroll_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_AUTO_SCROLL_KEY);
+  hide_info_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_HIDE_INFO_KEY);
+  stop_packets_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_PACKETS_CB_KEY);
+  stop_packets_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_PACKETS_SB_KEY);
+  stop_packets_lb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_PACKETS_LB_KEY);
+  stop_filesize_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILESIZE_CB_KEY);
+  stop_filesize_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILESIZE_SB_KEY);
+  stop_filesize_om = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILESIZE_OM_KEY);
+  stop_duration_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_DURATION_CB_KEY);
+  stop_duration_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_DURATION_SB_KEY);
+  stop_duration_om = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_DURATION_OM_KEY);
+  stop_files_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILES_CB_KEY);
+  stop_files_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILES_SB_KEY);
+  stop_files_lb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILES_LB_KEY);
 #ifdef HAVE_PCAP_SETSAMPLING
-  samp_count_rb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SAMP_COUNT_RB_KEY);
-  samp_timer_rb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SAMP_TIMER_RB_KEY);
-  samp_count_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SAMP_COUNT_SB_KEY);
-  samp_timer_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SAMP_TIMER_SB_KEY);
+  samp_count_rb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_COUNT_RB_KEY);
+  samp_timer_rb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_TIMER_RB_KEY);
+  samp_count_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_COUNT_SB_KEY);
+  samp_timer_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_TIMER_SB_KEY);
 #endif
 
   /* The snapshot length spinbox is sensitive if the "Limit each packet