osmocom/wireshark
14
0
Fork 1
Code Issues Pull requests Projects Releases Wiki Activity
wireshark/gtk/color_dlg.c
Guy Harris 115700bc62 From Richard Urwin: 
use Export and Import for the buttons in GTK+ 2.x as well;

	get rid of a duplicate fclose;

	other fixes.

Update the description of color filters in the Ethereal man page to
reflect the change, clean up the formatting (use =item), and add the
global and personal color filters files to the FILES section; refer to
them as "color filters" files rather than "colorfilters" files, as the
FILES section gives the "colorfilters" file name so you don't have to
use that as the name.

Clean up white space.

svn path=/trunk/; revision=8285
2003-08-27 22:55:51 +00:00

1716 lines
61 KiB
C
Raw Blame History

/* color_dlg.c
* Definitions for dialog boxes for color filters
*
* $Id: color_dlg.c,v 1.26 2003/08/27 22:55:51 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* 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.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <gtk/gtk.h>
#include <string.h>
#include "gtk/main.h"
#include <epan/packet.h>
#include "color.h"
#include "colors.h"
#include "color_filters.h"
#include "color_dlg.h"
#include "color_utils.h"
#include "file.h"
#include <epan/dfilter/dfilter.h>
#include "simple_dialog.h"
#include "dlg_utils.h"
#include "ui_util.h"
#include "dfilter_expr_dlg.h"
#include "compat_macros.h"
#include "file_dlg.h"
static GtkWidget* colorize_dialog_new(void);
static void add_filter_to_list(gpointer filter_arg, gpointer list_arg);
static void color_filter_up_cb(GtkButton *button, gpointer user_data);
static void color_filter_down_cb(GtkButton *button, gpointer user_data);
#if GTK_MAJOR_VERSION < 2
static void remember_selected_row(GtkCList *clist, gint row, gint column,
GdkEvent *event, gpointer user_data);
static void unremember_selected_row(GtkCList *clist, gint row, gint column,
GdkEvent *event, gpointer user_data);
#else
static void remember_selected_row(GtkTreeSelection *sel, gpointer list);
#endif
static void color_destroy_cb(GtkButton *button, gpointer user_data);
static void destroy_edit_dialog_cb(gpointer filter_arg, gpointer dummy);
static void color_new_cb(GtkButton *button, gpointer user_data);
static void color_edit_cb(GtkButton *button, gpointer user_data);
static void color_delete_cb(GtkWidget *widget, gpointer user_data);
static void color_save_cb(GtkButton *button, gpointer user_data);
static void color_ok_cb(GtkButton *button, gpointer user_data);
static void color_cancel_cb(GtkWidget *widget, gpointer user_data);
static void color_apply_cb(GtkButton *button, gpointer user_data);
static void color_revert_cb(GtkWidget *button, gpointer user_data);
static void color_import_cb(GtkButton *button, gpointer user_data );
static void edit_color_filter_dialog_new(GtkWidget *color_filters,
GtkWidget **colorize_filter_name,
GtkWidget **colorize_filter_text);
#if GTK_MAJOR_VERSION < 2
static void edit_color_filter_destroy_cb(GtkObject *object, gpointer user_data);
#else
static void edit_color_filter_destroy_cb(GObject *object, gpointer user_data);
#endif
static void edit_color_filter_fg_cb(GtkButton *button, gpointer user_data);
static void edit_color_filter_bg_cb(GtkButton *button, gpointer user_data);
static void edit_color_filter_ok_cb(GtkButton *button, gpointer user_data);
static void edit_color_filter_cancel_cb(GtkObject *object, gpointer user_data);
static GtkWidget* color_sel_win_new(color_filter_t *colorf, gboolean);
static void color_sel_ok_cb(GtkButton *button, gpointer user_data);
static void color_sel_cancel_cb(GtkObject *object, gpointer user_data);
static GtkWidget *colorize_win;
static gint num_of_filters; /* number of filters being displayed */
static gint row_selected; /* row in color_filters that is selected */
static gchar *titles[2] = { "Name", "String" };
#define COLOR_UP_LB "color_up_lb"
#define COLOR_DOWN_LB "color_down_lb"
#define COLOR_EDIT_LB "color_edit_lb"
#define COLOR_DELETE_LB "color_delete_lb"
#define COLOR_FILTERS_CL "color_filters_cl"
#define COLOR_FILTER "color_filter"
#define COLOR_SELECTION_FG "color_selection_fg"
#define COLOR_SELECTION_BG "color_selection_bg"
#define COLOR_SELECTION_PARENT "color_selection_parent"
static void
filter_expr_cb(GtkWidget *w _U_, gpointer filter_te)
{
dfilter_expr_dlg_new(GTK_WIDGET(filter_te));
}
/* Callback for the "Display:Colorize Display" menu item. */
void
color_display_cb(GtkWidget *w _U_, gpointer d _U_)
{
if (colorize_win != NULL) {
/* There's already a color dialog box active; reactivate it. */
reactivate_window(colorize_win);
} else {
/* Create a new "Colorize Display" dialog. */
colorize_win = colorize_dialog_new();
}
}
/* if this filter is marked count it in the given int* */
static void
count_this_mark(gpointer filter_arg, gpointer counter_arg)
{
color_filter_t *colorf = filter_arg;
int * cnt = counter_arg;
if (colorf->marked)
(*cnt)++;
}
/* TODO: implement count of selected filters. Plug in to file_dlg update of "export selected" checkbox. */
int color_marked_count(void)
{
int count = 0;
g_slist_foreach(filter_list, count_this_mark, &count);
return count;
}
/* Create the "Apply Color Filters" dialog. */
static GtkWidget*
colorize_dialog_new (void)
{
GtkWidget *color_win;
GtkWidget *dlg_vbox;
GtkWidget *main_hbox;
GtkTooltips *tooltips;
GtkWidget *order_fr;
GtkWidget *order_vbox;
GtkWidget *color_filter_up;
GtkWidget *order_move_label;
GtkWidget *color_filter_down;
GtkWidget *list_fr;
GtkWidget *list_vbox;
GtkWidget *scrolledwindow1;
GtkWidget *color_filters;
GtkWidget *list_label;
GtkWidget *edit_fr;
GtkWidget *button_edit_vbox;
GtkWidget *color_new;
GtkWidget *color_edit;
GtkWidget *color_delete;
GtkWidget *button_ok_hbox;
GtkWidget *importexport_vbox;
GtkWidget *okapply_vbox;
GtkWidget *saverevert_vbox;
GtkWidget *color_ok;
GtkWidget *color_apply;
GtkWidget *color_save;
GtkWidget *color_export;
GtkWidget *color_import;
GtkWidget *color_revert;
GtkWidget *color_cancel;
#if GTK_MAJOR_VERSION >= 2
GtkListStore *store;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
#endif
row_selected = -1; /* no row selected */
tooltips = gtk_tooltips_new ();
/* Resizing of the dialog window is now reasonably done.
* Default size is set so that it should fit into every usual screen resolution.
* All other widgets are always packed depending on the current window size. */
color_win = dlg_window_new ("Ethereal: Apply Color Filters");
OBJECT_SET_DATA(color_win, "color_win", color_win);
gtk_window_set_default_size(GTK_WINDOW(color_win), 600, 350);
dlg_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (dlg_vbox);
OBJECT_SET_DATA_FULL(color_win, "dlg_vbox", dlg_vbox, gtk_widget_unref);
gtk_container_set_border_width (GTK_CONTAINER (dlg_vbox), 5);
gtk_widget_show (dlg_vbox);
gtk_container_add (GTK_CONTAINER (color_win), dlg_vbox);
main_hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (main_hbox);
OBJECT_SET_DATA_FULL(color_win, "main_hbox", main_hbox, gtk_widget_unref);
gtk_widget_show (main_hbox);
gtk_box_pack_start (GTK_BOX (dlg_vbox), main_hbox, TRUE, TRUE, 0);
/* order frame */
order_fr = gtk_frame_new("Order");
gtk_box_pack_start (GTK_BOX (main_hbox), order_fr, FALSE, FALSE, 0);
gtk_widget_show(order_fr);
order_vbox = gtk_vbox_new (TRUE, 0);
gtk_widget_ref (order_vbox);
OBJECT_SET_DATA_FULL(color_win, "order_vbox", order_vbox, gtk_widget_unref);
gtk_container_set_border_width (GTK_CONTAINER (order_vbox), 5);
gtk_widget_show (order_vbox);
gtk_container_add(GTK_CONTAINER(order_fr), order_vbox);
color_filter_up = gtk_button_new_with_label (("Up"));
gtk_widget_ref (color_filter_up);
OBJECT_SET_DATA_FULL(color_win, "color_filter_up", color_filter_up, gtk_widget_unref);
WIDGET_SET_SIZE (color_filter_up, -1, 20);
gtk_widget_show (color_filter_up);
gtk_box_pack_start (GTK_BOX (order_vbox), color_filter_up, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, color_filter_up, ("Move filter higher in list"), NULL);
gtk_widget_set_sensitive (color_filter_up, FALSE);
order_move_label = gtk_label_new (("Move\nselected filter\nup or down"));
gtk_widget_ref (order_move_label);
OBJECT_SET_DATA_FULL(color_win, "order_move_label", order_move_label, gtk_widget_unref);
gtk_widget_show (order_move_label);
gtk_box_pack_start (GTK_BOX (order_vbox), order_move_label, FALSE, FALSE, 0);
color_filter_down = gtk_button_new_with_label (("Down"));
gtk_widget_ref (color_filter_down);
OBJECT_SET_DATA_FULL(color_win, "color_filter_down", color_filter_down,
gtk_widget_unref);
WIDGET_SET_SIZE(color_filter_down, -1, 20);
gtk_widget_show (color_filter_down);
gtk_box_pack_start (GTK_BOX (order_vbox), color_filter_down, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, color_filter_down, ("Move filter lower in list"), NULL);
gtk_widget_set_sensitive (color_filter_down, FALSE);
/* End order_frame */
/* list frame */
list_fr = gtk_frame_new("Filter");
gtk_box_pack_start (GTK_BOX (main_hbox), list_fr, TRUE, TRUE, 0);
gtk_widget_show(list_fr);
list_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (list_vbox);
OBJECT_SET_DATA_FULL(color_win, "list_vbox", list_vbox, gtk_widget_unref);
gtk_container_set_border_width (GTK_CONTAINER (list_vbox), 5);
gtk_widget_show (list_vbox);
gtk_container_add(GTK_CONTAINER(list_fr), list_vbox);
list_label = gtk_label_new (("[List is processed in order until match is found]"));
gtk_widget_ref (list_label);
OBJECT_SET_DATA_FULL(color_win, "list_label", list_label, gtk_widget_unref);
gtk_widget_show (list_label);
gtk_box_pack_start (GTK_BOX (list_vbox), list_label, FALSE, FALSE, 0);
/* create the list of filters */
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
#if GTK_MAJOR_VERSION >= 2
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
#endif
gtk_widget_ref (scrolledwindow1);
OBJECT_SET_DATA_FULL(color_win, "scrolledwindow1", scrolledwindow1, gtk_widget_unref);
gtk_widget_show (scrolledwindow1);
gtk_box_pack_start (GTK_BOX (list_vbox), scrolledwindow1, TRUE, TRUE, 0);
#if GTK_MAJOR_VERSION < 2
color_filters = gtk_clist_new_with_titles(2, titles);
#else
/* the list store contains : filter name, filter string, foreground
* color, background color, pointer to color filter */
store = gtk_list_store_new(5, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
color_filters = tree_view_new(GTK_TREE_MODEL(store));
g_object_unref(store);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(titles[0], renderer, "text",
0, "foreground", 2,
"background", 3, NULL);
gtk_tree_view_column_set_fixed_width(column, 80);
gtk_tree_view_append_column(GTK_TREE_VIEW(color_filters), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(titles[1], renderer, "text",
1, "foreground", 2,
"background", 3, NULL);
gtk_tree_view_column_set_fixed_width(column, 300);
gtk_tree_view_append_column(GTK_TREE_VIEW(color_filters), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(color_filters), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(color_filters), FALSE);
#endif
num_of_filters = 0;
g_slist_foreach(filter_list, add_filter_to_list, color_filters);
#if GTK_MAJOR_VERSION >= 2
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
#else
gtk_clist_set_selection_mode (GTK_CLIST (color_filters),GTK_SELECTION_EXTENDED);
#endif
gtk_widget_show (color_filters);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), color_filters);
#if GTK_MAJOR_VERSION < 2
gtk_clist_set_column_width (GTK_CLIST (color_filters), 0, 80);
gtk_clist_set_column_width (GTK_CLIST (color_filters), 1, 300);
gtk_clist_column_titles_show (GTK_CLIST (color_filters));
#endif
/* end list_frame */
/* edit buttons frame */
edit_fr = gtk_frame_new("Edit");
gtk_box_pack_start (GTK_BOX (main_hbox), edit_fr, FALSE, FALSE, 0);
gtk_widget_show(edit_fr);
/* button_edit_vbox is first button column (containing: new, edit and such) */
button_edit_vbox = gtk_vbutton_box_new();
gtk_widget_ref (button_edit_vbox);
OBJECT_SET_DATA_FULL(color_win, "button_edit_vbox", button_edit_vbox, gtk_widget_unref);
gtk_button_box_set_child_size(GTK_BUTTON_BOX(button_edit_vbox), 50, 20);
gtk_container_set_border_width (GTK_CONTAINER (button_edit_vbox), 5);
gtk_widget_show (button_edit_vbox);
gtk_container_add(GTK_CONTAINER(edit_fr), button_edit_vbox);
#if GTK_MAJOR_VERSION < 2
color_new = gtk_button_new_with_label (("New..."));
#else
color_new = gtk_button_new_from_stock(GTK_STOCK_NEW);
#endif
gtk_widget_ref (color_new);
OBJECT_SET_DATA_FULL(color_win, "color_new", color_new, gtk_widget_unref);
gtk_widget_show (color_new);
#if GTK_MAJOR_VERSION < 2
WIDGET_SET_SIZE(color_new, 50, 20);
#endif
gtk_box_pack_start (GTK_BOX (button_edit_vbox), color_new, FALSE, FALSE, 5);
gtk_tooltips_set_tip (tooltips, color_new, ("Create a new filter after the selected filter"), NULL);
color_edit = gtk_button_new_with_label (("Edit..."));
gtk_widget_ref (color_edit);
OBJECT_SET_DATA_FULL(color_win, "color_edit", color_edit, gtk_widget_unref);
gtk_widget_show (color_edit);
#if GTK_MAJOR_VERSION < 2
WIDGET_SET_SIZE(color_edit, 50, 20);
#endif
gtk_box_pack_start (GTK_BOX (button_edit_vbox), color_edit, FALSE, FALSE, 5);
gtk_tooltips_set_tip (tooltips, color_edit, ("Edit the selected filter"), NULL);
gtk_widget_set_sensitive (color_edit, FALSE);
#if GTK_MAJOR_VERSION < 2
color_delete = gtk_button_new_with_label (("Delete"));
#else
color_delete = gtk_button_new_from_stock(GTK_STOCK_DELETE);
#endif
gtk_widget_ref (color_delete);
OBJECT_SET_DATA_FULL(color_win, "color_delete", color_delete, gtk_widget_unref);
gtk_widget_show (color_delete);
gtk_box_pack_start (GTK_BOX (button_edit_vbox), color_delete, FALSE, FALSE, 5);
WIDGET_SET_SIZE (color_delete, 50, 20);
gtk_tooltips_set_tip (tooltips, color_delete, ("Delete the selected filter"), NULL);
gtk_widget_set_sensitive (color_delete, FALSE);
/* End edit buttons frame */
/* button_ok_hbox is bottom button row */
button_ok_hbox = gtk_hbutton_box_new();
gtk_widget_ref (button_ok_hbox);
OBJECT_SET_DATA_FULL(color_win, "button_ok_hbox", button_ok_hbox, gtk_widget_unref);
gtk_widget_show (button_ok_hbox);
gtk_box_pack_start (GTK_BOX (dlg_vbox), button_ok_hbox, FALSE, FALSE, 5);
okapply_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (okapply_vbox);
OBJECT_SET_DATA_FULL(color_win, "okapply_vbox", okapply_vbox, gtk_widget_unref);
gtk_widget_show (okapply_vbox);
gtk_box_pack_start (GTK_BOX (button_ok_hbox), okapply_vbox, TRUE, TRUE, 0);
#if GTK_MAJOR_VERSION < 2
color_ok = gtk_button_new_with_label (("OK"));
#else
color_ok = gtk_button_new_from_stock(GTK_STOCK_OK);
#endif
gtk_widget_ref (color_ok);
OBJECT_SET_DATA_FULL(color_win, "color_ok", color_ok, gtk_widget_unref);
gtk_widget_show (color_ok);
gtk_box_pack_start (GTK_BOX (okapply_vbox), color_ok, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, color_ok, ("Accept filter list; apply changes"), NULL);
#if GTK_MAJOR_VERSION < 2
color_apply = gtk_button_new_with_label (("Apply"));
#else
color_apply = gtk_button_new_from_stock(GTK_STOCK_APPLY);
#endif
gtk_widget_ref (color_apply);
OBJECT_SET_DATA_FULL(color_win, "color_apply", color_apply, gtk_widget_unref);
gtk_widget_show (color_apply);
gtk_box_pack_start (GTK_BOX (okapply_vbox), color_apply, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, color_apply, ("Apply filters in list"), NULL);
saverevert_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (saverevert_vbox);
OBJECT_SET_DATA_FULL(color_win, "saverevert_vbox", saverevert_vbox, gtk_widget_unref);
gtk_widget_show (saverevert_vbox);
gtk_box_pack_start (GTK_BOX (button_ok_hbox), saverevert_vbox, TRUE, TRUE, 0);
#if GTK_MAJOR_VERSION < 2
color_save = gtk_button_new_with_label (("Save"));
#else
color_save = gtk_button_new_from_stock(GTK_STOCK_SAVE);
#endif
gtk_widget_ref(color_save);
OBJECT_SET_DATA_FULL(color_win, "color_save", color_save, gtk_widget_unref);
gtk_widget_show(color_save);
gtk_box_pack_start(GTK_BOX (saverevert_vbox), color_save, FALSE, FALSE, 0);
gtk_tooltips_set_tip(tooltips, color_save, ("Save all filters to disk"), NULL);
#if GTK_MAJOR_VERSION < 2
color_revert = gtk_button_new_with_label (("Revert"));
#else
color_revert = gtk_button_new_from_stock(GTK_STOCK_REVERT_TO_SAVED);
#endif
gtk_widget_ref(color_revert);
OBJECT_SET_DATA_FULL(color_win, "color_revert", color_revert, gtk_widget_unref);
gtk_widget_show(color_revert);
gtk_box_pack_start(GTK_BOX (saverevert_vbox), color_revert, FALSE, FALSE, 0);
gtk_tooltips_set_tip(tooltips, color_revert, ("Delete filter file and revert to system-wide default filter set"), NULL);
importexport_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (importexport_vbox);
OBJECT_SET_DATA_FULL(color_win, "importexport_vbox", importexport_vbox, gtk_widget_unref);
gtk_widget_show (importexport_vbox);
gtk_box_pack_start (GTK_BOX (button_ok_hbox), importexport_vbox, TRUE, TRUE, 0);
color_export = gtk_button_new_with_label (("Export..."));
gtk_widget_ref(color_export);
gtk_widget_show(color_export);
gtk_box_pack_start(GTK_BOX (importexport_vbox), color_export, FALSE, FALSE, 0);
gtk_tooltips_set_tip(tooltips, color_export, ("Save all/marked filters to specified file"), NULL);
color_import = gtk_button_new_with_label (("Import..."));
gtk_widget_ref(color_import);
gtk_widget_show(color_import);
gtk_box_pack_start(GTK_BOX (importexport_vbox), color_import, FALSE, FALSE, 0);
gtk_tooltips_set_tip(tooltips, color_import, ("Include filters from specified file"), NULL);
#if GTK_MAJOR_VERSION < 2
color_cancel = gtk_button_new_with_label (("Cancel"));
#else
color_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
#endif
gtk_widget_ref (color_cancel);
OBJECT_SET_DATA_FULL(color_win, "color_cancel", color_cancel, gtk_widget_unref);
gtk_widget_show (color_cancel);
gtk_box_pack_start (GTK_BOX (button_ok_hbox), color_cancel, TRUE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, color_cancel, ("No more filter changes; don't apply"), NULL);
/* signals and such */
SIGNAL_CONNECT(color_win, "destroy", color_destroy_cb, NULL);
OBJECT_SET_DATA(color_filter_up, COLOR_FILTERS_CL, color_filters);
SIGNAL_CONNECT(color_filter_up, "clicked", color_filter_up_cb, NULL);
OBJECT_SET_DATA(color_filter_down, COLOR_FILTERS_CL, color_filters);
SIGNAL_CONNECT(color_filter_down, "clicked", color_filter_down_cb, NULL);
#if GTK_MAJOR_VERSION < 2
SIGNAL_CONNECT(color_filters, "select_row", remember_selected_row, NULL);
SIGNAL_CONNECT(color_filters, "unselect_row", unremember_selected_row, NULL);
#else
SIGNAL_CONNECT(selection, "changed", remember_selected_row, color_filters);
#endif
OBJECT_SET_DATA(color_filters, COLOR_UP_LB, color_filter_up);
OBJECT_SET_DATA(color_filters, COLOR_DOWN_LB, color_filter_down);
OBJECT_SET_DATA(color_filters, COLOR_EDIT_LB, color_edit);
OBJECT_SET_DATA(color_filters, COLOR_DELETE_LB, color_delete);
OBJECT_SET_DATA(color_new, COLOR_FILTERS_CL, color_filters);
SIGNAL_CONNECT(color_new, "clicked", color_new_cb, NULL);
OBJECT_SET_DATA(color_edit, COLOR_FILTERS_CL, color_filters);
SIGNAL_CONNECT(color_edit, "clicked", color_edit_cb, NULL);
OBJECT_SET_DATA(color_delete, COLOR_EDIT_LB, color_edit);
OBJECT_SET_DATA(color_delete, COLOR_FILTERS_CL, color_filters);
SIGNAL_CONNECT(color_delete, "clicked", color_delete_cb, NULL);
SIGNAL_CONNECT(color_save, "clicked", color_save_cb, NULL);
SIGNAL_CONNECT(color_export, "clicked", file_color_export_cmd_cb, NULL);
OBJECT_SET_DATA(color_import, COLOR_FILTERS_CL, color_filters);
SIGNAL_CONNECT(color_import, "clicked", color_import_cb, color_filters);
OBJECT_SET_DATA(color_revert, COLOR_FILTERS_CL, color_filters);
SIGNAL_CONNECT(color_revert, "clicked", color_revert_cb, NULL);
SIGNAL_CONNECT(color_ok, "clicked", color_ok_cb, NULL);
SIGNAL_CONNECT(color_apply, "clicked", color_apply_cb, NULL);
SIGNAL_CONNECT(color_cancel, "clicked", color_cancel_cb, NULL);
gtk_widget_grab_focus(color_filters);
OBJECT_SET_DATA(color_win, "tooltips", tooltips);
gtk_widget_show (color_win);
dlg_set_cancel(color_win, color_cancel);
return color_win;
}
static void
add_filter_to_list(gpointer filter_arg, gpointer list_arg)
{
color_filter_t *colorf = filter_arg;
#if GTK_MAJOR_VERSION < 2
GtkWidget *color_filters = list_arg;
gchar *data[2];
gint row;
GdkColor bg, fg;
data[0] = colorf->filter_name;
data[1] = colorf->filter_text;
row = gtk_clist_append(GTK_CLIST(color_filters), data);
color_t_to_gdkcolor(&fg, &colorf->fg_color);
color_t_to_gdkcolor(&bg, &colorf->bg_color);
gtk_clist_set_row_data(GTK_CLIST(color_filters), row, colorf);
gtk_clist_set_foreground(GTK_CLIST(color_filters), row, &fg);
gtk_clist_set_background(GTK_CLIST(color_filters), row, &bg);
#else
gchar fg_str[14], bg_str[14];
GtkListStore *store;
GtkTreeIter iter;
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(list_arg)));
gtk_list_store_append(store, &iter);
sprintf(fg_str, "#%04X%04X%04X",
colorf->fg_color.red, colorf->fg_color.green, colorf->fg_color.blue);
sprintf(bg_str, "#%04X%04X%04X",
colorf->bg_color.red, colorf->bg_color.green, colorf->bg_color.blue);
gtk_list_store_set(store, &iter, 0, colorf->filter_name,
1, colorf->filter_text, 2, fg_str, 3, bg_str,
4, colorf, -1);
#endif
num_of_filters++;
}
void move_this_row (GtkWidget *color_filters,
gint filter_number,
gint amount) /* only tested with +1(down) and -1(up) */
{
color_filter_t *colorf;
#if GTK_MAJOR_VERSION < 2
gint lower, higher;
#else
GtkTreeModel *model;
GtkTreeIter iter1, iter2;
gchar *name, *string, *fg_str, *bg_str;
#endif
g_assert(amount == +1 || amount == -1);
g_assert(amount == +1 || filter_number > 0);
g_assert(amount == -1 || filter_number < num_of_filters - 1);
#if GTK_MAJOR_VERSION < 2
if (amount > 0)
{
lower = filter_number;
higher = filter_number + amount;
}
else
{
higher = filter_number;
lower = filter_number + amount;
}
colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters), filter_number);
gtk_clist_swap_rows(GTK_CLIST(color_filters), higher, lower);
/*
* That row is still selected, but it's now moved.
*/
remember_selected_row(GTK_CLIST(color_filters), filter_number + amount, 0, NULL, NULL);
#else
model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
gtk_tree_model_iter_nth_child(model, &iter1, NULL, filter_number);
gtk_tree_model_iter_nth_child(model, &iter2, NULL, filter_number + amount);
gtk_tree_model_get(model, &iter1, 0, &name, 1, &string,
2, &fg_str, 3, &bg_str, 4, &colorf, -1);
gtk_list_store_remove(GTK_LIST_STORE(model), &iter1);
if (amount < 0)
gtk_list_store_insert_before(GTK_LIST_STORE(model), &iter1, &iter2);
else
gtk_list_store_insert_after(GTK_LIST_STORE(model), &iter1, &iter2);
gtk_list_store_set(GTK_LIST_STORE(model), &iter1, 0, name, 1, string,
2, fg_str, 3, bg_str, 4, colorf, -1);
g_free(name);
g_free(string);
g_free(fg_str);
g_free(bg_str);
/*
* re-select the initial row
*/
gtk_widget_grab_focus(color_filters);
gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters)), &iter1);
#endif
filter_list = g_slist_remove(filter_list, colorf);
filter_list = g_slist_insert(filter_list, colorf, filter_number + amount);
}
/* Move the selected filters up in the list */
static void
color_filter_up_cb(GtkButton *button, gpointer user_data _U_)
{
gint amount;
gint filter_number;
GtkWidget * color_filters;
color_filter_t *colorf;
#if GTK_MAJOR_VERSION < 2
#else
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *sel;
#endif
amount = -1;
color_filters = (GtkWidget *)OBJECT_GET_DATA(button, COLOR_FILTERS_CL);
#if GTK_MAJOR_VERSION < 2
colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters), 0);
if (colorf->marked)
return;
#endif
for (filter_number = 0; filter_number < num_of_filters; filter_number++)
{
#if GTK_MAJOR_VERSION < 2
colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters), filter_number);
if (colorf->marked)
move_this_row (color_filters, filter_number, amount);
#else
model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
gtk_tree_model_iter_nth_child(model, &iter, NULL, filter_number);
gtk_tree_model_get(model, &iter, 4, &colorf, -1);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
if (gtk_tree_selection_iter_is_selected(sel, &iter))
move_this_row (color_filters, filter_number, amount);
#endif
}
}
/* Move the selected filters down in the list */
static void
color_filter_down_cb(GtkButton *button, gpointer user_data _U_)
{
gint amount;
gint filter_number;
GtkWidget * color_filters;
color_filter_t *colorf;
#if GTK_MAJOR_VERSION < 2
#else
GtkTreeIter iter;
GtkTreeModel *model;
#endif
amount = +1;
color_filters = (GtkWidget *)OBJECT_GET_DATA(button, COLOR_FILTERS_CL);
#if GTK_MAJOR_VERSION < 2
colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters), num_of_filters - 1);
if (colorf->marked)
return;
#endif
for (filter_number = num_of_filters - 1; filter_number >= 0; filter_number--)
{
#if GTK_MAJOR_VERSION < 2
colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters), filter_number);
#else
model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
gtk_tree_model_iter_nth_child(model, &iter, NULL, filter_number);
gtk_tree_model_get(model, &iter, 4, &colorf, -1);
#endif
if (colorf->marked)
move_this_row (color_filters, filter_number, amount);
}
}
/* A row was selected; remember its row number */
#if GTK_MAJOR_VERSION < 2
static void
remember_selected_row(GtkCList *clist, gint row, gint column _U_,
GdkEvent *event _U_, gpointer user_data _U_)
{
GtkWidget *button;
color_filter_t *colorf;
row_selected = row;
colorf = gtk_clist_get_row_data(clist, row);
colorf->marked = TRUE;
/*
* A row is selected, so we can move it up *if* it's not at the top
* and move it down *if* it's not at the bottom.
*/
button = (GtkWidget *)OBJECT_GET_DATA(clist, COLOR_UP_LB);
gtk_widget_set_sensitive (button, row > 0);
button = (GtkWidget *)OBJECT_GET_DATA(clist, COLOR_DOWN_LB);
gtk_widget_set_sensitive(button, row < num_of_filters - 1);
/*
* A row is selected, so we can operate on it.
*/
button = (GtkWidget *)OBJECT_GET_DATA(clist, COLOR_EDIT_LB);
gtk_widget_set_sensitive (button, TRUE);
button = (GtkWidget *)OBJECT_GET_DATA(clist, COLOR_DELETE_LB);
gtk_widget_set_sensitive(button, TRUE);
}
#else
struct remember_data
{
gint count; /* count of selected filters */
gboolean first_marked; /* true if the first filter in the list is marked */
gboolean last_marked; /* true if the last filter in the list is marked */
gpointer color_filters;
};
/* called for each selected row in the tree.
*/
void remember_this_row (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer arg)
{
gint *path_index;
color_filter_t *colorf;
struct remember_data *data = arg;
gtk_tree_model_get(model, iter, 4, &colorf, -1);
colorf->marked = TRUE;
path_index = gtk_tree_path_get_indices(path); /* not to be freed */
if (path_index == NULL) /* can return NULL according to API doc.*/
{
return;
}
row_selected = path_index[0];
if (row_selected == 0)
data->first_marked = TRUE;
if (row_selected == num_of_filters - 1)
data->last_marked = TRUE;
data->count++;
}
/* clear the mark on this filter */
static void
clear_mark(gpointer filter_arg, gpointer arg _U_)
{
color_filter_t *colorf = filter_arg;
colorf->marked = FALSE;
}
/* The gtk+2.0 version gets called for, (maybe multiple,) changes in the selection. */
static void
remember_selected_row(GtkTreeSelection *sel, gpointer color_filters)
{
GtkWidget *button;
struct remember_data data;
data.first_marked = data.last_marked = FALSE;
data.count = 0;
data.color_filters = color_filters;
g_slist_foreach(filter_list, clear_mark, NULL);
gtk_tree_selection_selected_foreach(sel,remember_this_row, &data);
if (data.count > 0)
{
/*
* One or more rows are selected, so we can operate on them.
*/
/* We can only edit if there is exactly one filter selected */
button = (GtkWidget *)OBJECT_GET_DATA(color_filters, COLOR_EDIT_LB);
gtk_widget_set_sensitive (button, data.count == 1);
/* We can delete any number of filters */
button = (GtkWidget *)OBJECT_GET_DATA(color_filters, COLOR_DELETE_LB);
gtk_widget_set_sensitive (button, TRUE);
/*
* We can move them up *if* one of them isn't the top row,
* and move them down *if* one of them isn't the bottom row.
*/
button = (GtkWidget *)OBJECT_GET_DATA(color_filters, COLOR_UP_LB);
gtk_widget_set_sensitive(button, !data.first_marked);
button = (GtkWidget *)OBJECT_GET_DATA(color_filters, COLOR_DOWN_LB);
gtk_widget_set_sensitive(button, !data.last_marked);
}
else
{
row_selected = -1;
/*
* No row is selected, so we can't do operations that affect the
* selected row.
*/
button = (GtkWidget *)OBJECT_GET_DATA(color_filters, COLOR_UP_LB);
gtk_widget_set_sensitive (button, FALSE);
button = (GtkWidget *)OBJECT_GET_DATA(color_filters, COLOR_DOWN_LB);
gtk_widget_set_sensitive (button, FALSE);
button = (GtkWidget *)OBJECT_GET_DATA(color_filters, COLOR_EDIT_LB);
gtk_widget_set_sensitive (button, FALSE);
button = (GtkWidget *)OBJECT_GET_DATA(color_filters, COLOR_DELETE_LB);
gtk_widget_set_sensitive (button, FALSE);
}
}
#endif
#if GTK_MAJOR_VERSION < 2
/* A row was unselected; un-remember its row number */
static void
unremember_selected_row (GtkCList *clist,
gint row _U_,
gint column _U_,
GdkEvent *event _U_,
gpointer user_data _U_)
{
GtkWidget *button;
color_filter_t *colorf;
row_selected = -1;
colorf = gtk_clist_get_row_data(clist, row);
colorf->marked = FALSE;
if (color_marked_count() == 0)
{
/*
* No row is selected, so we can't do operations that affect the
* selected row.
*/
button = (GtkWidget *)OBJECT_GET_DATA(clist, COLOR_UP_LB);
gtk_widget_set_sensitive (button, FALSE);
button = (GtkWidget *)OBJECT_GET_DATA(clist, COLOR_DOWN_LB);
gtk_widget_set_sensitive (button, FALSE);
button = (GtkWidget *)OBJECT_GET_DATA(clist, COLOR_EDIT_LB);
gtk_widget_set_sensitive (button, FALSE);
button = (GtkWidget *)OBJECT_GET_DATA(clist, COLOR_DELETE_LB);
gtk_widget_set_sensitive(button, FALSE);
}
}
#endif
/* Called when the dialog box is being destroyed; destroy any edit
* dialogs opened from this dialog, and null out the pointer to this
* dialog.
jjj*/
static void
color_destroy_cb (GtkButton *button _U_,
gpointer user_data _U_)
{
/* Destroy any edit dialogs we have open. */
g_slist_foreach(filter_list, destroy_edit_dialog_cb, NULL);
colorize_win = NULL;
}
static void
destroy_edit_dialog_cb(gpointer filter_arg, gpointer dummy _U_)
{
color_filter_t *colorf = (color_filter_t *)filter_arg;
if (colorf->edit_dialog != NULL)
gtk_widget_destroy(colorf->edit_dialog);
}
/* XXX - we don't forbid having more than one "Edit color filter" dialog
open, so these shouldn't be static. */
static GtkWidget *filt_name_entry;
static GtkWidget *filt_text_entry;
static void
color_add_colorf(GtkWidget *color_filters, color_filter_t *colorf)
{
#if GTK_MAJOR_VERSION < 2
#else
GtkTreeModel *model;
gint num_filters;
GtkTreeIter iter;
GtkTreeSelection *sel;
#endif
add_filter_to_list(colorf, color_filters);
#if GTK_MAJOR_VERSION < 2
/* select the new row */
gtk_clist_select_row(GTK_CLIST(color_filters), num_of_filters - 1, -1);
#else
/* select the new row */
model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
num_filters = gtk_tree_model_iter_n_children(model, NULL);
gtk_tree_model_iter_nth_child(model, &iter, NULL, num_filters - 1);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
gtk_tree_selection_select_iter(sel, &iter);
#endif
}
void
color_add_filter_cb (color_filter_t *colorf, gpointer arg)
{
GtkWidget *color_filters = arg;
color_add_colorf(color_filters, colorf);
#if GTK_MAJOR_VERSION >= 2
gtk_widget_grab_focus(color_filters);
#endif
}
/* Pop up an "Export color filter" dialog box. */
static void
color_import_cb(GtkButton *button, gpointer user_data )
{
GtkWidget *color_filters;
#if GTK_MAJOR_VERSION >= 2
GtkTreeSelection *sel;
#endif
color_filters = (GtkWidget *)OBJECT_GET_DATA(button, COLOR_FILTERS_CL);
#if GTK_MAJOR_VERSION >= 2
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
gtk_tree_selection_unselect_all (sel);
#else
gtk_clist_unselect_all (GTK_CLIST(color_filters));
#endif
file_color_import_cmd_cb(GTK_WIDGET(button), user_data);
}
/* Create a new filter in the list, and pop up an "Edit color filter"
dialog box to edit it. */
static void
color_new_cb(GtkButton *button, gpointer user_data _U_)
{
color_filter_t *colorf;
GtkWidget *color_filters;
#if GTK_MAJOR_VERSION >= 2
GtkTreeSelection *sel;
#endif
color_filters = (GtkWidget *)OBJECT_GET_DATA(button, COLOR_FILTERS_CL);
#if GTK_MAJOR_VERSION >= 2
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
gtk_tree_selection_unselect_all (sel);
#else
gtk_clist_unselect_all (GTK_CLIST(color_filters));
#endif
colorf = new_color_filter("name", "filter"); /* Adds at end! */
color_add_colorf(color_filters, colorf);
edit_color_filter_dialog_new(color_filters, &filt_name_entry,
&filt_text_entry);
#if GTK_MAJOR_VERSION >= 2
gtk_widget_grab_focus(color_filters);
#endif
}
/* Pop up an "Edit color filter" dialog box to edit an existing filter. */
static void
color_edit_cb(GtkButton *button, gpointer user_data _U_)
{
GtkWidget *color_filters;
color_filters = (GtkWidget *)OBJECT_GET_DATA(button, COLOR_FILTERS_CL);
g_assert(row_selected != -1);
edit_color_filter_dialog_new(color_filters, &filt_name_entry,
&filt_text_entry);
}
/* Delete a color from the list. */
static void
color_delete(gint row, GtkWidget *color_filters)
{
color_filter_t *colorf;
#if GTK_MAJOR_VERSION >= 2
GtkTreeModel *model;
GtkTreeIter iter;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
gtk_tree_model_iter_nth_child(model, &iter, NULL, row);
gtk_tree_model_get(model, &iter, 4, &colorf, -1);
/* Remove this color filter from the CList displaying the
color filters. */
gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
num_of_filters--;
/* Destroy any "Edit color filter" dialog boxes editing it. */
if (colorf->edit_dialog != NULL)
gtk_widget_destroy(colorf->edit_dialog);
/* Remove the color filter from the list of color filters. */
delete_color_filter(colorf);
/* If we grab the focus after updating the selection, the first
* row is always selected, so we do it before */
gtk_widget_grab_focus(color_filters);
#else
colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters), row);
/* Remove this color filter from the CList displaying the
color filters. */
gtk_clist_remove(GTK_CLIST(color_filters), row);
num_of_filters--;
/* Destroy any "Edit color filter" dialog boxes editing it. */
if (colorf->edit_dialog != NULL)
gtk_widget_destroy(colorf->edit_dialog);
/* Remove the color filter from the list of color filters. */
delete_color_filter(colorf);
#endif
}
/* Delete the selected color from the list.*/
static void
color_delete_cb(GtkWidget *widget, gpointer user_data _U_)
{
GtkWidget *color_filters;
gint row, num_filters;
#if GTK_MAJOR_VERSION < 2
color_filter_t *colorf;
#else
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeSelection *sel;
#endif
color_filters = (GtkWidget *)OBJECT_GET_DATA(widget, COLOR_FILTERS_CL);
#if GTK_MAJOR_VERSION < 2
num_filters = num_of_filters;
#else
model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
num_filters = gtk_tree_model_iter_n_children(model, NULL);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
#endif
for (row = num_filters - 1; row >= 0; row--)
{
#if GTK_MAJOR_VERSION < 2
colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters), row);
if (colorf->marked)
color_delete (row, color_filters);
#else
gtk_tree_model_iter_nth_child(model, &iter, NULL, row);
if (gtk_tree_selection_iter_is_selected(sel, &iter))
color_delete (row, color_filters);
#endif
}
}
/* Save color filters to the color filter file. */
static void
color_save_cb(GtkButton *button _U_, gpointer user_data _U_)
{
if (!write_filters())
simple_dialog(ESD_TYPE_CRIT, NULL, "Could not open filter file: %s",
strerror(errno));
}
/* Remove all user defined color filters and revert to the global file. */
static void
color_revert_cb(GtkWidget *widget, gpointer user_data _U_)
{
GtkWidget * color_filters;
color_filters = (GtkWidget *)OBJECT_GET_DATA(widget, COLOR_FILTERS_CL);
while (num_of_filters > 0)
{
color_delete (num_of_filters-1, color_filters);
}
if (!revert_filters())
simple_dialog(ESD_TYPE_CRIT, NULL, "Could not delete filter file: %s",
strerror(errno));
/* colorize list */
colorize_packets(&cfile);
/* Destroy the dialog box. */
gtk_widget_destroy(colorize_win);
}
/* Exit dialog and apply new list of color filters to the capture. */
static void
color_ok_cb(GtkButton *button _U_, gpointer user_data _U_)
{
/* colorize list */
colorize_packets(&cfile);
/* Destroy the dialog box. */
gtk_widget_destroy(colorize_win);
}
/* Exit dialog without colorizing packets with the new list.
XXX - should really undo any changes to the list.... */
static void
color_cancel_cb(GtkWidget *widget _U_, gpointer user_data _U_)
{
/* Destroy the dialog box. */
gtk_widget_destroy(colorize_win);
}
/* Apply new list of color filters to the capture. */
static void
color_apply_cb(GtkButton *button _U_, gpointer user_data _U_)
{
colorize_packets(&cfile);
}
/* Create an "Edit Color Filter" dialog for a given color filter, and
associate it with that color filter. */
static void
edit_color_filter_dialog_new(GtkWidget *color_filters,
GtkWidget **colorize_filter_name,
GtkWidget **colorize_filter_text)
{
color_filter_t *colorf;
GtkWidget *edit_dialog;
GtkWidget *dialog_vbox;
GtkTooltips *tooltips;
GtkStyle *style;
GtkWidget *filter_fr;
GtkWidget *filter_fr_vbox;
GtkWidget *filter_name_hbox;
GtkWidget *color_filter_name;
GtkWidget *filter_string_hbox;
GtkWidget *add_expression_bt;
GtkWidget *color_filter_text;
GtkWidget *colorize_fr;
GtkWidget *colorize_hbox;
GtkWidget *colorize_filter_fg;
GtkWidget *colorize_filter_bg;
GtkWidget *button_hbox;
GtkWidget *edit_color_filter_ok;
GtkWidget *edit_color_filter_cancel;
#if GTK_MAJOR_VERSION >= 2
GtkTreeModel *model;
GtkTreeIter iter;
#endif
#if GTK_MAJOR_VERSION >= 2
model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
gtk_tree_model_iter_nth_child(model, &iter, NULL, row_selected);
gtk_tree_model_get(model, &iter, 4, &colorf, -1);
#else
colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters), row_selected);
#endif
if (colorf->edit_dialog != NULL) {
/* There's already an edit box open for this filter; reactivate it. */
reactivate_window(colorf->edit_dialog);
return;
}
tooltips = gtk_tooltips_new ();
/* dialog window */
edit_dialog = dlg_window_new ("Ethereal: Edit Color Filter");
gtk_window_set_default_size(GTK_WINDOW(edit_dialog), 500, -1);
/* gtk_window_set_position(GTK_WINDOW(edit_dialog), GTK_WIN_POS_MOUSE); */
OBJECT_SET_DATA(edit_dialog, "edit_dialog", edit_dialog);
colorf->edit_dialog = edit_dialog;
dialog_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (dialog_vbox);
OBJECT_SET_DATA_FULL(edit_dialog, "dialog_vbox", dialog_vbox, gtk_widget_unref);
gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
gtk_widget_show (dialog_vbox);
gtk_container_add (GTK_CONTAINER (edit_dialog), dialog_vbox);
/* Filter frame */
filter_fr = gtk_frame_new("Filter");
gtk_box_pack_start (GTK_BOX (dialog_vbox), filter_fr, FALSE, FALSE, 0);
gtk_widget_show(filter_fr);
filter_fr_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (filter_fr_vbox);
OBJECT_SET_DATA_FULL(edit_dialog, "filter_fr_vbox", filter_fr_vbox, gtk_widget_unref);
gtk_container_set_border_width (GTK_CONTAINER (filter_fr_vbox), 5);
gtk_widget_show (filter_fr_vbox);
gtk_container_add(GTK_CONTAINER(filter_fr), filter_fr_vbox);
/* filter name hbox */
filter_name_hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (filter_name_hbox);
OBJECT_SET_DATA_FULL(edit_dialog, "filter_name_hbox", filter_name_hbox,
gtk_widget_unref);
gtk_widget_show (filter_name_hbox);
gtk_box_pack_start (GTK_BOX (filter_fr_vbox), filter_name_hbox, TRUE, FALSE, 3);
color_filter_name = gtk_label_new (("Name: "));
gtk_widget_ref (color_filter_name);
OBJECT_SET_DATA_FULL(edit_dialog, "color_filter_name", color_filter_name,
gtk_widget_unref);
gtk_widget_show (color_filter_name);
gtk_box_pack_start (GTK_BOX (filter_name_hbox), color_filter_name, FALSE, FALSE, 0);
*colorize_filter_name = gtk_entry_new ();
gtk_widget_ref (*colorize_filter_name);
OBJECT_SET_DATA_FULL(edit_dialog, "*colorize_filter_name", *colorize_filter_name,
gtk_widget_unref);
gtk_entry_set_text(GTK_ENTRY(*colorize_filter_name), colorf->filter_name);
style = gtk_style_copy(gtk_widget_get_style(*colorize_filter_name));
color_t_to_gdkcolor(&style->base[GTK_STATE_NORMAL], &colorf->bg_color);
#if GTK_MAJOR_VERSION < 2
color_t_to_gdkcolor(&style->fg[GTK_STATE_NORMAL], &colorf->fg_color);
#else
color_t_to_gdkcolor(&style->text[GTK_STATE_NORMAL], &colorf->fg_color);
#endif
gtk_widget_set_style(*colorize_filter_name, style);
gtk_widget_show (*colorize_filter_name);
gtk_box_pack_start (GTK_BOX (filter_name_hbox), *colorize_filter_name, TRUE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, *colorize_filter_name, ("This is the editable name of the filter. (No @ characters allowed.)"), NULL);
/* filter string hbox */
filter_string_hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (filter_string_hbox);
OBJECT_SET_DATA_FULL(edit_dialog, "filter_string_hbox", filter_string_hbox,
gtk_widget_unref);
gtk_widget_show (filter_string_hbox);
gtk_box_pack_start (GTK_BOX (filter_fr_vbox), filter_string_hbox, TRUE, FALSE, 3);
color_filter_text = gtk_label_new (("String: "));
gtk_widget_ref (color_filter_text);
OBJECT_SET_DATA_FULL(edit_dialog, "color_filter_text", color_filter_text,
gtk_widget_unref);
gtk_widget_show (color_filter_text);
gtk_box_pack_start (GTK_BOX (filter_string_hbox), color_filter_text, FALSE, FALSE, 0);
*colorize_filter_text = gtk_entry_new ();
gtk_widget_ref (*colorize_filter_text);
OBJECT_SET_DATA_FULL(edit_dialog, "*colorize_filter_text", *colorize_filter_text,
gtk_widget_unref);
gtk_entry_set_text(GTK_ENTRY(*colorize_filter_text), colorf->filter_text);
#if 0
style = gtk_style_copy(gtk_widget_get_style(*colorize_filter_text));
style->base[GTK_STATE_NORMAL] = colorf->bg_color;
style->fg[GTK_STATE_NORMAL] = colorf->fg_color;
#endif
gtk_widget_set_style(*colorize_filter_text, style);
gtk_widget_show (*colorize_filter_text);
gtk_box_pack_start (GTK_BOX (filter_string_hbox), *colorize_filter_text, TRUE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, *colorize_filter_text, ("This is the editable text of the filter"), NULL);
/* Create the "Add Expression..." button, to pop up a dialog
for constructing filter comparison expressions. */
add_expression_bt = gtk_button_new_with_label("Add Expression...");
SIGNAL_CONNECT(add_expression_bt, "clicked", filter_expr_cb, *colorize_filter_text);
gtk_box_pack_start (GTK_BOX(filter_string_hbox), add_expression_bt, FALSE, FALSE, 3);
gtk_widget_show(add_expression_bt);
gtk_tooltips_set_tip (tooltips, add_expression_bt, ("Add an expression to the filter string"), NULL);
/* choose color frame */
colorize_fr = gtk_frame_new("Display Colors");
gtk_box_pack_start (GTK_BOX (dialog_vbox), colorize_fr, FALSE, FALSE, 0);
gtk_widget_show(colorize_fr);
colorize_hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (colorize_hbox);
OBJECT_SET_DATA_FULL(edit_dialog, "colorize_hbox", colorize_hbox, gtk_widget_unref);
gtk_container_set_border_width (GTK_CONTAINER (colorize_hbox), 5);
gtk_widget_show (colorize_hbox);
gtk_container_add(GTK_CONTAINER(colorize_fr), colorize_hbox);
colorize_filter_fg = gtk_button_new_with_label (("Foreground Color..."));
gtk_widget_ref (colorize_filter_fg);
OBJECT_SET_DATA_FULL(edit_dialog, "colorize_filter_fg", colorize_filter_fg,
gtk_widget_unref);
gtk_widget_show (colorize_filter_fg);
gtk_box_pack_start (GTK_BOX (colorize_hbox), colorize_filter_fg, TRUE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, colorize_filter_fg, ("Select foreground color for data display"), NULL);
colorize_filter_bg = gtk_button_new_with_label (("Background Color..."));
gtk_widget_ref (colorize_filter_bg);
OBJECT_SET_DATA_FULL(edit_dialog, "colorize_filter_bg", colorize_filter_bg,
gtk_widget_unref);
gtk_widget_show (colorize_filter_bg);
gtk_box_pack_start (GTK_BOX (colorize_hbox), colorize_filter_bg, TRUE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, colorize_filter_bg, ("Select background color for data display"), NULL);
/* button hbox (placement defaults coming from main.c) */
button_hbox = gtk_hbutton_box_new();
gtk_widget_ref (button_hbox);
OBJECT_SET_DATA_FULL(edit_dialog, "button_hbox", button_hbox, gtk_widget_unref);
gtk_container_set_border_width (GTK_CONTAINER (button_hbox), 0);
gtk_widget_show (button_hbox);
gtk_box_pack_start (GTK_BOX (dialog_vbox), button_hbox, FALSE, FALSE, 5);
edit_color_filter_ok = gtk_button_new_with_label (("OK"));
gtk_widget_ref (edit_color_filter_ok);
OBJECT_SET_DATA_FULL(edit_dialog, "edit_color_filter_ok", edit_color_filter_ok,
gtk_widget_unref);
gtk_widget_show (edit_color_filter_ok);
gtk_box_pack_start (GTK_BOX (button_hbox), edit_color_filter_ok, TRUE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, edit_color_filter_ok, ("Accept filter color change"), NULL);
edit_color_filter_cancel = gtk_button_new_with_label (("Cancel"));
gtk_widget_ref (edit_color_filter_cancel);
OBJECT_SET_DATA_FULL(edit_dialog, "edit_color_filter_cancel",
edit_color_filter_cancel, gtk_widget_unref);
gtk_widget_show (edit_color_filter_cancel);
gtk_box_pack_start (GTK_BOX (button_hbox), edit_color_filter_cancel, TRUE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, edit_color_filter_cancel, ("Reject filter color change"), NULL);
/* signals and such */
OBJECT_SET_DATA(edit_dialog, COLOR_FILTER, colorf);
SIGNAL_CONNECT(edit_dialog, "destroy", edit_color_filter_destroy_cb, NULL);
OBJECT_SET_DATA(colorize_filter_fg, COLOR_FILTER, colorf);
SIGNAL_CONNECT(colorize_filter_fg, "clicked", edit_color_filter_fg_cb, NULL);
OBJECT_SET_DATA(colorize_filter_bg, COLOR_FILTER, colorf);
SIGNAL_CONNECT(colorize_filter_bg, "clicked", edit_color_filter_bg_cb, NULL);
OBJECT_SET_DATA(edit_color_filter_ok, COLOR_FILTERS_CL, color_filters);
OBJECT_SET_DATA(edit_color_filter_ok, COLOR_FILTER, colorf);
SIGNAL_CONNECT(edit_color_filter_ok, "clicked", edit_color_filter_ok_cb, edit_dialog);
SIGNAL_CONNECT(edit_color_filter_cancel, "clicked", edit_color_filter_cancel_cb,
edit_dialog);
OBJECT_SET_DATA(edit_dialog, "tooltips", tooltips);
dlg_set_cancel(edit_dialog, edit_color_filter_cancel);
gtk_widget_show (edit_dialog);
}
/* Called when the dialog box is being destroyed; destroy any color
selection dialogs opened from this dialog, and null out the pointer
to this dialog. */
#if GTK_MAJOR_VERSION < 2
static void
edit_color_filter_destroy_cb(GtkObject *object, gpointer user_data _U_)
#else
static void
edit_color_filter_destroy_cb(GObject *object, gpointer user_data _U_)
#endif
{
color_filter_t *colorf;
GtkWidget *color_sel;
colorf = (color_filter_t *)OBJECT_GET_DATA(object, COLOR_FILTER);
colorf->edit_dialog = NULL;
/* Destroy any color selection dialogs this dialog had open. */
color_sel = (GtkWidget *)OBJECT_GET_DATA(object, COLOR_SELECTION_FG);
if (color_sel != NULL)
gtk_widget_destroy(color_sel);
color_sel = (GtkWidget *)OBJECT_GET_DATA(object, COLOR_SELECTION_BG);
if (color_sel != NULL)
gtk_widget_destroy(color_sel);
}
/* Pop up a color selection box to choose the foreground color. */
static void
edit_color_filter_fg_cb(GtkButton *button, gpointer user_data _U_)
{
color_filter_t *colorf;
GtkWidget *color_selection_fg;
colorf = (color_filter_t *)OBJECT_GET_DATA(button, COLOR_FILTER);
/* Do we already have one open for this dialog? */
color_selection_fg = OBJECT_GET_DATA(colorf->edit_dialog, COLOR_SELECTION_FG);
if (color_selection_fg != NULL) {
/* Yes. Just reactivate it. */
reactivate_window(color_selection_fg);
} else {
/* No. Create a new color selection box, and associate it with
this dialog. */
color_selection_fg = color_sel_win_new(colorf, FALSE);
OBJECT_SET_DATA(colorf->edit_dialog, COLOR_SELECTION_FG, color_selection_fg);
OBJECT_SET_DATA(color_selection_fg, COLOR_SELECTION_PARENT, colorf->edit_dialog);
}
}
/* Pop up a color selection box to choose the background color. */
static void
edit_color_filter_bg_cb (GtkButton *button,
gpointer user_data _U_)
{
color_filter_t *colorf;
GtkWidget *color_selection_bg;
colorf = (color_filter_t *)OBJECT_GET_DATA(button, COLOR_FILTER);
/* Do we already have one open for this dialog? */
color_selection_bg = OBJECT_GET_DATA(colorf->edit_dialog, COLOR_SELECTION_BG);
if (color_selection_bg != NULL) {
/* Yes. Just reactivate it. */
reactivate_window(color_selection_bg);
} else {
/* No. Create a new color selection box, and associate it with
this dialog. */
color_selection_bg = color_sel_win_new(colorf, TRUE);
OBJECT_SET_DATA(colorf->edit_dialog, COLOR_SELECTION_BG, color_selection_bg);
OBJECT_SET_DATA(color_selection_bg, COLOR_SELECTION_PARENT, colorf->edit_dialog);
}
}
/* accept color (and potential content) change */
static void
edit_color_filter_ok_cb (GtkButton *button,
gpointer user_data)
{
GtkWidget *dialog;
GtkStyle *style;
GdkColor new_fg_color;
GdkColor new_bg_color;
gchar *filter_name;
gchar *filter_text;
color_filter_t *colorf;
dfilter_t *compiled_filter;
GtkWidget *color_filters;
#if GTK_MAJOR_VERSION >= 2
GtkTreeModel *model;
GtkTreeIter iter;
gchar fg_str[14], bg_str[14];
#endif
dialog = (GtkWidget *)user_data;
style = gtk_widget_get_style(filt_name_entry);
new_bg_color = style->base[GTK_STATE_NORMAL];
#if GTK_MAJOR_VERSION < 2
new_fg_color = style->fg[GTK_STATE_NORMAL];
#else
new_fg_color = style->text[GTK_STATE_NORMAL];
#endif
filter_name = g_strdup(gtk_entry_get_text(GTK_ENTRY(filt_name_entry)));
filter_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(filt_text_entry)));
if(strchr(filter_name,'@') || strchr(filter_text,'@')){
simple_dialog(ESD_TYPE_CRIT, NULL, "Filter names and strings must not"
" use the '@' character. Filter unchanged.");
g_free(filter_name);
g_free(filter_text);
return;
}
if(!dfilter_compile(filter_text, &compiled_filter)) {
simple_dialog(ESD_TYPE_CRIT, NULL, "Filter \"%s\" did not compile correctly.\n"
" Please try again. Filter unchanged.\n%s\n", filter_name,
dfilter_error_msg);
} else {
color_filters = (GtkWidget *)OBJECT_GET_DATA(button, COLOR_FILTERS_CL);
colorf = (color_filter_t *)OBJECT_GET_DATA(button, COLOR_FILTER);
if (colorf->filter_name != NULL)
g_free(colorf->filter_name);
colorf->filter_name = filter_name;
if (colorf->filter_text != NULL)
g_free(colorf->filter_text);
colorf->filter_text = filter_text;
gdkcolor_to_color_t(&colorf->fg_color, &new_fg_color);
gdkcolor_to_color_t(&colorf->bg_color, &new_bg_color);
#if GTK_MAJOR_VERSION < 2
gtk_clist_set_foreground(GTK_CLIST(color_filters), row_selected,
&new_fg_color);
gtk_clist_set_background(GTK_CLIST(color_filters), row_selected,
&new_bg_color);
#else
sprintf(fg_str, "#%04X%04X%04X",
new_fg_color.red, new_fg_color.green, new_fg_color.blue);
sprintf(bg_str, "#%04X%04X%04X",
new_bg_color.red, new_bg_color.green, new_bg_color.blue);
model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
gtk_tree_model_iter_nth_child(model, &iter, NULL, row_selected);
gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, filter_name,
1, filter_text, 2, fg_str, 3, bg_str, -1);
#endif
if(colorf->c_colorfilter != NULL)
dfilter_free(colorf->c_colorfilter);
colorf->c_colorfilter = compiled_filter;
#if GTK_MAJOR_VERSION < 2
/* gtk_clist_set_text frees old text (if any) and allocates new space */
gtk_clist_set_text(GTK_CLIST(color_filters), row_selected, 0,
filter_name);
gtk_clist_set_text(GTK_CLIST(color_filters), row_selected, 1,
filter_text);
#endif
/* Destroy the dialog box. */
gtk_widget_destroy(dialog);
}
}
/* Exit dialog and do not process list */
static void
edit_color_filter_cancel_cb(GtkObject *object _U_, gpointer user_data)
{
GtkWidget *dialog;
dialog = (GtkWidget *)user_data;
/* Destroy the dialog box. */
gtk_widget_destroy(dialog);
}
static GtkWidget*
color_sel_win_new(color_filter_t *colorf, gboolean is_bg)
{
gint title_len;
gchar *title;
static const gchar fg_title_format[] = "Ethereal: Choose foreground color for \"%s\"";
static const gchar bg_title_format[] = "Ethereal: Choose background color for \"%s\"";
GtkWidget *color_sel_win;
color_t *color;
#if GTK_MAJOR_VERSION >= 2
GdkColor gcolor;
#endif
GtkWidget *color_sel_ok;
GtkWidget *color_sel_cancel;
GtkWidget *color_sel_help;
if (is_bg) {
color = &colorf->bg_color;
title_len = strlen(bg_title_format) + strlen(colorf->filter_name);
title = g_malloc(title_len + 1);
sprintf(title, bg_title_format, colorf->filter_name);
} else {
color = &colorf->fg_color;
title_len = strlen(fg_title_format) + strlen(colorf->filter_name);
title = g_malloc(title_len + 1);
sprintf(title, fg_title_format, colorf->filter_name);
}
color_sel_win = gtk_color_selection_dialog_new(title);
g_free(title);
OBJECT_SET_DATA(color_sel_win, "color_sel_win", color_sel_win);
gtk_container_set_border_width (GTK_CONTAINER (color_sel_win), 10);
if (color != NULL) {
#if GTK_MAJOR_VERSION < 2
gdouble cols[3];
cols[0] = (gdouble)color->red / 65536.0;
cols[1] = (gdouble)color->green / 65536.0;
cols[2] = (gdouble)color->blue / 65536.0;
gtk_color_selection_set_color(
GTK_COLOR_SELECTION(
GTK_COLOR_SELECTION_DIALOG(color_sel_win)->colorsel), cols);
#else
color_t_to_gdkcolor(&gcolor, color);
gtk_color_selection_set_current_color(
GTK_COLOR_SELECTION(
GTK_COLOR_SELECTION_DIALOG(color_sel_win)->colorsel), &gcolor);
#endif
}
color_sel_ok = GTK_COLOR_SELECTION_DIALOG (color_sel_win)->ok_button;
OBJECT_SET_DATA(color_sel_win, "color_sel_ok", color_sel_ok);
gtk_widget_show (color_sel_ok);
GTK_WIDGET_SET_FLAGS (color_sel_ok, GTK_CAN_DEFAULT);
color_sel_cancel = GTK_COLOR_SELECTION_DIALOG (color_sel_win)->cancel_button;
OBJECT_SET_DATA(color_sel_win, "color_sel_cancel", color_sel_cancel);
gtk_widget_show (color_sel_cancel);
GTK_WIDGET_SET_FLAGS (color_sel_cancel, GTK_CAN_DEFAULT);
color_sel_help = GTK_COLOR_SELECTION_DIALOG (color_sel_win)->help_button;
OBJECT_SET_DATA(color_sel_win, "color_sel_help", color_sel_help);
gtk_widget_show (color_sel_help);
GTK_WIDGET_SET_FLAGS (color_sel_help, GTK_CAN_DEFAULT);
SIGNAL_CONNECT(color_sel_win, "destroy", color_sel_cancel_cb, color_sel_win);
SIGNAL_CONNECT(color_sel_ok, "clicked", color_sel_ok_cb, color_sel_win);
SIGNAL_CONNECT(color_sel_cancel, "clicked", color_sel_cancel_cb, color_sel_win);
gtk_widget_show(color_sel_win);
return color_sel_win;
}
static void
color_sel_win_destroy(GtkWidget *sel_win)
{
GtkWidget *parent;
GtkWidget *color_selection_fg, *color_selection_bg;
/* Find the "Edit color filter" dialog box with which this is associated. */
parent = (GtkWidget *)OBJECT_GET_DATA(sel_win, COLOR_SELECTION_PARENT);
/* Find that dialog box's foreground and background color selection
boxes, if any. */
color_selection_fg = OBJECT_GET_DATA(parent, COLOR_SELECTION_FG);
color_selection_bg = OBJECT_GET_DATA(parent, COLOR_SELECTION_BG);
if (sel_win == color_selection_fg) {
/* This was its foreground color selection box; it isn't, anymore. */
OBJECT_SET_DATA(parent, COLOR_SELECTION_FG, NULL);
}
if (sel_win == color_selection_bg) {
/* This was its background color selection box; it isn't, anymore. */
OBJECT_SET_DATA(parent, COLOR_SELECTION_BG, NULL);
}
/* Now destroy it. */
gtk_widget_destroy(sel_win);
}
/* Retrieve selected color */
static void
color_sel_ok_cb (GtkButton *button _U_,
gpointer user_data)
{
GdkColor new_color; /* Color from color selection dialog */
#if GTK_MAJOR_VERSION < 2
gdouble new_colors[3];
#endif
GtkWidget *color_dialog;
GtkStyle *style;
GtkWidget *parent;
GtkWidget *color_selection_fg, *color_selection_bg;
gboolean is_bg;
color_dialog = (GtkWidget *)user_data;
#if GTK_MAJOR_VERSION < 2
gtk_color_selection_get_color(GTK_COLOR_SELECTION(
GTK_COLOR_SELECTION_DIALOG(color_dialog)->colorsel), new_colors);
new_color.red = (guint16)(new_colors[0]*65535.0);
new_color.green = (guint16)(new_colors[1]*65535.0);
new_color.blue = (guint16)(new_colors[2]*65535.0);
#else
gtk_color_selection_get_current_color(GTK_COLOR_SELECTION(
GTK_COLOR_SELECTION_DIALOG(color_dialog)->colorsel), &new_color);
#endif
if ( ! get_color(&new_color) ){
simple_dialog(ESD_TYPE_CRIT, NULL, "Could not allocate color. Try again.");
} else {
/* Find the "Edit color filter" dialog box with which this is
associated. */
parent = (GtkWidget *)OBJECT_GET_DATA(color_dialog, COLOR_SELECTION_PARENT);
/* Find that dialog box's foreground and background color selection
boxes, if any. */
color_selection_fg = OBJECT_GET_DATA(parent, COLOR_SELECTION_FG);
color_selection_bg = OBJECT_GET_DATA(parent, COLOR_SELECTION_BG);
is_bg = (color_dialog == color_selection_bg);
color_sel_win_destroy(color_dialog);
/* now apply the change to the fore/background */
style = gtk_style_copy(gtk_widget_get_style(filt_name_entry));
if (is_bg)
style->base[GTK_STATE_NORMAL] = new_color;
#if GTK_MAJOR_VERSION < 2
else
style->fg[GTK_STATE_NORMAL] = new_color;
#else
else
style->text[GTK_STATE_NORMAL] = new_color;
#endif
gtk_widget_set_style(filt_name_entry, style);
gtk_widget_set_style(filt_text_entry, style);
}
}
/* Don't choose the selected color as the foreground or background
color for the filter. */
static void
color_sel_cancel_cb (GtkObject *object _U_,
gpointer user_data)
{
GtkWidget *color_dialog;
color_dialog = (GtkWidget *)user_data;
/* nothing to change here. Just get rid of the dialog box. */
color_sel_win_destroy(color_dialog);
}
Reference in a new issue View git blame Copy permalink