osmocom
/
wireshark
14
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity

remove GTK1 code 

svn path=/trunk/; revision=24816
This commit is contained in:
Ulf Lamping 2008-04-06 23:20:23 +00:00
parent 70595a85f4
commit 0e701b77ae
5 changed files with 1 additions and 646 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

289
gtk/dfilter_expr_dlg.c
View File

@ -98,14 +98,8 @@ static void display_value_fields(header_field_info *hfinfo,
* Note that this is called every time the user clicks on an item,
* whether it is already selected or not.
*/
#if GTK_MAJOR_VERSION < 2
static void
field_select_row_cb(GtkWidget *tree, GList *node, gint column _U_,
gpointer user_data _U_)
#else
static void
field_select_row_cb(GtkTreeSelection *sel, gpointer tree)
#endif
{
GtkWidget *window = gtk_widget_get_toplevel(tree);
GtkWidget *relation_list = OBJECT_GET_DATA(window,
@ -129,18 +123,12 @@ field_select_row_cb(GtkTreeSelection *sel, gpointer tree)
header_field_info *hfinfo, *cur_hfinfo;
const char *value_type;
char value_label_string[1024+1]; /* XXX - should be large enough */
#if GTK_MAJOR_VERSION >= 2
GtkTreeModel *model;
GtkTreeIter iter;
if (!gtk_tree_selection_get_selected(sel, &model, &iter))
return;
gtk_tree_model_get(model, &iter, 1, &hfinfo, -1);
#else
hfinfo = gtk_ctree_node_get_row_data(GTK_CTREE(tree),
GTK_CTREE_NODE(node));
#endif
/*
* What was the item that was last selected?
@ -208,22 +196,14 @@ field_select_row_cb(GtkTreeSelection *sel, gpointer tree)
build_enum_values(value_list_scrolled_win, value_list,
hfinfo->strings);
} else
#if GTK_MAJOR_VERSION < 2
gtk_list_clear_items(GTK_LIST(value_list), 0, -1);
#else
gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(value_list))));
#endif
break;
default:
/*
* Clear the list of values.
*/
#if GTK_MAJOR_VERSION < 2
gtk_list_clear_items(GTK_LIST(value_list), 0, -1);
#else
gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(value_list))));
#endif
break;
}
@ -244,17 +224,11 @@ field_select_row_cb(GtkTreeSelection *sel, gpointer tree)
static void
show_relations(GtkWidget *relation_list, ftenum_t ftype)
{
#if GTK_MAJOR_VERSION >= 2
GtkTreeIter iter;
#endif
/*
* Clear out the currently displayed list of relations.
*/
#if GTK_MAJOR_VERSION < 2
gtk_list_clear_items(GTK_LIST(relation_list), 0, -1);
#else
gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(relation_list))));
#endif
/*
* Add the supported relations.
@ -280,10 +254,8 @@ show_relations(GtkWidget *relation_list, ftenum_t ftype)
ftype_can_matches(ftype) || (ftype_can_slice(ftype) && ftype_can_matches(FT_BYTES)));
#endif
#if GTK_MAJOR_VERSION >= 2
gtk_tree_model_get_iter_first(gtk_tree_view_get_model(GTK_TREE_VIEW(relation_list)), &iter);
gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(relation_list)), &iter);
#endif
}
/*
@ -299,19 +271,6 @@ relation_is_presence_test(const char *string)
static void
add_relation_list(GtkWidget *relation_list, const char *relation, gboolean sensitive)
{
#if GTK_MAJOR_VERSION < 2
GtkWidget *label, *item;
label = gtk_label_new(relation);
item = gtk_list_item_new();
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_container_add(GTK_CONTAINER(item), label);
gtk_widget_show(label);
gtk_container_add(GTK_CONTAINER(relation_list), item);
gtk_widget_show(item);
gtk_widget_set_sensitive(item, sensitive);
#else
GtkListStore *store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(relation_list)));
GtkTreeIter iter;
@ -323,23 +282,12 @@ add_relation_list(GtkWidget *relation_list, const char *relation, gboolean sensi
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, relation, -1);
#endif
}
#if GTK_MAJOR_VERSION < 2
static void
relation_list_sel_cb(GtkList *relation_list, GtkWidget *child _U_,
gpointer user_data _U_)
#else
static void
relation_list_sel_cb(GtkTreeSelection *sel, gpointer user_data _U_)
#endif
{
#if GTK_MAJOR_VERSION < 2
GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(relation_list));
#else
GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(gtk_tree_selection_get_tree_view(sel)));
#endif
GtkWidget *range_label =
OBJECT_GET_DATA(window, E_DFILTER_EXPR_RANGE_LABEL_KEY);
GtkWidget *range_entry =
@ -357,18 +305,6 @@ relation_list_sel_cb(GtkTreeSelection *sel, gpointer user_data _U_)
header_field_info *hfinfo =
OBJECT_GET_DATA(window, E_DFILTER_EXPR_CURRENT_VAR_KEY);
gchar *item_str;
#if GTK_MAJOR_VERSION < 2
GList *sl;
GtkWidget *item, *item_label;
/*
* What's the relation?
*/
sl = GTK_LIST(relation_list)->selection;
item = GTK_WIDGET(sl->data);
item_label = GTK_BIN(item)->child;
gtk_label_get(GTK_LABEL(item_label), &item_str);
#else
GtkTreeModel *model;
GtkTreeIter iter;
@ -378,7 +314,6 @@ relation_list_sel_cb(GtkTreeSelection *sel, gpointer user_data _U_)
if (!gtk_tree_selection_get_selected(sel, &model, &iter))
return;
gtk_tree_model_get(model, &iter, 0, &item_str, -1);
#endif
/*
* Update the display of various items for the value, as appropriate.
@ -387,9 +322,7 @@ relation_list_sel_cb(GtkTreeSelection *sel, gpointer user_data _U_)
!relation_is_presence_test(item_str),
value_label, value_entry, value_list_label, value_list,
value_list_scrolled_win, range_label, range_entry);
#if GTK_MAJOR_VERSION >= 2
g_free(item_str);
#endif
}
static void
@ -397,22 +330,16 @@ build_boolean_values(GtkWidget *value_list_scrolled_win, GtkWidget *value_list,
const true_false_string *values)
{
static const true_false_string true_false = { "True", "False" };
#if GTK_MAJOR_VERSION >= 2
GtkTreeSelection *sel;
GtkTreeIter iter;
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(value_list));
#endif
/*
* Clear out the items for the list, and put in the names
* from the value_string list.
*/
#if GTK_MAJOR_VERSION < 2
gtk_list_clear_items(GTK_LIST(value_list), 0, -1);
#else
gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(value_list))));
#endif
/*
* Put the list in single mode, so we don't get any selection
@ -420,11 +347,7 @@ build_boolean_values(GtkWidget *value_list_scrolled_win, GtkWidget *value_list,
* on a list item BEFORE WE GET TO SET THE DATA FOR THE LIST
* ITEM SO THAT THE HANDLER CAN HANDLE IT).
*/
#if GTK_MAJOR_VERSION < 2
gtk_list_set_selection_mode(GTK_LIST(value_list), GTK_SELECTION_SINGLE);
#else
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
#endif
/*
* Build the list.
@ -440,14 +363,9 @@ build_boolean_values(GtkWidget *value_list_scrolled_win, GtkWidget *value_list,
* the assumption that they're most likely to test if something
* is true, not false.
*/
#if GTK_MAJOR_VERSION < 2
gtk_list_set_selection_mode(GTK_LIST(value_list), GTK_SELECTION_BROWSE);
gtk_list_select_item(GTK_LIST(value_list), 0);
#else
gtk_tree_selection_set_mode(sel, GTK_SELECTION_BROWSE);
gtk_tree_model_get_iter_first(gtk_tree_view_get_model(GTK_TREE_VIEW(value_list)), &iter);
gtk_tree_selection_select_iter(sel, &iter);
#endif
gtk_widget_show_all(value_list_scrolled_win);
}
@ -456,20 +374,14 @@ static void
build_enum_values(GtkWidget *value_list_scrolled_win _U_, GtkWidget *value_list,
const value_string *values)
{
#if GTK_MAJOR_VERSION >= 2
GtkTreeSelection *sel;
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(value_list));
#endif
/*
* Clear out the items for the list, and put in the names
* from the value_string list.
*/
#if GTK_MAJOR_VERSION < 2
gtk_list_clear_items(GTK_LIST(value_list), 0, -1);
#else
gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(value_list))));
#endif
/*
* Put the list in single mode, so we don't get any selection
@ -477,11 +389,7 @@ build_enum_values(GtkWidget *value_list_scrolled_win _U_, GtkWidget *value_list,
* on a list item BEFORE WE GET TO SET THE DATA FOR THE LIST
* ITEM SO THAT THE HANDLER CAN HANDLE IT).
*/
#if GTK_MAJOR_VERSION < 2
gtk_list_set_selection_mode(GTK_LIST(value_list), GTK_SELECTION_SINGLE);
#else
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
#endif
/*
* Build the list.
@ -495,35 +403,17 @@ build_enum_values(GtkWidget *value_list_scrolled_win _U_, GtkWidget *value_list,
/*
* OK, we're done, so we can finally put it in browse mode.
*/
#if GTK_MAJOR_VERSION < 2
gtk_list_set_selection_mode(GTK_LIST(value_list), GTK_SELECTION_BROWSE);
#else
gtk_tree_selection_set_mode(sel, GTK_SELECTION_BROWSE);
#endif
}
static void
add_value_list_item(GtkWidget *value_list, const gchar *string, const gpointer data)
{
#if GTK_MAJOR_VERSION < 2
GtkWidget *label, *item;
label = gtk_label_new(string);
item = gtk_list_item_new();
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_container_add(GTK_CONTAINER(item), label);
gtk_widget_show(label);
gtk_container_add(GTK_CONTAINER(value_list), item);
OBJECT_SET_DATA(item, E_DFILTER_EXPR_VALUE_KEY, data);
gtk_widget_show(item);
#else
GtkListStore *store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(value_list)));
GtkTreeIter iter;
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, string, 1, data, -1);
#endif
}
/*
@ -638,35 +528,21 @@ display_value_fields(header_field_info *hfinfo, gboolean is_comparison,
gtk_widget_set_sensitive(range_entry, show_range);
}
#if GTK_MAJOR_VERSION < 2
static void
value_list_sel_cb(GtkList *value_list, GtkWidget *child,
gpointer value_entry_arg)
#else
static void
value_list_sel_cb(GtkTreeSelection *sel, gpointer value_entry_arg)
#endif
{
GtkWidget *value_entry = value_entry_arg;
#if GTK_MAJOR_VERSION < 2
GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(value_list));
#else
GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(gtk_tree_selection_get_tree_view(sel)));
GtkTreeModel *model;
GtkTreeIter iter;
#endif
header_field_info *hfinfo = OBJECT_GET_DATA(window,
E_DFILTER_EXPR_CURRENT_VAR_KEY);
const value_string *value = NULL;
char value_string[11+1]; /* long enough for 32-bit octal value */
#if GTK_MAJOR_VERSION < 2
value = OBJECT_GET_DATA(child, E_DFILTER_EXPR_VALUE_KEY);
#else
if (!gtk_tree_selection_get_selected(sel, &model, &iter))
return;
gtk_tree_model_get(model, &iter, 1, &value, -1);
#endif
/*
* This should either be a numeric type or a Boolean type.
@ -765,13 +641,8 @@ dfilter_expr_dlg_accept_cb(GtkWidget *w, gpointer filter_te_arg)
ftenum_t ftype;
gboolean can_compare;
fvalue_t *fvalue;
#if GTK_MAJOR_VERSION < 2
GList *sl;
GtkWidget *item, *item_label;
#else
GtkTreeModel *model;
GtkTreeIter iter;
#endif
gboolean quote_it;
/*
@ -782,17 +653,10 @@ dfilter_expr_dlg_accept_cb(GtkWidget *w, gpointer filter_te_arg)
/*
* Get the relation operator to use.
*/
#if GTK_MAJOR_VERSION < 2
sl = GTK_LIST(relation_list)->selection;
item = GTK_WIDGET(sl->data);
item_label = GTK_BIN(item)->child;
gtk_label_get(GTK_LABEL(item_label), &item_str);
#else
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(relation_list)),
&model, &iter)) {
gtk_tree_model_get(model, &iter, 0, &item_str, -1);
}
#endif
/*
* Get the range to use, if any.
@ -1012,9 +876,7 @@ dfilter_expr_dlg_accept_cb(GtkWidget *w, gpointer filter_te_arg)
* widget for the "Accept" button).
*/
window_destroy(window);
#if GTK_MAJOR_VERSION >= 2
g_free(item_str);
#endif
}
static void
@ -1073,20 +935,12 @@ dfilter_expr_dlg_new(GtkWidget *filter_te)
header_field_info *hfinfo;
int i;
protocol_t *protocol;
#if GTK_MAJOR_VERSION < 2
int len;
void *cookie;
const gchar *name;
GHashTable *proto_array;
GtkCTreeNode *protocol_node, *item_node;
#else
GtkTreeStore *store;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkListStore *l_store;
GtkTreeSelection *l_sel;
#endif
proto_initialize_all_prefixes();
@ -1111,18 +965,12 @@ dfilter_expr_dlg_new(GtkWidget *filter_te)
gtk_box_pack_start(GTK_BOX(field_vb), field_tree_lb, FALSE, FALSE, 0);
tree_scrolled_win = scrolled_window_new(NULL, NULL);
#if GTK_MAJOR_VERSION >= 2
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(tree_scrolled_win),
GTK_SHADOW_IN);
#endif
gtk_box_pack_start(GTK_BOX(field_vb), tree_scrolled_win, TRUE, TRUE, 0);
WIDGET_SET_SIZE(tree_scrolled_win, 300, -1);
#if GTK_MAJOR_VERSION < 2
field_tree = ctree_new(1, 0);
SIGNAL_CONNECT(field_tree, "tree-select-row", field_select_row_cb, field_tree);
#else
store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
field_tree = tree_view_new(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(field_tree), FALSE);
@ -1135,22 +983,8 @@ dfilter_expr_dlg_new(GtkWidget *filter_te)
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sort_column_id(column, 0);
SIGNAL_CONNECT(selection, "changed", field_select_row_cb, field_tree);
#endif
gtk_container_add(GTK_CONTAINER(tree_scrolled_win), field_tree);
#if GTK_MAJOR_VERSION < 2
/*
* GTK's annoying CTree widget will deliver a selection event
* the instant you add an item to the field_tree, *the fact that you
* haven't even had time to set the item's row data nonwithstanding*.
*
* We'll put the widget into GTK_SELECTION_SINGLE mode in the
* hopes that it *STOPS DOING THAT*.
*/
gtk_clist_set_selection_mode(GTK_CLIST(field_tree),
GTK_SELECTION_SINGLE);
#endif
relation_vb = gtk_vbox_new(FALSE, 5);
gtk_container_border_width(GTK_CONTAINER(relation_vb), 5);
gtk_container_add(GTK_CONTAINER(main_hb), relation_vb);
@ -1163,16 +997,9 @@ dfilter_expr_dlg_new(GtkWidget *filter_te)
/* never use a scrollbar in x direction, show the complete relation string */
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(relation_list_scrolled_win),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
#if GTK_MAJOR_VERSION >= 2
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(relation_list_scrolled_win),
GTK_SHADOW_IN);
#endif
#if GTK_MAJOR_VERSION < 2
relation_list = gtk_list_new();
gtk_list_set_selection_mode(GTK_LIST(relation_list),
GTK_SELECTION_BROWSE);
#else
l_store = gtk_list_store_new(1, G_TYPE_STRING);
relation_list = tree_view_new(GTK_TREE_MODEL(l_store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(relation_list), FALSE);
@ -1183,13 +1010,7 @@ dfilter_expr_dlg_new(GtkWidget *filter_te)
gtk_tree_view_append_column(GTK_TREE_VIEW(relation_list), column);
l_sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(relation_list));
gtk_tree_selection_set_mode(l_sel, GTK_SELECTION_BROWSE);
#endif
#if GTK_MAJOR_VERSION < 2
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(relation_list_scrolled_win),
relation_list);
#else
gtk_container_add(GTK_CONTAINER(relation_list_scrolled_win), relation_list);
#endif
gtk_box_pack_start(GTK_BOX(relation_vb), relation_list_scrolled_win, TRUE, TRUE, 0);
/*
@ -1258,21 +1079,6 @@ dfilter_expr_dlg_new(GtkWidget *filter_te)
gtk_box_pack_start(GTK_BOX(value_vb), value_list_scrolled_win, TRUE,
TRUE, 0);
#if GTK_MAJOR_VERSION < 2
value_list = gtk_list_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(value_list_scrolled_win),
value_list);
SIGNAL_CONNECT(value_list, "select-child", value_list_sel_cb, value_entry);
gtk_list_set_selection_mode(GTK_LIST(value_list), GTK_SELECTION_SINGLE);
/* This remains hidden until an enumerated field is selected */
/*
* The value stuff may be hidden or shown depending on what
* relation was selected; connect to the "select-child" signal
* for the relation list, so we can make that happen.
*/
SIGNAL_CONNECT(relation_list, "select-child", relation_list_sel_cb, NULL);
#else
l_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
value_list = tree_view_new(GTK_TREE_MODEL(l_store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(value_list), FALSE);
@ -1296,7 +1102,6 @@ dfilter_expr_dlg_new(GtkWidget *filter_te)
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(value_list_scrolled_win),
value_list);
/* This remains hidden until an enumerated field is selected */
#endif
/*
* Put the items in the Tree; we don't want to do that until
@ -1308,89 +1113,6 @@ dfilter_expr_dlg_new(GtkWidget *filter_te)
* we're ready to cope with the selection signal.
*/
#if GTK_MAJOR_VERSION < 2
/* a hash table seems excessive, but I don't see support for a
sparse array in glib */
proto_array = g_hash_table_new(g_direct_hash, g_direct_equal);
for (i = proto_get_first_protocol(&cookie); i != -1;
i = proto_get_next_protocol(&cookie)) {
hfinfo = proto_registrar_get_nth(i);
/* Create a node for the protocol, and remember it for
later use. */
protocol = find_protocol_by_id(i);
if (!proto_is_protocol_enabled(protocol))
continue;
name = proto_get_protocol_short_name(protocol); /* name, short_name or filter name ? */
protocol_node = gtk_ctree_insert_node(GTK_CTREE(field_tree),
NULL, NULL,
(gchar **) &name, 5,
NULL, NULL, NULL, NULL,
FALSE, FALSE);
gtk_ctree_node_set_row_data(GTK_CTREE(field_tree), protocol_node,
hfinfo);
g_hash_table_insert(proto_array, GINT_TO_POINTER(i), protocol_node);
}
len = proto_registrar_n();
for (i = 0; i < len; i++) {
char *strp, str[TAG_STRING_LEN+1];
/*
* If this field is a protocol, skip it - we already put
* it in above.
*/
if (proto_registrar_is_protocol(i))
continue;
hfinfo = proto_registrar_get_nth(i);
/*
* If this field isn't at the head of the list of
* fields with this name, skip this field - all
* fields with the same name are really just versions
* of the same field stored in different bits, and
* should have the same type/radix/value list, and
* just differ in their bit masks. (If a field isn't
* a bitfield, but can be, say, 1 or 2 bytes long,
* it can just be made FT_UINT16, meaning the
* *maximum* length is 2 bytes, and be used
* for all lengths.)
*/
if (hfinfo->same_name_prev != NULL)
continue;
if (!proto_is_protocol_enabled(find_protocol_by_id(
proto_registrar_get_parent(i)))) {
continue;
}
/* Create a node for the item, and put it
under its parent protocol. */
protocol_node = g_hash_table_lookup(proto_array,
GINT_TO_POINTER(proto_registrar_get_parent(i)));
if (hfinfo->blurb != NULL && hfinfo->blurb[0] != '\0') {
g_snprintf(str, TAG_STRING_LEN, "%s - %s (%s)", hfinfo->abbrev,
hfinfo->name, hfinfo->blurb);
} else {
g_snprintf(str, TAG_STRING_LEN, "%s - %s", hfinfo->abbrev,
hfinfo->name);
}
str[TAG_STRING_LEN]=0;
strp=str;
item_node = gtk_ctree_insert_node(GTK_CTREE(field_tree),
protocol_node, NULL,
&strp, 5,
NULL, NULL, NULL, NULL,
TRUE, FALSE);
gtk_ctree_node_set_row_data(GTK_CTREE(field_tree),
item_node, hfinfo);
}
g_hash_table_destroy(proto_array);
#else /* GTK_MAJOR_VERSION < 2 */
{
/* GTK2 code using two levels iterator to enumerate all protocol fields */
@ -1435,7 +1157,6 @@ dfilter_expr_dlg_new(GtkWidget *filter_te)
}
g_object_unref(G_OBJECT(store));
}
#endif /* GTK_MAJOR_VERSION < 2 */
range_label = gtk_label_new("Range (offset:length)");
gtk_misc_set_alignment(GTK_MISC(range_label), 0.0, 0.0);
@ -1478,16 +1199,6 @@ dfilter_expr_dlg_new(GtkWidget *filter_te)
value_list_scrolled_win);
OBJECT_SET_DATA(window, E_DFILTER_EXPR_OK_BT_KEY, ok_bt);
#if GTK_MAJOR_VERSION < 2
/*
* OK, we've finally built the entire list, complete with the row data,
* and attached to the top-level widget pointers to the relevant
* subwidgets, so it's safe to put the list in browse mode.
*/
gtk_clist_set_selection_mode (GTK_CLIST(field_tree),
GTK_SELECTION_BROWSE);
#endif
SIGNAL_CONNECT(window, "delete_event", dfilter_expr_dlg_delete_event_cb,
window);

