osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

Update some text in the help dialog. 

Replace the large matrix of protocol togglebuttons with a GtkCList. The
CList displays three columns: the enabled/disabled state, the protocol's
abbreviated name and the protocol's full name.  Protocols can be enabled
or disabled by double-clicking on them.  The enable all, disable all, and
invert buttons were left intact.

I made a half-assed attempt at Gtk2 support by copying code from
plugins_dlg.c.  It's incomplete, and probably won't compile.

Using check boxes in the first column instead of the word "Disabled" would
have been nice.  GtkCLists don't let you embed anything besides text and
pixmaps unfortunately.

Update the man page accordingly.

We still need a way to save a list of disabled protocols.

svn path=/trunk/; revision=6707
This commit is contained in:
Gerald Combs 2002-12-01 19:11:54 +00:00
parent eb6384af0d
commit 07e0a47740
3 changed files with 240 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
doc/ethereal.pod.template
View File

@ -417,8 +417,17 @@ changed, or deleted.
=item Edit:Protocols
Edit the list of protocols, allowing protocol dissection to be
enabled or disabled.
Allow protocol dissection to be enabled or disabled for a specific
protocol. Individual protocols can be enabled or disabled by
double-clicking on them in the list. The entire list can be enabled,
disabled, or inverted using the buttons below the list.
When a protocol is disabled, dissection in a particular packet stops
when that protocol is reached, and Ethereal moves on to the next packet.
Any higher-layer protocols that would otherwise have been processed will
not be displayed. For example, disabling TCP will prevent the dissection
and display of TCP, HTTP, SMTP, Telnet, and any other protocol exclusively
dependent on TCP.
=item Capture:Start

10
gtk/help_dlg.c
View File

