*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include "config.h"
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
#include <time.h>
#include <gtk/gtk.h>
#endif
#include <wsutil/file_util.h>
+#include <wsutil/str_util.h>
+#ifdef HAVE_LIBPCAP
+#include "ui/iface_lists.h"
+#include "ui/capture_globals.h"
+#endif
#include "ui/recent.h"
#include "ui/simple_dialog.h"
+#include "ui/utf8_entities.h"
#include "ui/gtk/gui_utils.h"
#include "ui/gtk/color_utils.h"
#include "ui/gtk/help_dlg.h"
#include "ui/gtk/capture_file_dlg.h"
#include "ui/gtk/stock_icons.h"
-#include "ui/gtk/utf8_entities.h"
#ifdef HAVE_LIBPCAP
#include "ui/gtk/capture_dlg.h"
#include "ui/gtk/capture_if_dlg.h"
-#include "ui/gtk/capture_globals.h"
#if GTK_CHECK_VERSION(2,18,0)
#include "ui/gtk/webbrowser.h"
#endif
#include "airpcap_loader.h"
#include "airpcap_gui_utils.h"
#endif
-#if defined(HAVE_AIRPCAP)
-#include "../../image/toolbar/capture_airpcap_16.xpm"
-#endif
#if defined(HAVE_PCAP_REMOTE)
#include "ui/gtk/remote_icons.h"
#endif
#endif
static GtkWidget *welcome_file_panel_vb = NULL;
#ifdef HAVE_LIBPCAP
-static GtkWidget *if_view = NULL;
-static GtkWidget *swindow;
+static GtkWidget *if_view = NULL; /* contains a view (list) of all the interfaces */
+static GtkWidget *if_scrolled_window; /* a scrolled window that contains the if_view */
#endif
static GSList *status_messages = NULL;
#ifdef HAVE_LIBPCAP
static void capture_if_start(GtkWidget *w _U_, gpointer data _U_);
+#if GTK_CHECK_VERSION(2,18,0)
static gboolean activate_link_cb(GtkLabel *label _U_, gchar *uri, gpointer user_data _U_);
-static void welcome_if_tree_load(void);
+#endif
#endif
/* The "scroll box dynamic" is a (complicated) pseudo widget to */
#define CAPTURE_HB_BOX_INTERFACE_LIST "CaptureHorizontalBoxInterfaceList"
#define CAPTURE_HB_BOX_START "CaptureHorizontalBoxStart"
#define CAPTURE_HB_BOX_CAPTURE "CaptureHorizontalBoxCapture"
+#define CAPTURE_HB_BOX_REFRESH "CaptureHorizontalBoxRefresh"
static GtkWidget *
GtkWidget * parent_box;
- parent_box = gtk_vbox_new(FALSE, 0);
+ parent_box = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
gtk_box_pack_start(GTK_BOX(parent_box), GTK_WIDGET(child_box), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(parent_box), SCROLL_BOX_CHILD_BOX, child_box);
g_object_set_data(G_OBJECT(parent_box), SCROLL_BOX_MAX_CHILDS, GINT_TO_POINTER(max_childs));
welcome_item_enter_cb(GtkWidget *eb, GdkEventCrossing *event _U_, gpointer user_data _U_)
{
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_entered_bg);
+ gtk_widget_override_background_color(eb, GTK_STATE_FLAG_NORMAL, &rgba_topic_item_entered_bg);
#else
gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_item_entered_bg);
#endif
welcome_item_leave_cb(GtkWidget *eb, GdkEventCrossing *event _U_, gpointer user_data _U_)
{
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_idle_bg);
+ gtk_widget_override_background_color(eb, GTK_STATE_FLAG_NORMAL, &rgba_topic_item_idle_bg);
#else
gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_item_idle_bg);
#endif
GtkWidget *eb, *w, *item_hb, *text_vb;
gchar *formatted_text;
- item_hb = gtk_hbox_new(FALSE, 1);
+ item_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1, FALSE);
/* event box (for background color and events) */
eb = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(eb), item_hb);
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_idle_bg);
+ gtk_widget_override_background_color(eb, GTK_STATE_FLAG_NORMAL, &rgba_topic_item_idle_bg);
#else
gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_item_idle_bg);
#endif
w = gtk_image_new_from_stock(stock_item, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_box_pack_start(GTK_BOX(item_hb), w, FALSE, FALSE, 5);
- text_vb = gtk_vbox_new(FALSE, 3);
+ text_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
/* title */
w = gtk_label_new(title);
g_string_append(message, prefs.gui_start_title);
}
- if (prefs.gui_version_in_start_page) {
+ if ((prefs.gui_version_placement == version_welcome_only) ||
+ (prefs.gui_version_placement == version_both)) {
g_string_append_printf(message, "</span>\n<span size=\"large\" foreground=\"white\">Version " VERSION "%s",
wireshark_svnversion);
}
GtkWidget *eb;
GtkWidget *icon;
- item_vb = gtk_vbox_new(FALSE, 0);
+ item_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
/* colorize vbox */
eb = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(eb), item_vb);
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_header_bar_bg);
+ gtk_widget_override_background_color(eb, GTK_STATE_FLAG_NORMAL, &rgba_header_bar_bg);
#else
gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &header_bar_bg);
#endif
- item_hb = gtk_hbox_new(FALSE, 0);
+ item_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE);
gtk_box_pack_start(GTK_BOX(item_vb), item_hb, FALSE, FALSE, 10);
/*icon = xpm_to_widget_from_parent(top_level, wssplash_xpm);*/
eb = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(eb), w);
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_header_bg);
+ gtk_widget_override_background_color(eb, GTK_STATE_FLAG_NORMAL, &rgba_topic_header_bg);
#else
gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_header_bg);
#endif
GtkWidget *topic_header;
- topic_vb = gtk_vbox_new(FALSE, 0);
+ topic_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
topic_header = welcome_topic_header_new(header);
gtk_box_pack_start(GTK_BOX(topic_vb), topic_header, FALSE, FALSE, 0);
- layout_vb = gtk_vbox_new(FALSE, 5);
+ layout_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 5, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(layout_vb), 10);
gtk_box_pack_start(GTK_BOX(topic_vb), layout_vb, FALSE, FALSE, 0);
topic_eb = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(topic_eb), topic_vb);
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(topic_eb, GTK_STATE_NORMAL, &rgba_topic_content_bg);
+ gtk_widget_override_background_color(topic_eb, GTK_STATE_FLAG_NORMAL, &rgba_topic_content_bg);
#else
gtk_widget_modify_bg(topic_eb, GTK_STATE_NORMAL, &topic_content_bg);
#endif
{
recent_item_status *ri_stat = (recent_item_status *) data;
ws_statb64 stat_buf;
+ gchar *size_str;
int err;
if (!ri_stat) {
g_mutex_lock(recent_mtx);
ri_stat->err = err;
if(err == 0) {
- if (stat_buf.st_size/1024/1024/1024 > 10) {
- g_string_append_printf(ri_stat->str, " (%" G_GINT64_MODIFIER "d GB)", (gint64) (stat_buf.st_size/1024/1024/1024));
- } else if (stat_buf.st_size/1024/1024 > 10) {
- g_string_append_printf(ri_stat->str, " (%" G_GINT64_MODIFIER "d MB)", (gint64) (stat_buf.st_size/1024/1024));
- } else if (stat_buf.st_size/1024 > 10) {
- g_string_append_printf(ri_stat->str, " (%" G_GINT64_MODIFIER "d KB)", (gint64) (stat_buf.st_size/1024));
- } else {
- g_string_append_printf(ri_stat->str, " (%" G_GINT64_MODIFIER "d Bytes)", (gint64) (stat_buf.st_size));
- }
+ size_str = format_size(stat_buf.st_size, format_size_unit_bytes|format_size_prefix_si);
+
/* pango format string */
g_string_prepend(ri_stat->str, "<span foreground='blue'>");
- g_string_append(ri_stat->str, "</span>");
+ g_string_append_printf(ri_stat->str, " (%s)</span>", size_str);
+ g_free(size_str);
} else {
g_string_append(ri_stat->str, " [not found]");
}
/* event box */
eb = gtk_event_box_new();
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_idle_bg);
+ gtk_widget_override_background_color(eb, GTK_STATE_FLAG_NORMAL, &rgba_topic_item_idle_bg);
#else
gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_item_idle_bg);
#endif
}
#ifdef HAVE_LIBPCAP
-static gboolean select_current_ifaces(GtkTreeModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer userdata)
-{
- guint i;
- gchar *if_name;
- interface_t device;
-
- GtkTreeSelection *selection = (GtkTreeSelection *)userdata;
- device.name = NULL;
- gtk_tree_model_get (model, iter, IFACE_NAME, &if_name, -1);
- for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
- device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
- if (strcmp(device.name, if_name) == 0) {
- if (device.selected && !gtk_tree_selection_path_is_selected(selection, path)) {
- gtk_tree_selection_select_iter(selection, iter);
- } else {
- gtk_tree_selection_unselect_iter(selection, iter);
- }
- break;
- }
- }
- return FALSE;
-}
-
gboolean on_selection_changed(GtkTreeSelection *selection _U_,
GtkTreeModel *model,
GtkTreePath *path,
global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
g_array_insert_val(global_capture_opts.all_ifaces, i, device);
- if (dlg_window_present()) {
+ if (capture_dlg_window_present()) {
enable_selected_interface(g_strdup(if_name), device.selected);
}
if (interfaces_dialog_window_present()) {
}
#endif
-void
-select_ifaces(void)
-{
-#ifdef HAVE_LIBPCAP
- GtkWidget *view;
- GtkTreeModel *model;
- GtkTreeSelection *entry;
-
- if (global_capture_opts.num_selected > 0 && swindow) {
- view = g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES);
- model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
- entry = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
- gtk_tree_model_foreach(GTK_TREE_MODEL(model), select_current_ifaces, (gpointer) entry);
- gtk_widget_grab_focus(view);
- }
-#endif
-}
-
#ifdef HAVE_LIBPCAP
void
-change_interface_name(gchar *oldname, guint index)
+change_interface_name(gchar *oldname, guint indx)
{
GtkWidget *view;
GtkTreeModel *model;
entry = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
- device = g_array_index(global_capture_opts.all_ifaces, interface_t, index);
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, indx);
if (gtk_tree_model_get_iter_first (model, &iter)) {
do {
gtk_tree_model_get(model, &iter, IFACE_NAME, &optname, -1);
#ifdef HAVE_PCAP_REMOTE
void
-add_interface_to_list(guint index)
+add_interface_to_list(guint indx)
{
GtkWidget *view, *icon;
GtkTreeModel *model;
gchar *lines;
interface_t device;
- device = g_array_index(global_capture_opts.all_ifaces, interface_t, index);
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, indx);
icon = pixbuf_to_widget(remote_sat_pb_data);
view = g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES);
model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
clear_capture_box(void)
{
GtkWidget *item_hb;
-
+
item_hb = g_object_get_data(G_OBJECT(welcome_hb), CAPTURE_HB_BOX_INTERFACE_LIST);
if (item_hb) {
gtk_widget_destroy(item_hb);
if (item_hb) {
gtk_widget_destroy(item_hb);
}
- if (swindow) {
- gtk_widget_destroy(swindow);
- swindow = NULL;
+ item_hb = g_object_get_data(G_OBJECT(welcome_hb), CAPTURE_HB_BOX_REFRESH);
+ if (item_hb) {
+ gtk_widget_destroy(item_hb);
+ }
+ if (if_scrolled_window) {
+ gtk_widget_destroy(if_scrolled_window);
+ if_scrolled_window = NULL;
if_view = NULL;
}
}
+static void update_interface_scrolled_window_height(void)
+{
+ /* set the height of the scroll window that shows the interfaces
+ * based on the number of visible interfaces - up to a maximum of 10 interfaces */
+ guint i;
+ interface_t device;
+ int visible_interface_count=0;
+
+ if(if_scrolled_window==NULL){
+ return;
+ }
+
+ for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
+ if (!device.hidden) {
+ visible_interface_count++;
+ }
+ }
+ if(visible_interface_count>10){
+ /* up to 10 interfaces will be visible at one time */
+ visible_interface_count=10;
+ }
+ if(visible_interface_count<2){
+ /* minimum space for two interfaces */
+ visible_interface_count=2;
+ }
+ gtk_widget_set_size_request(if_scrolled_window, FALSE, visible_interface_count*21+4);
+}
+
+static void
+update_capture_box(void)
+{
+ guint i;
+ GtkListStore *store = NULL;
+ GtkTreeIter iter;
+ GtkTreeSelection *entry;
+ interface_t device;
+ gboolean changed = FALSE;
+
+ entry = gtk_tree_view_get_selection(GTK_TREE_VIEW(if_view));
+ gtk_tree_selection_unselect_all(GTK_TREE_SELECTION(entry));
+ store = gtk_list_store_new(NUMCOLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
+
+ gtk_list_store_clear(store);
+ gtk_tree_view_set_model(GTK_TREE_VIEW(if_view), GTK_TREE_MODEL (store));
+ for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
+ if (!device.hidden) {
+ gtk_list_store_append (store, &iter);
+ gtk_list_store_set (store, &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(capture_get_if_icon(&device))), IFACE_DESCR, device.display_name, IFACE_NAME, device.name, -1);
+ if (device.selected) {
+ gtk_tree_selection_select_iter(entry, &iter);
+ }
+ }
+ }
+ update_interface_scrolled_window_height();
+ changed = TRUE;
+ gtk_tree_selection_set_select_function(GTK_TREE_SELECTION(entry), on_selection_changed, (gpointer)&changed, NULL);
+}
+
+static void
+refresh_interfaces_cb(GtkWidget *w _U_, gpointer user_data _U_)
+{
+ clear_capture_box();
+ refresh_local_interface_lists();
+}
+
static void fill_capture_box(void)
{
- GtkWidget *box_to_fill;
+ GtkWidget *box_to_fill, *item_hb_refresh;
GtkWidget *item_hb_interface_list, *item_hb_capture, *item_hb_start, *label, *w;
-#ifdef _WIN32
- GtkWidget *item_hb;
-#endif
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
int error = 0;
- gchar *label_text;
+ gchar *label_text, *err_str;
#ifdef _WIN32
DWORD reg_ret;
DWORD chimney_enabled = 0;
DWORD ce_size = sizeof(chimney_enabled);
#endif
-
+
label = g_object_get_data(G_OBJECT(welcome_hb), CAPTURE_LABEL);
if (label) {
gtk_widget_destroy(label);
"Same as Capture/Interfaces menu or toolbar item",
welcome_button_callback_helper, capture_if_cb);
gtk_box_pack_start(GTK_BOX(box_to_fill), item_hb_interface_list, FALSE, FALSE, 5);
- swindow = gtk_scrolled_window_new (NULL, NULL);
- gtk_widget_set_size_request(swindow, FALSE, 100);
- gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swindow), GTK_SHADOW_IN);
- gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ if_scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+ update_interface_scrolled_window_height();
+ gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(if_scrolled_window), GTK_SHADOW_IN);
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(if_scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
g_object_set_data(G_OBJECT(welcome_hb), CAPTURE_HB_BOX_INTERFACE_LIST, item_hb_interface_list);
if_view = gtk_tree_view_new ();
"Same as Capture/Interfaces with default options",
(welcome_button_callback_t)capture_if_start, (gpointer)if_view);
gtk_box_pack_start(GTK_BOX(box_to_fill), item_hb_start, FALSE, FALSE, 5);
- welcome_if_tree_load();
- gtk_container_add (GTK_CONTAINER (swindow), if_view);
- gtk_container_add(GTK_CONTAINER(box_to_fill), swindow);
+ update_capture_box();
+ gtk_container_add (GTK_CONTAINER (if_scrolled_window), if_view);
+ gtk_container_add(GTK_CONTAINER(box_to_fill), if_scrolled_window);
g_object_set_data(G_OBJECT(welcome_hb), CAPTURE_HB_BOX_START, item_hb_start);
item_hb_capture = welcome_button(WIRESHARK_STOCK_CAPTURE_OPTIONS,
_T("SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\EnableTCPChimney"),
NULL, NULL, (LPBYTE) &chimney_enabled, &ce_size);
if (reg_ret == ERROR_SUCCESS && chimney_enabled) {
- item_hb = welcome_button(WIRESHARK_STOCK_WIKI,
- "Offloading Detected",
- "TCP Chimney offloading is enabled. You \nmight not capture much data.",
- topic_online_url(ONLINEPAGE_CHIMNEY),
- topic_menu_cb, GINT_TO_POINTER(ONLINEPAGE_CHIMNEY));
+ welcome_button(WIRESHARK_STOCK_WIKI,
+ "Offloading Detected",
+ "TCP Chimney offloading is enabled. You \nmight not capture much data.",
+ topic_online_url(ONLINEPAGE_CHIMNEY),
+ topic_menu_cb, GINT_TO_POINTER(ONLINEPAGE_CHIMNEY));
gtk_box_pack_start(GTK_BOX(box_to_fill), item_hb_capture, FALSE, FALSE, 5);
}
#endif /* _WIN32 */
if (if_view) {
clear_capture_box();
}
- if (error != NO_INTERFACES_FOUND) {
- if (error == CANT_GET_INTERFACE_LIST) {
- label_text = g_strdup("No interface can be used for capturing in "
- "this system with the current configuration.\n"
- "\n"
- "See Capture Help below for details.");
- } else {
- label_text = g_strdup("WinPcap doesn't appear to be installed. "
- "In order to capture packets, WinPcap "
- "must be installed; see\n"
- "\n"
+
+ /* run capture_interface_list(), not to get the interfaces, but to detect
+ * any errors, if there is an error, display an appropriate message in the gui */
+ capture_interface_list(&error, &err_str);
+ switch (error) {
+
+ case CANT_GET_INTERFACE_LIST:
+ label_text = g_strdup_printf("No interface can be used for capturing in "
+ "this system with the current configuration.\n\n"
+ "(%s)\n"
+ "\n"
+ "See Capture Help below for details.",
+ err_str);
+ break;
+
+ case NO_INTERFACES_FOUND:
+ label_text = g_strdup("No interface can be used for capturing in "
+ "this system with the current configuration.\n"
+ "\n"
+ "See Capture Help below for details.");
+ break;
+
+ case DONT_HAVE_PCAP:
+ label_text = g_strdup("WinPcap doesn't appear to be installed. "
+ "In order to capture packets, WinPcap "
+ "must be installed; see\n"
+ "\n"
#if GTK_CHECK_VERSION(2,18,0)
-
" <a href=\"http://www.winpcap.org/\">http://www.winpcap.org/</a>\n"
+ " <a href=\"http://www.winpcap.org/\">http://www.winpcap.org/</a>\n"
#else
- " http://www.winpcap.org/\n"
+ " http://www.winpcap.org/\n"
#endif
- "\n"
- "or the mirror at\n"
- "\n"
+ "\n"
+ "or the mirror at\n"
+ "\n"
#if GTK_CHECK_VERSION(2,18,0)
-
" <a href=\"http://www.mirrors.wiretapped.net/security/packet-capture/winpcap/\">http://www.mirrors.wiretapped.net/security/packet-capture/winpcap/</a>\n"
+ " <a href=\"http://www.mirrors.wiretapped.net/security/packet-capture/winpcap/\">http://www.mirrors.wiretapped.net/security/packet-capture/winpcap/</a>\n"
#else
- " http://www.mirrors.wiretapped.net/security/packet-capture/winpcap/\n"
+ " http://www.mirrors.wiretapped.net/security/packet-capture/winpcap/\n"
#endif
- "\n"
- "or the mirror at\n"
- "\n"
+ "\n"
+ "or the mirror at\n"
+ "\n"
#if GTK_CHECK_VERSION(2,18,0)
-
" <a href=\"http://winpcap.cs.pu.edu.tw/\">http://winpcap.cs.pu.edu.tw/</a>\n"
+ " <a href=\"http://winpcap.cs.pu.edu.tw/\">http://winpcap.cs.pu.edu.tw/</a>\n"
#else
- " http://winpcap.cs.pu.edu.tw/\n"
+ " http://winpcap.cs.pu.edu.tw/\n"
#endif
- "\n"
- "for a downloadable version of WinPcap "
- "and for instructions on how to install "
- "WinPcap.");
- }
- } else {
- label_text = g_strdup("No interface can be used for capturing in "
- "this system with the current configuration.\n"
"\n"
- "See Capture Help below for details.");
+ "for a downloadable version of WinPcap "
+ "and for instructions on how to install "
+ "WinPcap.");
+ break;
+
+ default:
+ label_text = g_strdup_printf("Error = %d; this \"can't happen\".", error);
+ break;
}
+ if (err_str != NULL)
+ g_free(err_str);
w = gtk_label_new(label_text);
gtk_label_set_markup(GTK_LABEL(w), label_text);
gtk_label_set_line_wrap(GTK_LABEL(w), TRUE);
g_signal_connect(w, "activate-link", G_CALLBACK(activate_link_cb), NULL);
#endif
g_object_set_data(G_OBJECT(welcome_hb), CAPTURE_LABEL, w);
- }
-}
-#endif
-
-/* list the interfaces */
-static void
-welcome_if_tree_load(void)
-{
-#ifdef HAVE_LIBPCAP
- guint i;
- GtkListStore *store = NULL;
- GtkTreeIter iter;
- GtkTreeSelection *entry;
- interface_t device;
- gboolean changed = FALSE;
- int error;
-
- if (if_view && swindow) {
- entry = gtk_tree_view_get_selection(GTK_TREE_VIEW(if_view));
- gtk_tree_selection_unselect_all(GTK_TREE_SELECTION(entry));
- store = gtk_list_store_new(NUMCOLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
-
- gtk_list_store_clear(store);
- gtk_tree_view_set_model(GTK_TREE_VIEW(if_view), GTK_TREE_MODEL (store));
- /* LOAD THE INTERFACES */
- if (global_capture_opts.all_ifaces->len == 0) {
- scan_local_interfaces(&global_capture_opts, &error);
- if (global_capture_opts.all_ifaces->len == 0) {
- fill_capture_box();
- }
- } else {
- for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
- device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
- if (!device.hidden) {
- gtk_list_store_append (store, &iter);
- gtk_list_store_set (store, &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(capture_get_if_icon(&device))), IFACE_DESCR, device.display_name, IFACE_NAME, device.name, -1);
- if (device.selected) {
- gtk_tree_selection_select_iter(entry, &iter);
- }
- }
- }
- changed = TRUE;
- gtk_tree_selection_set_select_function(GTK_TREE_SELECTION(entry), on_selection_changed, (gpointer)&changed, NULL);
- if (gtk_widget_is_focus(GTK_WIDGET(if_view)) && dlg_window_present()) {
- update_all_rows();
- }
+ if (error == CANT_GET_INTERFACE_LIST || error == NO_INTERFACES_FOUND) {
+ item_hb_refresh = welcome_button(GTK_STOCK_REFRESH,
+ "Refresh Interfaces",
+ "Get a new list of the local interfaces.",
+ "Click the title to get a new list of interfaces",
+ welcome_button_callback_helper, refresh_interfaces_cb);
+ gtk_box_pack_start(GTK_BOX(box_to_fill), item_hb_refresh, FALSE, FALSE, 5);
+ g_object_set_data(G_OBJECT(welcome_hb), CAPTURE_HB_BOX_REFRESH, item_hb_refresh);
}
- } else {
- fill_capture_box();
}
-#endif /* HAVE_LIBPCAP */
}
+#endif /* HAVE_LIBPCAP */
/* reload the list of interfaces */
{
#ifdef HAVE_LIBPCAP
if (welcome_hb) {
- welcome_if_tree_load();
+ /* If we have a list of interfaces, and if the current interface
+ list is non-empty, just update the interface list. Otherwise,
+ create it (as we didn't have it) or destroy it (as we won't
+ have it). */
+ if (if_view && if_scrolled_window && global_capture_opts.all_ifaces->len > 0) {
+ update_capture_box();
+ } else {
+ GtkWidget *item_hb;
+ item_hb = g_object_get_data(G_OBJECT(welcome_hb), CAPTURE_HB_BOX_REFRESH);
+ if (item_hb) {
+ gtk_widget_destroy(item_hb);
+ }
+ fill_capture_box();
+ }
gtk_widget_show_all(welcome_hb);
}
#endif /* HAVE_LIBPCAP */
break;
}
}
- airpcap_set_toolbar_start_capture(airpcap_if_active);
+ if (airpcap_if_active)
+ airpcap_set_toolbar_start_capture(airpcap_if_active);
#endif
capture_start_cb(NULL, NULL);
}
GtkWidget *topic_capture_to_fill;
gchar *label_text;
GtkWidget *file_child_box;
-#ifdef HAVE_LIBPCAP
- int error;
-#endif
-#ifdef _WIN32
- DWORD chimney_enabled = 0;
- DWORD ce_size = sizeof(chimney_enabled);
-#endif
+
/* prepare colors */
#if 0
/* Allocating color isn't necessary? */
#endif
welcome_scrollw = scrolled_window_new(NULL, NULL);
- welcome_vb = gtk_vbox_new(FALSE, 0);
+ welcome_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
welcome_eb = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(welcome_eb), welcome_vb);
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(welcome_eb, GTK_STATE_NORMAL, &rgba_welcome_bg);
+ gtk_widget_override_background_color(welcome_eb, GTK_STATE_FLAG_NORMAL, &rgba_welcome_bg);
#else
gtk_widget_modify_bg(welcome_eb, GTK_STATE_NORMAL, &welcome_bg);
#endif
gtk_box_pack_start(GTK_BOX(welcome_vb), header, FALSE, FALSE, 0);
/* content */
- welcome_hb = gtk_hbox_new(FALSE, 10);
+ welcome_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(welcome_hb), 10);
gtk_box_pack_start(GTK_BOX(welcome_vb), welcome_hb, TRUE, TRUE, 0);
/* column capture */
- column_vb = gtk_vbox_new(FALSE, 10);
+ column_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 10, FALSE);
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(column_vb, GTK_STATE_NORMAL, &rgba_welcome_bg);
+ gtk_widget_override_background_color(column_vb, GTK_STATE_FLAG_NORMAL, &rgba_welcome_bg);
#else
gtk_widget_modify_bg(column_vb, GTK_STATE_NORMAL, &welcome_bg);
#endif
g_object_set_data(G_OBJECT(welcome_hb), CAPTURE_VIEW, topic_capture_to_fill);
#ifdef HAVE_LIBPCAP
- if (global_capture_opts.all_ifaces->len == 0) {
- scan_local_interfaces(&global_capture_opts, &error);
- }
-
+ fill_in_local_interfaces();
fill_capture_box();
/* capture help topic */
gtk_misc_set_alignment (GTK_MISC(w), 0.0f, 0.0f);
gtk_box_pack_start(GTK_BOX(topic_to_fill), w, FALSE, FALSE, 5);
- file_child_box = gtk_vbox_new(FALSE, 1);
+ file_child_box = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 1, FALSE);
/* 17 file items or 300 pixels height is about the size */
/* that still fits on a screen of about 1000*700 */
welcome_file_panel_vb = scroll_box_dynamic_new(GTK_WIDGET(file_child_box), 17, 300);
/* column online */
- column_vb = gtk_vbox_new(FALSE, 10);
+ column_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 10, FALSE);
gtk_box_pack_start(GTK_BOX(welcome_hb), column_vb, TRUE, TRUE, 0);
/* topic online */
{
return welcome_hb;
}
-
-
git.samba.org / metze / wireshark / wip.git / blobdiff