77
gtk/dlg_utils.c
View File

@ -222,7 +222,7 @@ dlg_button_row_new(const gchar *stock_id_first, ...)
gtk_button_box_set_spacing(GTK_BUTTON_BOX(button_hbox), 5);
/* GTK+ 1.3 and later - on Win32, we use 1.3[.x] or 2.x, not 1.2[.x] */
#if !defined(_WIN32) && GTK_MAJOR_VERSION >= 2
#if !defined(_WIN32)
/* beware: sequence of buttons are important! */
/* XXX: this can be implemented more elegant of course, but it works as it should */
@ -379,11 +379,7 @@ dlg_window_new(const gchar *title)
{
GtkWidget *win;
#if GTK_MAJOR_VERSION < 2
win = window_new(GTK_WINDOW_DIALOG, title);
#else
win = window_new(GTK_WINDOW_TOPLEVEL, title);
#endif
/*
* XXX - if we're running in the capture child process, we can't easily
@ -429,74 +425,3 @@ dlg_activate (GtkWidget *widget _U_, gpointer ok_button)
gtk_widget_activate(GTK_WIDGET(ok_button));
}
#if GTK_MAJOR_VERSION < 2
/* Sigh. GTK+ appears not to acknowledge that it should be possible
to attach mnemonics to anything other than menu items; provide
routines to create radio and check buttons with labels that
include mnemonics. */
typedef struct {
GtkWidget *button;
GtkAccelGroup *accel_group;
} fix_label_args_t;
static void
dlg_fix_label_callback(GtkWidget *label_widget, gpointer data)
{
fix_label_args_t *args = data;
gchar *label;
guint accel_key;
gtk_label_get(GTK_LABEL(label_widget), &label);
accel_key = gtk_label_parse_uline(GTK_LABEL(label_widget), label);
if (accel_key != GDK_VoidSymbol) {
/* Yes, we have a mnemonic. */
gtk_widget_add_accelerator(args->button, "clicked", args->accel_group,
accel_key, 0, GTK_ACCEL_LOCKED);
gtk_widget_add_accelerator(args->button, "clicked", args->accel_group,
accel_key, GDK_MOD1_MASK, GTK_ACCEL_LOCKED);
}
}
static void
dlg_fix_button_label(GtkWidget *button, GtkAccelGroup *accel_group)
{
fix_label_args_t args;
args.button = button;
args.accel_group = accel_group;
gtk_container_foreach(GTK_CONTAINER(button), dlg_fix_label_callback, &args);
}
GtkWidget *
dlg_radio_button_new_with_label_with_mnemonic(GSList *group,
const gchar *label, GtkAccelGroup *accel_group)
{
GtkWidget *radio_button;
radio_button = gtk_radio_button_new_with_label (group, label);
dlg_fix_button_label(radio_button, accel_group);
return radio_button;
}
GtkWidget *
dlg_check_button_new_with_label_with_mnemonic(const gchar *label,
GtkAccelGroup *accel_group)
{
GtkWidget *check_button;
check_button = gtk_check_button_new_with_label (label);
dlg_fix_button_label(check_button, accel_group);
return check_button;
}
GtkWidget *
dlg_toggle_button_new_with_label_with_mnemonic(const gchar *label,
GtkAccelGroup *accel_group)
{
GtkWidget *toggle_button;
toggle_button = gtk_toggle_button_new_with_label (label);
dlg_fix_button_label(toggle_button, accel_group);
return toggle_button;
}
#endif

17
gtk/expert_comp_dlg.c
View File

@ -127,19 +127,6 @@ error_packet(void *pss, packet_info *pinfo _U_, epan_dissect_t *edt _U_, const v
}
#if (GTK_MAJOR_VERSION < 2)
static void
error_draw(void *pss)
{
expert_comp_dlg_t *ss=(expert_comp_dlg_t *)pss;
draw_error_table_data(&ss->error_table);
draw_error_table_data(&ss->warn_table);
draw_error_table_data(&ss->note_table);
draw_error_table_data(&ss->chat_table);
}
#endif
void protect_thread_critical_region(void);
void unprotect_thread_critical_region(void);
static void
@ -267,11 +254,7 @@ expert_comp_init(const char *optarg _U_, void* userdata _U_)
/* Register the tap listener */
#if (GTK_MAJOR_VERSION < 2)
error_string=register_tap_listener("expert", ss, filter, error_reset, error_packet, error_draw);
#else
error_string=register_tap_listener("expert", ss, filter, error_reset, error_packet, NULL);
#endif
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, error_string->str);
g_string_free(error_string, TRUE);