@ -1,6 +1,6 @@
/* help_dlg.c
*
* $Id: help_dlg.c,v 1.28 2002/11/11 15:39:05 oabad Exp $
* $Id: help_dlg.c,v 1.29 2002/12/01 19:11:53 gerald Exp $
*
* Laurent Deniel <deniel@worldnet.fr>
*
@ -330,12 +330,12 @@ static void insert_text(GtkWidget *w, char *buffer, int nchars)
}
static char *proto_help =
"The protocols (and packet types) currently supported by\n"
"Ethereal are the following:\n\n";
"The following protocols (and packet types) are currently\n"
"supported by Ethereal:\n\n";
static char *dfilter_help =
"The following list shows all per-protocol fields that\n"
"can be used in a display filter:\n";
"The following per-protocol fields can be used in display\n"
"filters:\n";
static char *cfilter_help =
"Packet capturing is performed with the pcap library. The capture filter "

359
gtk/proto_dlg.c
View File

@ -1,6 +1,6 @@
/* proto_dlg.c
*
* $Id: proto_dlg.c,v 1.19 2002/11/28 01:58:27 guy Exp $
* $Id: proto_dlg.c,v 1.20 2002/12/01 19:11:54 gerald Exp $
*
* Laurent Deniel <deniel@worldnet.fr>
*
@ -45,13 +45,21 @@ static void proto_apply_cb(GtkWidget *, gpointer);
static void proto_cancel_cb(GtkWidget *, gpointer);
static void proto_destroy_cb(GtkWidget *, gpointer);
static void show_proto_selection(GtkWidget *main, GtkWidget *container);
#if GTK_MAJOR_VERSION < 2
static void show_proto_selection(GtkCList *proto_list);
#else
static void show_proto_selection(GtkListStore *proto_store);
#endif
static gboolean set_proto_selection(GtkWidget *);
static gboolean revert_proto_selection(void);
static void toggle_all_cb(GtkWidget *button, gpointer parent_w);
static void enable_all_cb(GtkWidget *button, gpointer parent_w);
static void disable_all_cb(GtkWidget *button, gpointer parent_w);
#if GTK_MAJOR_VERSION < 2
static void proto_list_select_cb(GtkCList *proto_list, gint row, gint col,
GdkEventButton *ev, gpointer gp);
#endif
static GtkWidget *proto_w = NULL;
@ -62,21 +70,38 @@ typedef struct protocol_data {
char *name;
char *abbrev;
int hfinfo_index;
gboolean was_enabled;
gboolean enabled;
#if GTK_MAJOR_VERSION < 2
gint row;
#else
GtkTreeIter iter;
#endif
} protocol_data_t;
void proto_cb(GtkWidget *w _U_, gpointer data _U_)
#define DISABLED "Disabled"
#define STATUS_TXT(x) ((x) ? "" : DISABLED)
void
proto_cb(GtkWidget *w _U_, gpointer data _U_)
{
GtkWidget *main_vb, *bbox, *proto_nb, *apply_bt, *cancel_bt, *ok_bt,
*label, *scrolled_w, *selection_vb, *button;
GtkWidget *main_vb, *bbox, *proto_list, *label, *proto_sw, *proto_frame,
*proto_vb, *button;
gchar *titles[] = { "Status", "Protocol", "Description" };
gint width;
#if GTK_MAJOR_VERSION >= 2
GtkListStore *proto_store;
GtkCellRenderer *proto_rend;
GtkTreeViewColumn *proto_col;
#endif
if (proto_w != NULL) {
reactivate_window(proto_w);
return;
}
proto_w = dlg_window_new("Ethereal: Protocol");
proto_w = dlg_window_new("Ethereal: Enabled Protocols");
SIGNAL_CONNECT(proto_w, "delete_event", proto_delete_cb, NULL);
SIGNAL_CONNECT(proto_w, "destroy", proto_destroy_cb, NULL);
WIDGET_SET_SIZE(proto_w, DEF_WIDTH * 2/3, DEF_HEIGHT * 2/3);
@ -88,162 +113,228 @@ void proto_cb(GtkWidget *w _U_, gpointer data _U_)
gtk_container_add(GTK_CONTAINER(proto_w), main_vb);
gtk_widget_show(main_vb);
/* Protocol topics container */
/* Protocol selection list ("enable/disable" protocols) */
proto_nb = gtk_notebook_new();
gtk_container_add(GTK_CONTAINER(main_vb), proto_nb);
/* XXX do not know why I need this to fill all space around buttons */
WIDGET_SET_SIZE(proto_nb, DEF_WIDTH * 2/3 - 50, DEF_HEIGHT * 2/3 - 50);
proto_frame = gtk_frame_new("Enabled Protocols");
gtk_box_pack_start(GTK_BOX(main_vb), proto_frame, TRUE, TRUE, 0);
gtk_container_border_width(GTK_CONTAINER(proto_frame), 5);
gtk_widget_show(proto_frame);
/* Protocol selection panel ("enable/disable" protocols) */
/* Protocol list */
proto_vb = gtk_vbox_new(FALSE, 0);
gtk_container_border_width(GTK_CONTAINER(proto_vb), 1);
gtk_container_add(GTK_CONTAINER(proto_frame), proto_vb);
gtk_container_border_width(GTK_CONTAINER(proto_vb), 5);
gtk_widget_show(proto_vb);
proto_sw = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(proto_vb), proto_sw, TRUE, TRUE, 0);
gtk_widget_show(proto_sw);
selection_vb = gtk_vbox_new(FALSE, 0);
gtk_container_border_width(GTK_CONTAINER(selection_vb), 1);
label = gtk_label_new("Button pressed: protocol decoding is enabled");
#if GTK_MAJOR_VERSION < 2
proto_list = gtk_clist_new_with_titles(3, titles);
gtk_container_add(GTK_CONTAINER(proto_sw), proto_list);
gtk_clist_set_selection_mode(GTK_CLIST(proto_list), GTK_SELECTION_SINGLE);
gtk_clist_column_titles_passive(GTK_CLIST(proto_list));
gtk_clist_column_titles_show(GTK_CLIST(proto_list));
gtk_clist_set_column_auto_resize(GTK_CLIST(proto_list), 0, FALSE);
gtk_clist_set_column_auto_resize(GTK_CLIST(proto_list), 1, TRUE);
gtk_clist_set_column_auto_resize(GTK_CLIST(proto_list), 2, TRUE);
width = gdk_string_width(proto_list->style->font, DISABLED);
gtk_clist_set_column_width(GTK_CLIST(proto_list), 0, width);
SIGNAL_CONNECT(proto_list, "select-row", proto_list_select_cb, NULL);
show_proto_selection(GTK_CLIST(proto_list));
gtk_widget_show(proto_list);
#else
proto_store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
show_proto_selection(proto_store);
proto_list = tree_view_new(GTK_TREE_MODEL(proto_store));
gtk_tree_view_set_search_column(GTK_TREE_VIEW(proto_list), 0);
g_object_unref(G_OBJECT(proto_store));
gtk_container_add(GTK_CONTAINER(proto_sw), proto_list);
proto_rend = gtk_cell_renderer_text_new();
proto_col = gtk_tree_view_column_new_with_attributes(titles[0], proto_rend,
"status", 0, NULL);
gtk_tree_view_column_set_sort_column_id(proto_col, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(proto_list), proto_col);
proto_rend = gtk_cell_renderer_text_new();
proto_col = gtk_tree_view_column_new_with_attributes(titles[1], proto_rend,
"abbrev", 1, NULL);
gtk_tree_view_column_set_sort_column_id(proto_col, 1);
gtk_tree_view_append_column(GTK_TREE_VIEW(proto_list), proto_col);
proto_rend = gtk_cell_renderer_text_new();
proto_col = gtk_tree_view_column_new_with_attributes(titles[2], proto_rend,
"name", 2, NULL);
gtk_tree_view_column_set_sort_column_id(proto_col, 2);
gtk_tree_view_append_column(GTK_TREE_VIEW(proto_list), proto_col);
#endif
label = gtk_label_new("Disabling a protocol prevents higher "
"layer protocols from being displayed");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(selection_vb), label, FALSE, FALSE, 0);
scrolled_w = scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(scrolled_w), 1);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_w),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(selection_vb), scrolled_w, TRUE, TRUE, 0);
show_proto_selection(proto_w, scrolled_w);
gtk_widget_show(scrolled_w);
gtk_widget_show(selection_vb);
label = gtk_label_new("Decoding");
gtk_notebook_append_page(GTK_NOTEBOOK(proto_nb), selection_vb, label);
label = gtk_label_new("Note that when a protocol is disabled, "
"all linked sub-protocols are as well");
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(selection_vb), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(proto_vb), label, FALSE, FALSE, 5);
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
gtk_box_pack_start(GTK_BOX(selection_vb), bbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(proto_vb), bbox, FALSE, FALSE, 0);
gtk_widget_show(bbox);
/* Toggle All */
button = gtk_button_new_with_label("Toggle All");
SIGNAL_CONNECT(button, "clicked", toggle_all_cb, proto_w);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
gtk_widget_show(button);
/* Enable All */
button = gtk_button_new_with_label("Enable All");
SIGNAL_CONNECT(button, "clicked", enable_all_cb, proto_w);
SIGNAL_CONNECT(button, "clicked", enable_all_cb, proto_list);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
gtk_widget_show(button);
/* Disable All */
button = gtk_button_new_with_label("Disable All");
SIGNAL_CONNECT(button, "clicked", disable_all_cb, proto_w);
SIGNAL_CONNECT(button, "clicked", disable_all_cb, proto_list);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
gtk_widget_show(button);
/* Invert */
button = gtk_button_new_with_label("Invert");
SIGNAL_CONNECT(button, "clicked", toggle_all_cb, proto_list);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
gtk_widget_show(button);
/* XXX add other protocol-related panels here ... */
gtk_widget_show(proto_nb);
/* Ok, Apply, Cancel Buttons */
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
gtk_container_add(GTK_CONTAINER(main_vb), bbox);
gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0);
gtk_widget_show(bbox);
#if GTK_MAJOR_VERSION < 2
ok_bt = gtk_button_new_with_label ("OK");
button = gtk_button_new_with_label ("OK");
#else
ok_bt = gtk_button_new_from_stock(GTK_STOCK_OK);
button = gtk_button_new_from_stock(GTK_STOCK_OK);
#endif
SIGNAL_CONNECT(ok_bt, "clicked", proto_ok_cb, proto_w);
GTK_WIDGET_SET_FLAGS(ok_bt, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX (bbox), ok_bt, TRUE, TRUE, 0);
gtk_widget_grab_default(ok_bt);
gtk_widget_show(ok_bt);
SIGNAL_CONNECT(button, "clicked", proto_ok_cb, proto_w);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX (bbox), button, TRUE, TRUE, 0);
gtk_widget_grab_default(button);
gtk_widget_show(button);
#if GTK_MAJOR_VERSION < 2
apply_bt = gtk_button_new_with_label ("Apply");
button = gtk_button_new_with_label ("Apply");
#else
apply_bt = gtk_button_new_from_stock(GTK_STOCK_APPLY);
button = gtk_button_new_from_stock(GTK_STOCK_APPLY);
#endif
SIGNAL_CONNECT(apply_bt, "clicked", proto_apply_cb, proto_w);
GTK_WIDGET_SET_FLAGS(apply_bt, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX (bbox), apply_bt, TRUE, TRUE, 0);
gtk_widget_show(apply_bt);
SIGNAL_CONNECT(button, "clicked", proto_apply_cb, proto_w);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX (bbox), button, TRUE, TRUE, 0);
gtk_widget_show(button);
#if GTK_MAJOR_VERSION < 2
cancel_bt = gtk_button_new_with_label ("Cancel");
button = gtk_button_new_with_label ("Cancel");
#else
cancel_bt = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
#endif
SIGNAL_CONNECT(cancel_bt, "clicked", proto_cancel_cb, proto_w);
GTK_WIDGET_SET_FLAGS(cancel_bt, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX (bbox), cancel_bt, TRUE, TRUE, 0);
gtk_widget_show(cancel_bt);
SIGNAL_CONNECT(button, "clicked", proto_cancel_cb, proto_w);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX (bbox), button, TRUE, TRUE, 0);
gtk_widget_show(button);
dlg_set_cancel(proto_w, cancel_bt);
dlg_set_cancel(proto_w, button);
gtk_quit_add_destroy(gtk_main_level(), GTK_OBJECT(proto_w));
gtk_widget_show(proto_w);
} /* proto_cb */
#if GTK_MAJOR_VERSION < 2
static void
proto_list_select_cb(GtkCList *proto_list, gint row, gint col _U_,
GdkEventButton *ev, gpointer gp _U_) {
protocol_data_t *p = gtk_clist_get_row_data(proto_list, row);
if (ev->type == GDK_2BUTTON_PRESS) { /* Double-click */
if (p->enabled)
p->enabled = FALSE;
else
p->enabled = TRUE;
gtk_clist_set_text(proto_list, row, 0, STATUS_TXT(p->enabled) );
}
} /* proto_list_select_cb */
#endif
/* XXX - We need a callback for Gtk2 */
/* Toggle All */
static void
toggle_all_cb(GtkWidget *button _U_, gpointer parent_w)
toggle_all_cb(GtkWidget *button _U_, gpointer pl)
{
GSList *entry;
#if GTK_MAJOR_VERSION < 2
GtkCList *proto_list = GTK_CLIST(pl);
#endif
for (entry = protocol_list; entry != NULL; entry = g_slist_next(entry)) {
GtkWidget *button;
protocol_data_t *p = entry->data;
button = (GtkWidget *)OBJECT_GET_DATA(parent_w, p->abbrev);
/* gtk_toggle_button_toggled() didn't work for me... */
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),
!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)));
if (p->enabled)
p->enabled = FALSE;
else
p->enabled = TRUE;
#if GTK_MAJOR_VERSION < 2
gtk_clist_set_text(proto_list, p->row, 0, STATUS_TXT(p->enabled) );
#endif
}
}
/* Enable/Disable All Helper */
static void
set_active_all(gpointer parent_w, gboolean new_state)
set_active_all(GtkWidget *w, gboolean new_state)
{
#if GTK_MAJOR_VERSION < 2
GtkCList *proto_list = GTK_CLIST(w);
#endif
GSList *entry;
#if GTK_MAJOR_VERSION < 2
gtk_clist_freeze(proto_list);
#endif
for (entry = protocol_list; entry != NULL; entry = g_slist_next(entry)) {
GtkWidget *button;
protocol_data_t *p = entry->data;
button = (GtkWidget *)OBJECT_GET_DATA(parent_w, p->abbrev);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), new_state);
p->enabled = new_state;
#if GTK_MAJOR_VERSION < 2
gtk_clist_set_text(proto_list, p->row, 0, STATUS_TXT(new_state) );
#endif
}
#if GTK_MAJOR_VERSION < 2
gtk_clist_thaw(proto_list);
#endif
}
/* Enable All */
static void
enable_all_cb(GtkWidget *button _U_, gpointer parent_w)
enable_all_cb(GtkWidget *button _U_, gpointer pl)
{
set_active_all(parent_w, TRUE);
set_active_all(pl, TRUE);
}
/* Disable All */
static void
disable_all_cb(GtkWidget *button _U_, gpointer parent_w)
disable_all_cb(GtkWidget *button _U_, gpointer pl)
{
set_active_all(parent_w, FALSE);
set_active_all(pl, FALSE);
}
static void proto_destroy_cb(GtkWidget *w _U_, gpointer data _U_)
static void
proto_destroy_cb(GtkWidget *w _U_, gpointer data _U_)
{
GSList *entry;
@ -265,13 +356,15 @@ static void proto_destroy_cb(GtkWidget *w _U_, gpointer data _U_)
XXX - that'll destroy the Protocols dialog; will that upset
a higher-level handler that says "OK, we've been asked to delete
this, so destroy it"? */
static gboolean proto_delete_cb(GtkWidget *proto_w, gpointer dummy _U_)
static gboolean
proto_delete_cb(GtkWidget *proto_w, gpointer dummy _U_)
{
proto_cancel_cb(NULL, proto_w);
return FALSE;
}
static void proto_ok_cb(GtkWidget *ok_bt _U_, gpointer parent_w)
static void
proto_ok_cb(GtkWidget *ok_bt _U_, gpointer parent_w)
{
gboolean redissect;
@ -281,13 +374,15 @@ static void proto_ok_cb(GtkWidget *ok_bt _U_, gpointer parent_w)
redissect_packets(&cfile);
}
static void proto_apply_cb(GtkWidget *apply_bt _U_, gpointer parent_w)
static void
proto_apply_cb(GtkWidget *apply_bt _U_, gpointer parent_w)
{
if (set_proto_selection(GTK_WIDGET(parent_w)))
redissect_packets(&cfile);
}
static void proto_cancel_cb(GtkWidget *cancel_bt _U_, gpointer parent_w)
static void
proto_cancel_cb(GtkWidget *cancel_bt _U_, gpointer parent_w)
{
gboolean redissect;
@ -297,18 +392,17 @@ static void proto_cancel_cb(GtkWidget *cancel_bt _U_, gpointer parent_w)
redissect_packets(&cfile);
}
static gboolean set_proto_selection(GtkWidget *parent_w)
static gboolean
set_proto_selection(GtkWidget *parent_w _U_)
{
GSList *entry;
gboolean need_redissect = FALSE;
for (entry = protocol_list; entry != NULL; entry = g_slist_next(entry)) {
GtkWidget *button;
protocol_data_t *p = entry->data;
button = (GtkWidget *)OBJECT_GET_DATA(parent_w, p->abbrev);
if (proto_is_protocol_enabled(p->hfinfo_index) != GTK_TOGGLE_BUTTON (button)->active) {
proto_set_decoding(p->hfinfo_index, GTK_TOGGLE_BUTTON (button)->active);
if (proto_is_protocol_enabled(p->hfinfo_index) != p->enabled) {
proto_set_decoding(p->hfinfo_index, p->enabled);
need_redissect = TRUE;
}
}
@ -317,7 +411,8 @@ static gboolean set_proto_selection(GtkWidget *parent_w)
} /* set_proto_selection */
static gboolean revert_proto_selection(void)
static gboolean
revert_proto_selection(void)
{
GSList *entry;
gboolean need_redissect = FALSE;
@ -328,8 +423,8 @@ static gboolean revert_proto_selection(void)
for (entry = protocol_list; entry != NULL; entry = g_slist_next(entry)) {
protocol_data_t *p = entry->data;
if (proto_is_protocol_enabled(p->hfinfo_index) != p->was_enabled) {
proto_set_decoding(p->hfinfo_index, p->was_enabled);
if (proto_is_protocol_enabled(p->hfinfo_index) != p->enabled) {
proto_set_decoding(p->hfinfo_index, p->enabled);
need_redissect = TRUE;
}
}
@ -338,7 +433,8 @@ static gboolean revert_proto_selection(void)
} /* revert_proto_selection */
gint protocol_data_compare(gconstpointer a, gconstpointer b)
gint
protocol_data_compare(gconstpointer a, gconstpointer b)
{
const protocol_data_t *ap = (const protocol_data_t *)a;
const protocol_data_t *bp = (const protocol_data_t *)b;
@ -346,17 +442,22 @@ gint protocol_data_compare(gconstpointer a, gconstpointer b)
return strcmp(ap->abbrev, bp->abbrev);
}
static void show_proto_selection(GtkWidget *main, GtkWidget *container)
static void
#if GTK_MAJOR_VERSION < 2
show_proto_selection(GtkCList *proto_list)
#else
show_proto_selection(GtkListStore *proto_store)
#endif
{
#define NB_COL 7
GSList *entry;
GtkTooltips *tooltips;
GtkWidget *table;
int i, t = 0, l = 0, nb_line, nb_proto = 0;
gint i;
void *cookie;
protocol_data_t *p;
#if GTK_MAJOR_VERSION < 2
gchar *proto_text[3];
#else
GtkTreeIter proto_iter;
#endif
/* Iterate over all the protocols */
@ -365,48 +466,36 @@ static void show_proto_selection(GtkWidget *main, GtkWidget *container)
if (proto_can_disable_protocol(i)) {
p = g_malloc(sizeof(protocol_data_t));
p->name = proto_get_protocol_name(i);
p->abbrev = proto_get_protocol_filter_name(i);
p->abbrev = proto_get_protocol_short_name(i);
p->hfinfo_index = i;
p->was_enabled = proto_is_protocol_enabled(i);
p->enabled = proto_is_protocol_enabled(i);
protocol_list = g_slist_insert_sorted(protocol_list,
p, protocol_data_compare);
nb_proto ++;
}
}
/* create a table (n x NB_COL) of buttons */
nb_line = (nb_proto % NB_COL) ? nb_proto / NB_COL + 1 : nb_proto / NB_COL;
table = gtk_table_new (nb_line, NB_COL, FALSE);
gtk_table_set_row_spacings(GTK_TABLE (table), 1);
gtk_table_set_col_spacings(GTK_TABLE (table), 1);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(container), table);
gtk_widget_show(table);
tooltips = gtk_tooltips_new();
nb_proto = 0;
for (entry = protocol_list; entry != NULL; entry = g_slist_next(entry)) {
GtkWidget *button;
p = entry->data;
/* button label is the protocol abbrev */
button = gtk_toggle_button_new_with_label(p->abbrev);
/* tip is the complete protocol name */
gtk_tooltips_set_tip(tooltips, button, p->name, NULL);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button),
proto_is_protocol_enabled(p->hfinfo_index));
OBJECT_SET_DATA(main, p->abbrev, button);
gtk_table_attach_defaults (GTK_TABLE (table), button, l, l+1, t, t+1);
gtk_widget_show (button);
if (++nb_proto % NB_COL) {
l++;
}
else {
l = 0;
t++;
}
#if GTK_MAJOR_VERSION < 2
/* XXX - The preferred way to do this would be to have a check box
* in the first column. GtkClists don't let us put arbitrary widgets
* in a cell, so we use the word "Disabled" instead. We should be
* able to use check boxes in Gtk2, however.
*/
proto_text[0] = STATUS_TXT (p->enabled);
proto_text[1] = p->abbrev;
proto_text[2] = p->name;
p->row = gtk_clist_append(proto_list, proto_text);
gtk_clist_set_row_data(proto_list, p->row, p);
#else
gtk_list_store_append(proto_store, &proto_iter);
gtk_list_store_set(proto_store, &proto_iter,
0, STATUS_TXT (p->enabled),
1, p->abbrev,
2, p->name,
-1);
#endif
}
} /* show_proto_selection */