*
* 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;
static GMutex *recent_mtx;
+#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_);
+#endif
+#endif
+
/* The "scroll box dynamic" is a (complicated) pseudo widget to */
/* place a vertically list of widgets in (currently the interfaces and recent files). */
/* Once this list get's higher than a specified amount, */
/* This is all complicated, the scrolled window is a bit ugly, */
/* the sizes might not be the same on all systems, ... */
/* ... but that's the best what we currently have */
-#define SCROLL_BOX_CHILD_BOX "ScrollBoxDynamic_ChildBox"
-#define SCROLL_BOX_MAX_CHILDS "ScrollBoxDynamic_MaxChilds"
-#define SCROLL_BOX_SCROLLW_Y_SIZE "ScrollBoxDynamic_Scrollw_Y_Size"
-#define SCROLL_BOX_SCROLLW "ScrollBoxDynamic_Scrollw"
-#define TREE_VIEW_INTERFACES "TreeViewInterfaces"
+#define SCROLL_BOX_CHILD_BOX "ScrollBoxDynamic_ChildBox"
+#define SCROLL_BOX_MAX_CHILDS "ScrollBoxDynamic_MaxChilds"
+#define SCROLL_BOX_SCROLLW_Y_SIZE "ScrollBoxDynamic_Scrollw_Y_Size"
+#define SCROLL_BOX_SCROLLW "ScrollBoxDynamic_Scrollw"
+#define TREE_VIEW_INTERFACES "TreeViewInterfaces"
+#define CAPTURE_VIEW "CaptureView"
+#define CAPTURE_LABEL "CaptureLabel"
+#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 *
scroll_box_dynamic_new(GtkWidget *child_box, guint max_childs, guint scrollw_y_size) {
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
+#ifdef HAVE_LIBPCAP
void
-select_ifaces(void)
+change_interface_name(gchar *oldname, guint indx)
{
-#ifdef HAVE_LIBPCAP
GtkWidget *view;
GtkTreeModel *model;
+ GtkTreeIter iter;
+ interface_t device;
GtkTreeSelection *entry;
+ gchar *optname;
+
+ view = g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES);
+ entry = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
+ model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
- 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);
+ 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);
+ if (strcmp(optname, oldname) == 0) {
+ gtk_list_store_set(GTK_LIST_STORE(model), &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);
+ }
+ break;
+ }
+ } while (gtk_tree_model_iter_next(model, &iter));
+ g_free(optname);
}
-#endif
}
+#endif
#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));
}
#endif
-/* list the interfaces */
-void
-welcome_if_tree_load(void)
-{
#ifdef HAVE_LIBPCAP
+static void
+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);
+ }
+ item_hb = g_object_get_data(G_OBJECT(welcome_hb), CAPTURE_HB_BOX_START);
+ if (item_hb) {
+ gtk_widget_destroy(item_hb);
+ }
+ item_hb = g_object_get_data(G_OBJECT(welcome_hb), CAPTURE_HB_BOX_CAPTURE);
+ if (item_hb) {
+ gtk_widget_destroy(item_hb);
+ }
+ 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;
- GtkWidget *view;
GtkTreeSelection *entry;
interface_t device;
gboolean changed = FALSE;
- int error;
- view = g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES);
- entry = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
- gtk_tree_selection_unselect_all(entry);
+ 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);
- } 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);
- }
+ 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);
}
}
- changed = TRUE;
}
- gtk_tree_selection_set_select_function(entry, on_selection_changed, (gpointer)&changed, NULL);
- if (gtk_widget_is_focus(view) && dlg_window_present()) {
- update_all_rows();
+ 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, *item_hb_refresh;
+ GtkWidget *item_hb_interface_list, *item_hb_capture, *item_hb_start, *label, *w;
+ GtkTreeSelection *selection;
+ GtkCellRenderer *renderer;
+ GtkTreeViewColumn *column;
+ int error = 0;
+ 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);
+ }
+ box_to_fill = g_object_get_data(G_OBJECT(welcome_hb), CAPTURE_VIEW);
+ if (global_capture_opts.all_ifaces->len > 0) {
+ item_hb_interface_list = welcome_button(WIRESHARK_STOCK_CAPTURE_INTERFACES,
+ "Interface List",
+ "Live list of the capture interfaces\n(counts incoming packets)",
+ "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);
+ 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 ();
+ g_object_set(G_OBJECT(if_view), "headers-visible", FALSE, NULL);
+ g_signal_connect(if_view, "row-activated", G_CALLBACK(options_interface_cb), (gpointer)welcome_hb);
+ g_object_set_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES, if_view);
+ column = gtk_tree_view_column_new();
+ renderer = gtk_cell_renderer_pixbuf_new();
+ gtk_tree_view_column_pack_start(column, renderer, FALSE);
+ gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", ICON, NULL);
+ renderer = gtk_cell_renderer_text_new();
+ gtk_tree_view_column_pack_start(column, renderer, TRUE);
+ gtk_tree_view_column_set_attributes(column, renderer, "text", IFACE_DESCR, NULL);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(if_view), column);
+ gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(if_view), 0), TRUE);
+ renderer = gtk_cell_renderer_text_new();
+ column = gtk_tree_view_column_new_with_attributes ("",
+ GTK_CELL_RENDERER(renderer),
+ "text", IFACE_NAME,
+ NULL);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(if_view), column);
+ gtk_tree_view_column_set_visible(column, FALSE);
+ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(if_view));
+ gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
+ item_hb_start = welcome_button(WIRESHARK_STOCK_CAPTURE_START,
+ "Start",
+ "Choose one or more interfaces to capture from, then <b>Start</b>",
+ "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);
+ 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,
+ "Capture Options",
+ "Start a capture with detailed options",
+ "Same as Capture/Options menu or toolbar item",
+ welcome_button_callback_helper, capture_prep_cb);
+ gtk_box_pack_start(GTK_BOX(box_to_fill), item_hb_capture, FALSE, FALSE, 5);
+ g_object_set_data(G_OBJECT(welcome_hb), CAPTURE_HB_BOX_CAPTURE, item_hb_capture);
+#ifdef _WIN32
+ /* Check for chimney offloading */
+ reg_ret = RegQueryValueEx(HKEY_LOCAL_MACHINE,
+ _T("SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\EnableTCPChimney"),
+ NULL, NULL, (LPBYTE) &chimney_enabled, &ce_size);
+ if (reg_ret == ERROR_SUCCESS && chimney_enabled) {
+ 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 */
+ } else {
+ if (if_view) {
+ clear_capture_box();
+ }
+
+ /* 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"
+#else
+ " http://www.winpcap.org/\n"
+#endif
+ "\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"
+#else
+ " http://www.mirrors.wiretapped.net/security/packet-capture/winpcap/\n"
+#endif
+ "\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"
+#else
+ " http://winpcap.cs.pu.edu.tw/\n"
+#endif
+ "\n"
+ "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_free (label_text);
+ gtk_misc_set_alignment (GTK_MISC(w), 0.0f, 0.0f);
+ gtk_box_pack_start(GTK_BOX(box_to_fill), w, FALSE, FALSE, 5);
+#if GTK_CHECK_VERSION(2,18,0)
+ g_signal_connect(w, "activate-link", G_CALLBACK(activate_link_cb), NULL);
+#endif
+ g_object_set_data(G_OBJECT(welcome_hb), CAPTURE_LABEL, w);
+ 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);
+ }
}
-#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 *header;
GtkWidget *topic_vb;
GtkWidget *topic_to_fill;
- GtkWidget *file_child_box;
+ GtkWidget *topic_capture_to_fill;
gchar *label_text;
-#ifdef HAVE_LIBPCAP
- int error;
-#endif
-#ifdef _WIN32
- LONG reg_ret;
- DWORD chimney_enabled = 0;
- DWORD ce_size = sizeof(chimney_enabled);
-#endif
-#ifdef HAVE_LIBPCAP
- GtkTreeSelection *selection;
- GtkCellRenderer *renderer;
- GtkTreeViewColumn *column;
-#endif
+ GtkWidget *file_child_box;
/* prepare colors */
#if 0
- /* Allocating collor isn't necessary? */
+ /* Allocating color isn't necessary? */
/* "page" background */
get_color(&welcome_bg);
#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
gtk_box_pack_start(GTK_BOX(welcome_hb), column_vb, TRUE, TRUE, 0);
/* capture topic */
- topic_vb = welcome_topic_new("Capture", &topic_to_fill);
+ topic_vb = welcome_topic_new("Capture", &topic_capture_to_fill);
gtk_box_pack_start(GTK_BOX(column_vb), topic_vb, TRUE, TRUE, 0);
+ 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);
- }
- if (global_capture_opts.all_ifaces->len > 0) {
- item_hb = welcome_button(WIRESHARK_STOCK_CAPTURE_INTERFACES,
- "Interface List",
- "Live list of the capture interfaces\n(counts incoming packets)",
- "Same as Capture/Interfaces menu or toolbar item",
- welcome_button_callback_helper, capture_if_cb);
- gtk_box_pack_start(GTK_BOX(topic_to_fill), item_hb, 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_view = gtk_tree_view_new ();
- g_object_set(G_OBJECT(if_view), "headers-visible", FALSE, NULL);
- g_signal_connect(if_view, "row-activated", G_CALLBACK(options_interface_cb), (gpointer)welcome_hb);
- g_object_set_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES, if_view);
- column = gtk_tree_view_column_new();
- renderer = gtk_cell_renderer_pixbuf_new();
- gtk_tree_view_column_pack_start(column, renderer, FALSE);
- gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", ICON, NULL);
- renderer = gtk_cell_renderer_text_new();
- gtk_tree_view_column_pack_start(column, renderer, TRUE);
- gtk_tree_view_column_set_attributes(column, renderer, "text", IFACE_DESCR, NULL);
- gtk_tree_view_append_column(GTK_TREE_VIEW(if_view), column);
- gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(if_view), 0), TRUE);
- renderer = gtk_cell_renderer_text_new();
- column = gtk_tree_view_column_new_with_attributes ("",
- GTK_CELL_RENDERER(renderer),
- "text", IFACE_NAME,
- NULL);
- gtk_tree_view_append_column(GTK_TREE_VIEW(if_view), column);
- gtk_tree_view_column_set_visible(column, FALSE);
- selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(if_view));
- gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
- item_hb = welcome_button(WIRESHARK_STOCK_CAPTURE_START,
- "Start",
- "Choose one or more interfaces to capture from, then <b>Start</b>",
- "Same as Capture/Interfaces with default options",
- (welcome_button_callback_t)capture_if_start, (gpointer)if_view);
- gtk_box_pack_start(GTK_BOX(topic_to_fill), item_hb, FALSE, FALSE, 5);
- welcome_if_tree_load();
- gtk_container_add (GTK_CONTAINER (swindow), if_view);
- gtk_container_add(GTK_CONTAINER(topic_to_fill), swindow);
-
- item_hb = welcome_button(WIRESHARK_STOCK_CAPTURE_OPTIONS,
- "Capture Options",
- "Start a capture with detailed options",
- "Same as Capture/Options menu or toolbar item",
- welcome_button_callback_helper, capture_prep_cb);
- gtk_box_pack_start(GTK_BOX(topic_to_fill), item_hb, FALSE, FALSE, 5);
-#ifdef _WIN32
- /* Check for chimney offloading */
- reg_ret = RegQueryValueEx(HKEY_LOCAL_MACHINE,
- _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));
- gtk_box_pack_start(GTK_BOX(topic_to_fill), item_hb, FALSE, FALSE, 5);
- }
-#endif /* _WIN32 */
- } else {
- 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"
-#if GTK_CHECK_VERSION(2,18,0)
- " <a href=\"http://www.winpcap.org/\">http://www.winpcap.org/</a>\n"
-#else
- " http://www.winpcap.org/\n"
-#endif
- "\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"
-#else
- " http://www.mirrors.wiretapped.net/security/packet-capture/winpcap/\n"
-#endif
- "\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"
-#else
- " 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.");
- }
- 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_free (label_text);
- gtk_misc_set_alignment (GTK_MISC(w), 0.0f, 0.0f);
- gtk_box_pack_start(GTK_BOX(topic_to_fill), w, FALSE, FALSE, 5);
-#if GTK_CHECK_VERSION(2,18,0)
- g_signal_connect(w, "activate-link", G_CALLBACK(activate_link_cb), NULL);
-#endif
- }
+ fill_in_local_interfaces();
+ fill_capture_box();
/* capture help topic */
topic_vb = welcome_topic_new("Capture Help", &topic_to_fill);
gtk_label_set_markup(GTK_LABEL(w), label_text);
g_free (label_text);
gtk_misc_set_alignment (GTK_MISC(w), 0.0f, 0.0f);
- gtk_box_pack_start(GTK_BOX(topic_to_fill), w, FALSE, FALSE, 5);
+ gtk_box_pack_start(GTK_BOX(topic_capture_to_fill), w, FALSE, FALSE, 5);
#endif /* HAVE_LIBPCAP */
/* fill bottom space */
w = gtk_label_new("");
- gtk_box_pack_start(GTK_BOX(topic_to_fill), w, TRUE, TRUE, 0);
+ gtk_box_pack_start(GTK_BOX(topic_capture_to_fill), w, TRUE, TRUE, 0);
/* column files */
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