262
gtk/expert_comp_table.c
View File

@ -38,11 +38,6 @@
#include "epan/packet_info.h"
#include "expert_comp_table.h"
#if (GTK_MAJOR_VERSION < 2)
#include "image/clist_ascend.xpm"
#include "image/clist_descend.xpm"
#endif
#include "simple_dialog.h"
#include "globals.h"
#include "gtk/find_dlg.h"
@ -63,7 +58,6 @@
#define SORT_ALPHABETICAL 0
#if (GTK_MAJOR_VERSION >= 2)
static gint
sort_iter_compare_func (GtkTreeModel *model,
GtkTreeIter *a,
@ -98,86 +92,7 @@ gpointer userdata)
}
return ret;
}
#endif
#if (GTK_MAJOR_VERSION < 2)
typedef struct column_arrows {
GtkWidget *table;
GtkWidget *ascend_pm;
GtkWidget *descend_pm;
} column_arrows;
static void
error_click_column_cb(GtkCList *clist, gint column, gpointer data)
{
column_arrows *col_arrows = (column_arrows *) data;
int i;
gtk_clist_freeze(clist);
for (i = 0; i < 4; i++) {
gtk_widget_hide(col_arrows[i].ascend_pm);
gtk_widget_hide(col_arrows[i].descend_pm);
}
if (column == clist->sort_column) {
if (clist->sort_type == GTK_SORT_ASCENDING) {
clist->sort_type = GTK_SORT_DESCENDING;
gtk_widget_show(col_arrows[column].descend_pm);
} else {
clist->sort_type = GTK_SORT_ASCENDING;
gtk_widget_show(col_arrows[column].ascend_pm);
}
} else {
if(column>=2){
clist->sort_type = GTK_SORT_DESCENDING;
gtk_widget_show(col_arrows[column].descend_pm);
} else {
clist->sort_type = GTK_SORT_ASCENDING;
gtk_widget_show(col_arrows[column].ascend_pm);
}
gtk_clist_set_sort_column(clist, column);
}
gtk_clist_thaw(clist);
gtk_clist_sort(clist);
}
static gint
error_sort_column(GtkCList *clist, gconstpointer ptr1, gconstpointer ptr2)
{
char *text1 = NULL;
char *text2 = NULL;
float f1,f2;
const GtkCListRow *row1 = ptr1;
const GtkCListRow *row2 = ptr2;
text1 = GTK_CELL_TEXT (row1->cell[clist->sort_column])->text;
text2 = GTK_CELL_TEXT (row2->cell[clist->sort_column])->text;
switch(clist->sort_column){
case 0:
case 2:
case 1:
return strcmp (text1, text2);
case 3:
case 4:
case 5:
sscanf(text1,"%f",&f1);
sscanf(text2,"%f",&f2);
if(fabs(f1-f2)<0.000005)
return 0;
if(f1>f2)
return 1;
return -1;
}
g_assert_not_reached();
return 0;
}
#else
enum
{
GROUP_COLUMN,
@ -186,7 +101,6 @@ enum
COUNT_COLUMN,
N_COLUMNS
};
#endif
static gint find_summary_data(error_equiv_table *err, const expert_info_t *expert_data)
{
@ -243,19 +157,14 @@ error_select_filter_cb(GtkWidget *widget _U_, gpointer callback_data, guint call
char str[256];
const char *current_filter;
#if (GTK_MAJOR_VERSION >= 2)
GtkTreeIter iter;
GtkTreeModel *model;
const expert_info_t expert_data;
#endif
action=FILTER_ACTION(callback_action);
type=FILTER_ACTYPE(callback_action);
#if (GTK_MAJOR_VERSION < 2)
selection=GPOINTER_TO_INT(g_list_nth_data(GTK_CLIST(err->table)->selection, 0));
#else
gtk_tree_selection_get_selected(err->select, &model, &iter);
gtk_tree_model_get (model, &iter, GROUP_COLUMN, &expert_data.group, -1);
@ -268,17 +177,11 @@ error_select_filter_cb(GtkWidget *widget _U_, gpointer callback_data, guint call
}
selection = find_summary_data(err, &expert_data);
#endif
if(selection>=(int)err->num_procs){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "No items are selected");
return;
}
#if (GTK_MAJOR_VERSION < 2)
/* translate it back from row index to index in procedures array */
selection=GPOINTER_TO_INT(gtk_clist_get_row_data(err->table, selection));
#endif
current_filter=gtk_entry_get_text(GTK_ENTRY(main_display_filter_widget));
/* Some expert data doesn't pass an expert item. Without this we cannot create a filter */
@ -391,12 +294,6 @@ error_select_filter_cb(GtkWidget *widget _U_, gpointer callback_data, guint call
g_snprintf(str, 255, "http://www.google.com/search?hl=en&q=%s+'%s'", err->procedures[selection].entries[1], err->procedures[selection].entries[2]);
browser_open_url(str);
break;
#if (GTK_MAJOR_VERSION < 2)
case 7:
/* Goto the first occurance (packet) in the trace */
cf_goto_frame(&cfile, err->procedures[selection].packet_num);
break;
#endif
default:
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Can't find menu action - %u", action);
}
@ -498,14 +395,8 @@ static GtkItemFactoryEntry error_list_menu_items[] =
/* Search Internet */
ITEM_FACTORY_ENTRY("/Internet Search for Info Text", NULL,
error_select_filter_cb, CALLBACK_WEB_LOOKUP, NULL, NULL),
#if (GTK_MAJOR_VERSION < 2)
/* Go to first packet matching this entry */
ITEM_FACTORY_ENTRY("/Goto First Occurrence", NULL,
error_select_filter_cb, 7*256+0, NULL, NULL),
#endif
};
#if (GTK_MAJOR_VERSION >= 2)
static void
expert_goto_pkt_cb (GtkTreeSelection *selection, gpointer data _U_)
{
@ -526,7 +417,6 @@ expert_goto_pkt_cb (GtkTreeSelection *selection, gpointer data _U_)
g_free (grp);
}
}
#endif
static void
error_create_popup_menu(error_equiv_table *err)
@ -534,96 +424,23 @@ error_create_popup_menu(error_equiv_table *err)
GtkItemFactory *item_factory;
#if (GTK_MAJOR_VERSION >= 2)
err->select = gtk_tree_view_get_selection (GTK_TREE_VIEW (err->tree_view));
gtk_tree_selection_set_mode (err->select, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (err->select), "changed",
G_CALLBACK (expert_goto_pkt_cb),
err);
#endif
item_factory = gtk_item_factory_new(GTK_TYPE_MENU, "<main>", NULL);
gtk_item_factory_create_items_ac(item_factory, sizeof(error_list_menu_items)/sizeof(error_list_menu_items[0]), error_list_menu_items, err, 2);
err->menu = gtk_item_factory_get_widget(item_factory, "<main>");
#if (GTK_MAJOR_VERSION >= 2)
SIGNAL_CONNECT(err->tree_view, "button_press_event", error_show_popup_menu_cb, err);
#else
SIGNAL_CONNECT(err->table, "button_press_event", error_show_popup_menu_cb, err);
#endif
}
void
init_error_table(error_equiv_table *err, guint16 num_procs, GtkWidget *vbox)
{
guint16 i, j;
#if (GTK_MAJOR_VERSION < 2)
column_arrows *col_arrows;
GdkBitmap *ascend_bm, *descend_bm;
GdkPixmap *ascend_pm, *descend_pm;
GtkStyle *win_style;
GtkWidget *column_lb;
const char *default_titles[] = { "Group", "Protocol", "Summary", "Count"};
err->scrolled_window=scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(vbox), err->scrolled_window, TRUE, TRUE, 0);
err->table=(GtkCList *)gtk_clist_new(4);
gtk_widget_show(GTK_WIDGET(err->table));
gtk_widget_show(err->scrolled_window);
col_arrows = (column_arrows *) g_malloc(sizeof(column_arrows) * 4);
win_style = gtk_widget_get_style(err->scrolled_window);
ascend_pm = gdk_pixmap_create_from_xpm_d(err->scrolled_window->window,
&ascend_bm,
&win_style->bg[GTK_STATE_NORMAL],
(gchar **)clist_ascend_xpm);
descend_pm = gdk_pixmap_create_from_xpm_d(err->scrolled_window->window,
&descend_bm,
&win_style->bg[GTK_STATE_NORMAL],
(gchar **)clist_descend_xpm);
for (i = 0; i < 4; i++) {
col_arrows[i].table = gtk_table_new(2, 2, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(col_arrows[i].table), 5);
column_lb = gtk_label_new(default_titles[i]);
gtk_table_attach(GTK_TABLE(col_arrows[i].table), column_lb, 0, 1, 0, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show(column_lb);
col_arrows[i].ascend_pm = gtk_pixmap_new(ascend_pm, ascend_bm);
gtk_table_attach(GTK_TABLE(col_arrows[i].table), col_arrows[i].ascend_pm, 1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
col_arrows[i].descend_pm = gtk_pixmap_new(descend_pm, descend_bm);
gtk_table_attach(GTK_TABLE(col_arrows[i].table), col_arrows[i].descend_pm, 1, 2, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0);
if (i == 3) {
gtk_widget_show(col_arrows[i].descend_pm);
}
gtk_clist_set_column_widget(GTK_CLIST(err->table), i, col_arrows[i].table);
gtk_widget_show(col_arrows[i].table);
}
gtk_clist_column_titles_show(GTK_CLIST(err->table));
gtk_clist_set_compare_func(err->table, error_sort_column);
gtk_clist_set_sort_column(err->table, 3);
gtk_clist_set_sort_type(err->table, GTK_SORT_DESCENDING);
/*XXX instead of this we should probably have some code to
dynamically adjust the width of the columns */
gtk_clist_set_column_width(err->table, 0, 75);
gtk_clist_set_column_width(err->table, 1, 75);
gtk_clist_set_column_width(err->table, 2, 400);
gtk_clist_set_column_width(err->table, 3, 50);
gtk_clist_set_shadow_type(err->table, GTK_SHADOW_IN);
gtk_clist_column_titles_show(err->table);
gtk_container_add(GTK_CONTAINER(err->scrolled_window), (GtkWidget *)err->table);
SIGNAL_CONNECT(err->table, "click-column", error_click_column_cb, col_arrows);
gtk_widget_show(GTK_WIDGET(err->table));
#else
GtkTreeStore *store;
GtkWidget *tree;
GtkTreeViewColumn *column;
@ -693,7 +510,6 @@ init_error_table(error_equiv_table *err, guint16 num_procs, GtkWidget *vbox)
/* Now enable the sorting of each column */
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(err->tree_view), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(err->tree_view), TRUE);
#endif
gtk_widget_show(err->scrolled_window);
@ -716,34 +532,12 @@ init_error_table_row(error_equiv_table *err, const expert_info_t *expert_data)
guint16 j;
gint row=0;
#if (GTK_MAJOR_VERSION >= 2)
GtkTreeStore *store;
#endif
/* we have discovered a new procedure. Extend the table accordingly */
row = find_summary_data(err, expert_data);
if(row==-1){
/* First time we have seen this event so initialize memory table */
#if (GTK_MAJOR_VERSION < 2)
row = 0;
old_num_procs++;
err->procedures=g_realloc(err->procedures, (sizeof(error_procedure_t)*(old_num_procs+1)));
err->procedures[err->num_procs].count=0;
for(j=0;j<4;j++)
{
err->procedures[err->num_procs].entries[j]=NULL;
}
err->procedures[err->num_procs].packet_num = (guint32)expert_data->packet_num; /* First packet num */
err->procedures[err->num_procs].entries[0]=(char *)g_strdup(val_to_str(expert_data->group, expert_group_vals,"Unknown group (%u)")); /* Group */
err->procedures[err->num_procs].entries[1]=(char *)g_strdup(expert_data->protocol); /* Protocol */
err->procedures[err->num_procs].entries[2]=(char *)g_strdup(expert_data->summary); /* Summary */
err->procedures[err->num_procs].entries[3]=(char *)g_strdup_printf("%d", err->procedures[row].count); /* Count */
err->procedures[err->num_procs].fvalue_value = NULL;
}
/* Store the updated count of events */
err->num_procs = old_num_procs;
#else
row = old_num_procs; /* Number of expert events since this is a new event */
err->procedures=g_realloc(err->procedures, (sizeof(error_procedure_t)*(old_num_procs+1)));
err->procedures[row].count=0; /* count of events for this item */
@ -787,7 +581,6 @@ init_error_table_row(error_equiv_table *err, const expert_info_t *expert_data)
/* Update the tree with new count for this event */
store = GTK_TREE_STORE(gtk_tree_view_get_model(err->tree_view));
gtk_tree_store_set(store, &err->procedures[row].iter, COUNT_COLUMN, err->procedures[row].count, -1);
#endif
}
void
@ -795,12 +588,8 @@ add_error_table_data(error_equiv_table *err, const expert_info_t *expert_data)
{
error_procedure_t *errp;
gint index;
#if (GTK_MAJOR_VERSION < 2)
gint row;
#else
GtkTreeStore *store;
GtkTreeIter new_iter;
#endif
index = find_summary_data(err,expert_data);
@ -813,15 +602,6 @@ add_error_table_data(error_equiv_table *err, const expert_info_t *expert_data)
}
errp=&err->procedures[index];
#if (GTK_MAJOR_VERSION < 2)
if (errp->count==0){
row=gtk_clist_append(err->table, err->procedures[index].entries);
gtk_clist_set_row_data(err->table, row, GINT_TO_POINTER(index));
}
errp->count++;
err->procedures[index].entries[3] = (char *)g_strdup_printf("%d", errp->count);
#else
store = GTK_TREE_STORE(gtk_tree_view_get_model(err->tree_view));
gtk_tree_store_append(store, &new_iter, &errp->iter);
@ -830,61 +610,24 @@ add_error_table_data(error_equiv_table *err, const expert_info_t *expert_data)
GROUP_COLUMN, "Packet:",
PROTOCOL_COLUMN, (char *)g_strdup_printf("%d", expert_data->packet_num),
-1);
#endif
}
#if (GTK_MAJOR_VERSION < 2)
void
draw_error_table_data(error_equiv_table *err)
{
int i,j;
char *strp;
for(i=0;i<err->num_procs;i++){
/* ignore procedures with no calls (they don't have CList rows) */
if(err->procedures[i].count==0){
continue;
}
j=gtk_clist_find_row_from_data(err->table, GINT_TO_POINTER(i));
strp=g_strdup_printf("%d", err->procedures[i].count);
gtk_clist_set_text(err->table, j, 3, strp);
err->procedures[i].entries[3]=(char *)strp;
}
gtk_clist_sort(err->table);
}
#endif
void
reset_error_table_data(error_equiv_table *err)
{
guint16 i;
#if (GTK_MAJOR_VERSION >= 2)
GtkTreeStore *store;
#endif
for(i=0;i<err->num_procs;i++){
err->procedures[i].entries[0] = NULL;
err->procedures[i].entries[1] = NULL;
err->procedures[i].entries[2] = NULL;
err->procedures[i].entries[3] = NULL;
#if (GTK_MAJOR_VERSION < 2)
err->procedures[i].packet_num=0;
#else
err->procedures[i].count=0;
#endif
}
#if (GTK_MAJOR_VERSION < 2)
gtk_clist_clear(err->table);
#else
store = GTK_TREE_STORE(gtk_tree_view_get_model(err->tree_view));
gtk_tree_store_clear(store);
#endif
err->num_procs = 0;
}
@ -899,12 +642,7 @@ free_error_table_data(error_equiv_table *err)
err->procedures[i].entries[j]=NULL;
}
err->procedures[i].fvalue_value=NULL;
#if (GTK_MAJOR_VERSION < 2)
err->procedures[i].packet_num=0;
#else
err->procedures[i].count=0;
#endif
}
}
err->procedures=NULL;

2
gtk/file_dlg.c
View File

@ -129,9 +129,7 @@ file_selection_new(const gchar *title, file_selection_action_t action _U_)
char *u3devicedocumentpath;
#endif
win = gtk_file_selection_new(title);
#if GTK_MAJOR_VERSION >= 2
gtk_window_set_position(GTK_WINDOW(win), GTK_WIN_POS_CENTER_ON_PARENT);
#endif
gtk_window_set_transient_for(GTK_WINDOW(win), GTK_WINDOW(top_level));
/* XXX - why are we doing this? We don't do it with the GtkFileChooser,