Don't keep the CList of color filters around; create it when the

"Colorize Display" dialog box is created, and let it be destoryed when
that dialog box is destroyed.

When moving color filters up or down, update the (order of the elements
in the) list of color filters, as well as the CList that displays them.

If we have a "Colorize Display" dialog box open, and the user selects
"Display:Colorize Display", raise the existing window, rather than
creating a new window.  (Alas, GTK+ doesn't have a call to request that
the window be given the input focus, so we can't do that as well.)

Fix up some names to be more consistent and to better reflect what the
variables/routines are for.

svn path=/trunk/; revision=1361

1 files changed, 255 insertions, 201 deletions

diff --git a/colors.c b/colors.c
index 57114cb2c1..a404014b96 100644
--- a/colors.c
+++ b/colors.c
@@ -1,7 +1,7 @@
 /* colors.c
  * Definitions for color structures and routines
  *
- * $Id: colors.c,v 1.22 1999/12/19 07:38:59 guy Exp $
+ * $Id: colors.c,v 1.23 1999/12/19 09:22:18 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -45,11 +45,12 @@
 
 extern capture_file cf;
 
-static void new_color_filter(colfilter *filters, gchar *name,
+static color_filter_t *new_color_filter(colfilter *filters, gchar *name,
 				 gchar *filter_string);
 static gboolean read_filters(colfilter *filter);
 static GtkWidget* create_color_win(colfilter *filter);
-static GtkWidget* create_colorize_win(colfilter *filter,
+static GtkWidget* create_edit_color_filter_win(colfilter *filter,
+				 GtkWidget *color_filters,
 				 GtkWidget **colorize_filter_name,
 				 GtkWidget **colorize_filter_text);
 static GtkWidget* create_color_sel_win(colfilter *filter, GdkColor *);
@@ -60,11 +61,14 @@ GSList *filter_list;
 static GdkColormap*	sys_cmap;
 static GdkColormap*	our_cmap = NULL;
 
+static GtkWidget *colorize_win;
+
 static gchar *titles[2] = { "Name", "Filter String" };
 GdkColor	WHITE = { 0, 65535, 65535, 65535 };
 GdkColor	BLACK = { 0, 0, 0, 0 };
 
 #define COLOR_CHANGE_COLORS_LB	"color_change_colors_lb"
+#define COLOR_FILTERS_CL	"color_filters_cl"
 
 /* This structure is used to allow you to compile in default colors if
  * you wish.  They can be later changed by a user.
@@ -86,16 +90,14 @@ colfilter_new(void)
   colfilter *filter;
   gboolean got_white, got_black;
 #ifdef READ_DEFAULT_COLOR_LIST
+  color_filter_t *colorf;
   gint i;
   GdkColor color;
 #endif
 
   filter = (colfilter *)g_malloc(sizeof(colfilter));
   filter->num_of_filters = 0;
-  filter->color_filters = gtk_clist_new_with_titles(2, titles);
 
-  gtk_widget_ref(filter->color_filters); /* so it doesn't go away */
-  /* color_filters will ALWAYS be a GtkCList */
   sys_cmap = gdk_colormap_get_system();
 
   /* Allocate "constant" colors. */
@@ -124,11 +126,12 @@ colfilter_new(void)
 		    default_colors[i].color);
 	}
 
-	new_color_filter(filter, default_colors[i].proto, default_colors[i].proto);
-	color_filter(i)->bg_color = color;
+	colorf = new_color_filter(filter, default_colors[i].proto,
+	    default_colors[i].proto);
+	colorf->bg_color = color;
 
 	if (dfilter_compile(default_colors[i].proto,
-	    &color_filter(i)->c_colorfilter) != 0) {
+	    &colorf->c_colorfilter) != 0) {
 		simple_dialog(ESD_TYPE_WARN, NULL,
 		  "Cannot compile default color filter %s.\n%s",
 		  default_colors[i].proto, dfilter_error_msg);
@@ -141,31 +144,19 @@ colfilter_new(void)
   return filter;
 }
 
-color_filter_t *
-color_filter(gint n)
-{
-	return g_slist_nth_data(filter_list, n);
-}
-
-static void
+static color_filter_t *
 new_color_filter(colfilter *filters, gchar *name, gchar *filter_string)
 {
 	color_filter_t *colorf;
-        gchar *data[2];
-	gint row;
-
-	data[0] = g_strdup(name);
-	data[1] = g_strdup(filter_string);
-        row = gtk_clist_append(GTK_CLIST(filters->color_filters), data);
 
 	colorf = (color_filter_t *)g_malloc(sizeof (color_filter_t));
-	colorf->filter_name = data[0];
-	colorf->filter_text = data[1];
+	colorf->filter_name = g_strdup(name);
+	colorf->filter_text = g_strdup(filter_string);
 	colorf->bg_color = WHITE;
 	colorf->fg_color = BLACK;
 	colorf->c_colorfilter = NULL;
 	filter_list = g_slist_append(filter_list, colorf);
- 	gtk_clist_set_row_data(GTK_CLIST(filters->color_filters), row, colorf);
+        return colorf;
 }
 
 static void
@@ -190,7 +181,7 @@ read_filters(colfilter *filter)
 	gchar name[256],filter_exp[256], buf[1024];
 	guint16 fg_r, fg_g, fg_b, bg_r, bg_g, bg_b;
 	GdkColor fg_color, bg_color;
-
+	color_filter_t *colorf;
 	int i;
 	FILE *f;
 	gchar *path;
@@ -200,9 +191,8 @@ read_filters(colfilter *filter)
 	/* decide what file to open (from dfilter code) */
 
 	/* should only be called by colors_init.
-	 * filter->color_filters must exist
 	 */
-	if(filter == NULL || filter->color_filters == NULL)
+	if(filter == NULL)
 		return FALSE;
 	/* we have a clist */
 
@@ -242,8 +232,8 @@ read_filters(colfilter *filter)
 		 name, dfilter_error_msg);
 		continue;
 	    }
-            new_color_filter(filter, name, filter_exp);
-	    color_filter(i)->c_colorfilter = temp_dfilter;
+            colorf = new_color_filter(filter, name, filter_exp);
+	    colorf->c_colorfilter = temp_dfilter;
 	    filter->num_of_filters++;
 	    fg_color.red = fg_r;
 	    fg_color.green = fg_g;
@@ -267,13 +257,8 @@ read_filters(colfilter *filter)
 		continue;
 	    }
 
-            color_filter(i)->bg_color = bg_color;
-            color_filter(i)->fg_color = fg_color;
-            gtk_clist_set_foreground(GTK_CLIST(filter->color_filters),
-			i,&fg_color);
-            gtk_clist_set_background(GTK_CLIST(filter->color_filters),
-			i,&bg_color);
-
+            colorf->bg_color = bg_color;
+            colorf->fg_color = fg_color;
 	    i++;
 	  }    /* if sscanf */
 	} while( !feof(f));
@@ -283,18 +268,18 @@ read_filters(colfilter *filter)
 static void
 write_filter(gpointer filter_arg, gpointer file_arg)
 {
-	color_filter_t *cfilter = filter_arg;
+	color_filter_t *colorf = filter_arg;
 	FILE *f = file_arg;
 
 	fprintf(f,"@%s@%s@[%d,%d,%d][%d,%d,%d]\n",
-	    cfilter->filter_name,
-	    cfilter->filter_text,
-	    cfilter->bg_color.red,
-	    cfilter->bg_color.green,
-	    cfilter->bg_color.blue,
-	    cfilter->fg_color.red,
-	    cfilter->fg_color.green,
-	    cfilter->fg_color.blue);
+	    colorf->filter_name,
+	    colorf->filter_text,
+	    colorf->bg_color.red,
+	    colorf->bg_color.green,
+	    colorf->bg_color.blue,
+	    colorf->fg_color.red,
+	    colorf->fg_color.green,
+	    colorf->fg_color.blue);
 }
 	
 static gboolean
@@ -326,35 +311,40 @@ write_filters(colfilter *filter)
 void
 color_display_cb(GtkWidget *w, gpointer d)
 {
-  /* cf already exists as a global */
-  /* create the color dialog */
-  create_color_win(cf.colors);
+  if (colorize_win != NULL) {
+    /* There's already a color dialog box active; raise it.
+       XXX - give it focus, too.  Alas, GDK has nothing that
+       calls "XSetInputFocus()" on a window.... */
+    gdk_window_raise(colorize_win->window);
+  } else {
+    colorize_win = create_color_win(cf.colors);
+  }
 }
 
 static void
 color_cancel_cb                        (GtkWidget       *widget,
                                         gpointer         user_data)
 {
-  GtkWidget *win = (GtkWidget *)user_data;
-  /* delete the window */
-  gtk_container_remove(GTK_CONTAINER(GTK_WIDGET(cf.colors->color_filters)->parent),
-	cf.colors->color_filters);
-  gtk_widget_destroy(win);
+  /* Delete the dialog box */
+  gtk_widget_destroy(colorize_win);
+  colorize_win = NULL;
 }
 
 static void
 color_delete_cb(GtkWidget *widget, gpointer user_data)
 {
   colfilter *filter;
-  GtkWidget *color_change_colors;
+  GtkWidget *color_filters;
   color_filter_t *colorf;
+  GtkWidget *color_change_colors;
 
   filter = (colfilter *)user_data;
   if(filter->row_selected != -1){
-  	colorf = gtk_clist_get_row_data(GTK_CLIST(filter->color_filters),
-	   filter->row_selected);
-	gtk_clist_remove(GTK_CLIST(filter->color_filters),
+  	color_filters = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(widget),
+		      COLOR_FILTERS_CL);
+  	colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters),
 	   filter->row_selected);
+	gtk_clist_remove(GTK_CLIST(color_filters), filter->row_selected);
 	delete_color_filter(colorf);
 	filter->num_of_filters--;
         if(!filter->num_of_filters){
@@ -370,35 +360,40 @@ color_delete_cb(GtkWidget *widget, gpointer user_data)
 		filter->row_selected--;
 		if(filter->row_selected < 0)
 			filter->row_selected = 0;
-		gtk_clist_select_row(GTK_CLIST(filter->color_filters),
-		  filter->row_selected,0);
+		gtk_clist_select_row(GTK_CLIST(color_filters),
+		    filter->row_selected, 0);
 	}
   }
 }
 
 /* Move the selected filter up in the list */
 static void
-color_filt_up_cb                       (GtkButton       *button,
+color_filter_up_cb                     (GtkButton       *button,
                                         gpointer         user_data)
 {
   colfilter *filter;
   gint filter_number;
+  GtkWidget *color_filters;
+  color_filter_t *colorf;
 
   filter = (colfilter *)user_data;
-
-  /* verify filter exists */
   filter_number = filter->row_selected;
-  /* if it is filter number 0, it cannot be moved */
-  if(filter != NULL &&
-     (filter_number = filter->row_selected)  != 0 &&
-      filter->num_of_filters >= 2){
-	gtk_clist_swap_rows(GTK_CLIST(filter->color_filters),filter_number, filter_number-1);
+
+  /* If it is filter number 0, it cannot be moved, as it's already
+     at the top of the filter.
+     If there's only one filter in the list, it cannot be moved,
+     as there's no place to move it. */
+  if(filter_number != 0 && filter->num_of_filters >= 2) {
+  	color_filters = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(button),
+		      COLOR_FILTERS_CL);
+        colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters),
+	   filter_number);
+	gtk_clist_swap_rows(GTK_CLIST(color_filters), filter_number,
+			filter_number-1);
+	filter_list = g_slist_remove(filter_list, colorf);
+	filter_list = g_slist_insert(filter_list, colorf, filter_number-1);
 	filter->row_selected--;
-      }
-  else {
-	return;
   }
-
 }
 
 /* Move the selected filter down in the list */
@@ -408,14 +403,25 @@ color_filter_down_cb                   (GtkButton       *button,
 {
   colfilter *filter;
   gint filter_number;
+  GtkWidget *color_filters;
+  color_filter_t *colorf;
 
   filter = (colfilter *)user_data;
-  /* verify filter exists */
   filter_number = filter->row_selected;
-  if(filter != NULL && 
-     (filter_number = filter->row_selected) != filter->num_of_filters-1 && 
-      filter->num_of_filters >= 2){
-	gtk_clist_swap_rows(GTK_CLIST(filter->color_filters),filter_number+1, filter_number);
+
+  /* If it is the last filter in the list, it cannot be moved, as it's
+     already at the bottom of the filter.
+     If there's only one filter in the list, it cannot be moved,
+     as there's no place to move it. */
+  if(filter_number != filter->num_of_filters-1 && filter->num_of_filters >= 2) {
+  	color_filters = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(button),
+		      COLOR_FILTERS_CL);
+        colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters),
+	   filter_number);
+	gtk_clist_swap_rows(GTK_CLIST(color_filters), filter_number+1,
+			filter_number);
+	filter_list = g_slist_remove(filter_list, colorf);
+	filter_list = g_slist_insert(filter_list, colorf, filter_number+1);
 	filter->row_selected++;
   }
   else
@@ -444,11 +450,22 @@ color_new_cb                          (GtkButton       *button,
                                         gpointer         user_data)
 {
   colfilter *filter;
+  color_filter_t *colorf;
+  GtkWidget *color_filters;
+  gchar *data[2];
+  gint row;
   GtkWidget *color_change_colors;
 
   filter = (colfilter *)user_data;
-  new_color_filter(filter, "name", "filter"); /* Adds at end! */
-  
+  colorf = new_color_filter(filter, "name", "filter"); /* Adds at end! */
+
+  color_filters = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(button),
+		      COLOR_FILTERS_CL);
+  data[0] = colorf->filter_name;
+  data[1] = colorf->filter_text;
+  row = gtk_clist_append(GTK_CLIST(color_filters), data);
+  gtk_clist_set_row_data(GTK_CLIST(color_filters), row, colorf);
+
   /* A row has been added, so we can edit it. */
   color_change_colors = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(button),
 					COLOR_CHANGE_COLORS_LB);
@@ -457,9 +474,9 @@ color_new_cb                          (GtkButton       *button,
   /* select the new (last) row */
   filter->row_selected = filter->num_of_filters;
   filter->num_of_filters++;
-  gtk_clist_select_row(GTK_CLIST(filter->color_filters),
-  			filter->row_selected,-1);
-  create_colorize_win(filter, &filt_name_entry, &filt_text_entry);
+  gtk_clist_select_row(GTK_CLIST(color_filters), filter->row_selected, -1);
+  create_edit_color_filter_win(filter, color_filters, &filt_name_entry,
+				&filt_text_entry);
 }
 
 /* Change a filter */
@@ -468,15 +485,19 @@ color_edit_cb                        (GtkButton       *button,
                                       gpointer         user_data)
 {
   colfilter *filter;
-  filter = (colfilter *)user_data;
+  GtkWidget *color_filters;
 
+  filter = (colfilter *)user_data;
+  color_filters = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(button),
+		      COLOR_FILTERS_CL);
   if(filter->row_selected == -1){
-	  /* select the first row */
-	  filter->row_selected = 0;
-	  gtk_clist_select_row(GTK_CLIST(filter->color_filters),
-	      filter->row_selected,-1);
+	/* select the first row */
+	filter->row_selected = 0;
+	gtk_clist_select_row(GTK_CLIST(color_filters), filter->row_selected,
+				-1);
   }
-  create_colorize_win(filter, &filt_name_entry, &filt_text_entry);
+  create_edit_color_filter_win(filter, color_filters, &filt_name_entry,
+				&filt_text_entry);
 }
 
 
@@ -498,16 +519,12 @@ static void
 color_ok_cb                            (GtkButton       *button,
                                         gpointer         user_data)
 {
-  GtkWidget *dialog;
-  dialog = (GtkWidget *)user_data;
-
   /* colorize list */
-
   colorize_packets(&cf);
-  gtk_container_remove(GTK_CONTAINER(GTK_WIDGET(cf.colors->color_filters)->parent),
-	cf.colors->color_filters);
-  gtk_widget_destroy(dialog);
 
+  /* Delete the dialog box */
+  gtk_widget_destroy(colorize_win);
+  colorize_win = NULL;
 }
 
 /* Process all data by applying filters in list */
@@ -520,7 +537,7 @@ color_apply_cb                         (GtkButton       *button,
 
 /* Exit dialog and do not process list */
 static void
-colorize_cancel_cb                     (GtkObject       *object,
+edit_color_filter_cancel_cb            (GtkObject       *object,
                                         gpointer         user_data)
 {
 
@@ -533,35 +550,43 @@ colorize_cancel_cb                     (GtkObject       *object,
 static gint bg_set_flag; /* 0 -> setting foreground, 1-> setting background */
 /* Change the foreground color */
 static void
-colorize_fg_cb                         (GtkButton       *button,
+edit_color_filter_fg_cb                (GtkButton       *button,
                                         gpointer         user_data)
 {
   colfilter *filter;
-  color_filter_t * cof;
+  GtkWidget *color_filters;
+  color_filter_t *colorf;
 
   filter = (colfilter *)user_data;
-  cof = color_filter(filter->row_selected);
-  create_color_sel_win(filter, &cof->fg_color);
+  color_filters = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(button),
+		      COLOR_FILTERS_CL);
+  colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters),
+	   filter->row_selected);
+  create_color_sel_win(filter, &colorf->fg_color);
   bg_set_flag = 0;
 }
 
 /* Change the background color */
 static void
-colorize_bg_cb                         (GtkButton       *button,
+edit_color_filter_bg_cb                (GtkButton       *button,
                                         gpointer         user_data)
 {
   colfilter *filter;
-  color_filter_t * cof;
+  GtkWidget *color_filters;
+  color_filter_t *colorf;
 
   filter = (colfilter *)user_data;
-  cof = color_filter(filter->row_selected);
-  create_color_sel_win(filter, &cof->bg_color);
+  color_filters = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(button),
+		      COLOR_FILTERS_CL);
+  colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters),
+	   filter->row_selected);
+  create_color_sel_win(filter, &colorf->bg_color);
   bg_set_flag = 1;
 }
 
 /* accept color (and potential content) change */
 static void
-colorize_ok_cb                         (GtkButton       *button,
+edit_color_filter_ok_cb                (GtkButton       *button,
                                         gpointer         user_data)
 {
   GtkWidget *dialog;
@@ -570,8 +595,9 @@ colorize_ok_cb                         (GtkButton       *button,
   GdkColor new_bg_color;
   gchar *filter_name;
   gchar *filter_text;
-  color_filter_t *cfilter;
+  color_filter_t *colorf;
   dfilter *compiled_filter;
+  GtkWidget *color_filters;
 
   dialog = (GtkWidget *)user_data;
 
@@ -590,32 +616,35 @@ colorize_ok_cb                         (GtkButton       *button,
 	return;
   }
 
-  cfilter = color_filter(cf.colors->row_selected);
-  if (cfilter->filter_name != NULL)
-    g_free(cfilter->filter_name);
-  cfilter->filter_name = filter_name;
-  if (cfilter->filter_text != NULL)
-    g_free(cfilter->filter_text);
-  cfilter->filter_text = filter_text;
-  cfilter->fg_color = new_fg_color;
-  cfilter->bg_color = new_bg_color;
-  gtk_clist_set_foreground(GTK_CLIST(cf.colors->color_filters),
-	cf.colors->row_selected, &new_fg_color);
-  gtk_clist_set_background(GTK_CLIST(cf.colors->color_filters),
-	cf.colors->row_selected, &new_bg_color);
-
   if(dfilter_compile(filter_text, &compiled_filter) != 0 ){
 	simple_dialog(ESD_TYPE_WARN, NULL, "Filter \"%s\" did not compile correctly.\n"
-		" Please try again. Filter unchanged.\n%s\n", filter_name,dfilter_error_msg);
+		" Please try again. Filter unchanged.\n%s\n", filter_name,
+		dfilter_error_msg);
   } else {
+	color_filters = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(button),
+		      COLOR_FILTERS_CL);
+	colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters),
+	   cf.colors->row_selected);
 
-	if( color_filter(cf.colors->row_selected)->c_colorfilter != NULL)
-	    dfilter_destroy(color_filter(cf.colors->row_selected)->c_colorfilter);
-	color_filter(cf.colors->row_selected)->c_colorfilter = compiled_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;
+	colorf->fg_color = new_fg_color;
+	colorf->bg_color = new_bg_color;
+	gtk_clist_set_foreground(GTK_CLIST(color_filters),
+	    cf.colors->row_selected, &new_fg_color);
+	gtk_clist_set_background(GTK_CLIST(color_filters),
+	    cf.colors->row_selected, &new_bg_color);
+	if(colorf->c_colorfilter != NULL)
+	    dfilter_destroy(colorf->c_colorfilter);
+	colorf->c_colorfilter = compiled_filter;
 	/* gtk_clist_set_text frees old text (if any) and allocates new space */
-	gtk_clist_set_text(GTK_CLIST(cf.colors->color_filters),
+	gtk_clist_set_text(GTK_CLIST(color_filters),
 		cf.colors->row_selected, 0, filter_name);
-	gtk_clist_set_text(GTK_CLIST(cf.colors->color_filters),
+	gtk_clist_set_text(GTK_CLIST(color_filters),
 		cf.colors->row_selected, 1, filter_text);
         gtk_widget_destroy(dialog);
   }
@@ -669,6 +698,22 @@ color_sel_ok_cb                        (GtkButton       *button,
   }
 }
 
+static void
+add_filter_to_clist(gpointer filter_arg, gpointer clist_arg)
+{
+  color_filter_t *colorf = filter_arg;
+  GtkWidget *color_filters = clist_arg;
+  gchar *data[2];
+  gint row;
+
+  data[0] = colorf->filter_name;
+  data[1] = colorf->filter_text;
+  row = gtk_clist_append(GTK_CLIST(color_filters), data);
+  gtk_clist_set_row_data(GTK_CLIST(color_filters), row, colorf);
+  gtk_clist_set_foreground(GTK_CLIST(color_filters), row, &colorf->fg_color);
+  gtk_clist_set_background(GTK_CLIST(color_filters), row, &colorf->bg_color);
+}
+
 static GtkWidget*
 create_color_win (colfilter *filter)
 {
@@ -676,11 +721,11 @@ create_color_win (colfilter *filter)
   GtkWidget *vbox1;
   GtkWidget *hbox1;
   GtkWidget *vbox2;
-  GtkWidget *color_filt_up;
+  GtkWidget *color_filter_up;
   GtkWidget *label4;
   GtkWidget *color_filter_down;
   GtkWidget *scrolledwindow1;
-  GtkWidget *clist1;
+  GtkWidget *color_filters;
   GtkWidget *hbox2;
   GtkWidget *color_new;
   GtkWidget *color_change_colors;
@@ -721,13 +766,13 @@ create_color_win (colfilter *filter)
   gtk_box_pack_start (GTK_BOX (hbox1), vbox2, FALSE, TRUE, 0);
   gtk_widget_set_usize (vbox2, 150, -2);
 
-  color_filt_up = gtk_button_new_with_label (("Up"));
-  gtk_widget_ref (color_filt_up);
-  gtk_object_set_data_full (GTK_OBJECT (color_win), "color_filt_up", color_filt_up,
+  color_filter_up = gtk_button_new_with_label (("Up"));
+  gtk_widget_ref (color_filter_up);
+  gtk_object_set_data_full (GTK_OBJECT (color_win), "color_filter_up", color_filter_up,
                             (GtkDestroyNotify) gtk_widget_unref);
-  gtk_widget_show (color_filt_up);
-  gtk_box_pack_start (GTK_BOX (vbox2), color_filt_up, FALSE, FALSE, 0);
-  gtk_tooltips_set_tip (tooltips, color_filt_up, ("Move filter higher in list"), NULL);
+  gtk_widget_show (color_filter_up);
+  gtk_box_pack_start (GTK_BOX (vbox2), color_filter_up, FALSE, FALSE, 0);
+  gtk_tooltips_set_tip (tooltips, color_filter_up, ("Move filter higher in list"), NULL);
 
   label4 = gtk_label_new (("Move filter\nup or down\n[List is processed \n"
 			  "in order until\nmatch is found]"));
@@ -752,31 +797,22 @@ create_color_win (colfilter *filter)
   gtk_widget_show (scrolledwindow1);
   gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow1, TRUE, TRUE, 0);
 
-
-  /* Do we have a list of filters, yet? */
-  if( filter->color_filters == NULL) {
-	/* no color filters as of now.
-	 * This should probably be an assert...
-	 */
-        fprintf(stderr,"Null clist\n");
-		fflush(stderr);
-  }
-
-  clist1 = filter->color_filters;
-  gtk_widget_ref (clist1);
+  color_filters = gtk_clist_new_with_titles(2, titles);
 
 #if 0
   /* I don't seem to need this, but just in case, I'll if0 it */
-  gtk_object_set_data_full (GTK_OBJECT (color_win), "clist1", clist1,
+  gtk_object_set_data_full (GTK_OBJECT (color_win), "color_filters",
+                            color_filters,
                             (GtkDestroyNotify) gtk_widget_unref);
 #endif
+  g_slist_foreach(filter_list, add_filter_to_clist, color_filters);
 
-  gtk_widget_show (clist1);
-  gtk_container_add (GTK_CONTAINER (scrolledwindow1), clist1);
-  gtk_widget_set_usize (clist1, 300, -2);
-  gtk_clist_set_column_width (GTK_CLIST (clist1), 0, 80);
-  gtk_clist_set_column_width (GTK_CLIST (clist1), 1, 80);
-  gtk_clist_column_titles_show (GTK_CLIST (clist1));
+  gtk_widget_show (color_filters);
+  gtk_container_add (GTK_CONTAINER (scrolledwindow1), color_filters);
+  gtk_widget_set_usize (color_filters, 300, -2);
+  gtk_clist_set_column_width (GTK_CLIST (color_filters), 0, 80);
+  gtk_clist_set_column_width (GTK_CLIST (color_filters), 1, 80);
+  gtk_clist_column_titles_show (GTK_CLIST (color_filters));
 
   hbox2 = gtk_hbox_new (FALSE, 0);
   gtk_widget_ref (hbox2);
@@ -859,25 +895,35 @@ create_color_win (colfilter *filter)
   gtk_widget_set_usize (color_cancel, 50, 30);
   gtk_tooltips_set_tip (tooltips, color_cancel, ("No more filter changes; don't apply"), NULL);
 
-  gtk_signal_connect (GTK_OBJECT (color_filt_up), "clicked",
-                      GTK_SIGNAL_FUNC (color_filt_up_cb),
+  gtk_object_set_data(GTK_OBJECT (color_filter_up), COLOR_FILTERS_CL,
+                      color_filters);
+  gtk_signal_connect (GTK_OBJECT (color_filter_up), "clicked",
+                      GTK_SIGNAL_FUNC (color_filter_up_cb),
                       filter);
+  gtk_object_set_data(GTK_OBJECT (color_filter_down), COLOR_FILTERS_CL,
+                      color_filters);
   gtk_signal_connect (GTK_OBJECT (color_filter_down), "clicked",
                       GTK_SIGNAL_FUNC (color_filter_down_cb),
                       filter);
-  gtk_signal_connect (GTK_OBJECT (clist1), "select_row",
+  gtk_signal_connect (GTK_OBJECT (color_filters), "select_row",
                       GTK_SIGNAL_FUNC (remember_selected_row),
                       filter);
   gtk_object_set_data(GTK_OBJECT (color_new), COLOR_CHANGE_COLORS_LB,
                       color_change_colors);
+  gtk_object_set_data(GTK_OBJECT (color_new), COLOR_FILTERS_CL,
+                      color_filters);
   gtk_signal_connect (GTK_OBJECT (color_new), "clicked",
                       GTK_SIGNAL_FUNC (color_new_cb),
                       filter);
+  gtk_object_set_data(GTK_OBJECT (color_change_colors), COLOR_FILTERS_CL,
+                      color_filters);
   gtk_signal_connect (GTK_OBJECT (color_change_colors), "clicked",
                       GTK_SIGNAL_FUNC (color_edit_cb),
                       filter);
   gtk_object_set_data(GTK_OBJECT (color_delete), COLOR_CHANGE_COLORS_LB,
                       color_change_colors);
+  gtk_object_set_data(GTK_OBJECT (color_delete), COLOR_FILTERS_CL,
+                      color_filters);
   gtk_signal_connect (GTK_OBJECT (color_delete), "clicked",
                       GTK_SIGNAL_FUNC (color_delete_cb),
                       filter);
@@ -886,15 +932,15 @@ create_color_win (colfilter *filter)
                       filter);
   gtk_signal_connect (GTK_OBJECT (color_ok), "clicked",
                       GTK_SIGNAL_FUNC (color_ok_cb),
-                      color_win);
+                      NULL);
   gtk_signal_connect (GTK_OBJECT (color_apply), "clicked",
                       GTK_SIGNAL_FUNC (color_apply_cb),
                       filter);
   gtk_signal_connect (GTK_OBJECT (color_cancel), "clicked",
                       GTK_SIGNAL_FUNC (color_cancel_cb),
-                      color_win);
+                      NULL);
 
-  gtk_widget_grab_focus (clist1);
+  gtk_widget_grab_focus (color_filters);
   gtk_object_set_data (GTK_OBJECT (color_win), "tooltips", tooltips);
   gtk_widget_show (color_win);
 
@@ -902,11 +948,12 @@ create_color_win (colfilter *filter)
 }
 
 static GtkWidget*
-create_colorize_win (colfilter *filter,
+create_edit_color_filter_win (colfilter *filter,
+	GtkWidget *color_filters,
 	GtkWidget **colorize_filter_name,
 	GtkWidget **colorize_filter_text)
-	
 {
+  color_filter_t *colorf;
   GtkWidget *colorize_win;
   GtkWidget *vbox3;
   GtkWidget *hbox6;
@@ -915,13 +962,16 @@ create_colorize_win (colfilter *filter,
   GtkWidget *color_filter_text;
   GtkWidget *hbox5;
   GtkWidget *colorize_filter_fg;
-  GtkWidget *colorize_protocol_bg;
+  GtkWidget *colorize_filter_bg;
   GtkWidget *hbox4;
-  GtkWidget *colorize_proto_ok;
-  GtkWidget *colorize_proto_cancel;
+  GtkWidget *edit_color_filter_ok;
+  GtkWidget *edit_color_filter_cancel;
   GtkTooltips *tooltips;
   GtkStyle  *style;
 
+  colorf = gtk_clist_get_row_data(GTK_CLIST(color_filters),
+	   filter->row_selected);
+
   tooltips = gtk_tooltips_new ();
 
   colorize_win = gtk_window_new (GTK_WINDOW_DIALOG);
@@ -953,12 +1003,11 @@ create_colorize_win (colfilter *filter,
   gtk_widget_ref (*colorize_filter_name);
   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "*colorize_filter_name", *colorize_filter_name,
                             (GtkDestroyNotify) gtk_widget_unref);
-  gtk_entry_set_text(GTK_ENTRY(*colorize_filter_name),
-	color_filter(filter->row_selected)->filter_name);
+  gtk_entry_set_text(GTK_ENTRY(*colorize_filter_name), colorf->filter_name);
 
   style = gtk_style_copy(gtk_widget_get_style(*colorize_filter_name));
-  style->base[GTK_STATE_NORMAL] = color_filter(filter->row_selected)->bg_color;
-  style->fg[GTK_STATE_NORMAL]   = color_filter(filter->row_selected)->fg_color;
+  style->base[GTK_STATE_NORMAL] = colorf->bg_color;
+  style->fg[GTK_STATE_NORMAL]   = colorf->fg_color;
   gtk_widget_set_style(*colorize_filter_name, style);
 
   gtk_widget_show (*colorize_filter_name);
@@ -983,12 +1032,11 @@ create_colorize_win (colfilter *filter,
   gtk_widget_ref (*colorize_filter_text);
   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "*colorize_filter_text", *colorize_filter_text,
                             (GtkDestroyNotify) gtk_widget_unref);
-  gtk_entry_set_text(GTK_ENTRY(*colorize_filter_text),
-	color_filter(filter->row_selected)->filter_text);
+  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] = color_filter(filter->row_selected)->bg_color;
-  style->fg[GTK_STATE_NORMAL]   = color_filter(filter->row_selected)->fg_color;
+  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);
@@ -1011,13 +1059,13 @@ create_colorize_win (colfilter *filter,
   gtk_box_pack_start (GTK_BOX (hbox5), colorize_filter_fg, TRUE, FALSE, 0);
   gtk_tooltips_set_tip (tooltips, colorize_filter_fg, ("Select color for data display"), NULL);
 
-  colorize_protocol_bg = gtk_button_new_with_label (("Choose\nbackground\ncolor"));
-  gtk_widget_ref (colorize_protocol_bg);
-  gtk_object_set_data_full (GTK_OBJECT (colorize_win), "colorize_protocol_bg", colorize_protocol_bg,
+  colorize_filter_bg = gtk_button_new_with_label (("Choose\nbackground\ncolor"));
+  gtk_widget_ref (colorize_filter_bg);
+  gtk_object_set_data_full (GTK_OBJECT (colorize_win), "colorize_filter_bg", colorize_filter_bg,
                             (GtkDestroyNotify) gtk_widget_unref);
-  gtk_widget_show (colorize_protocol_bg);
-  gtk_box_pack_start (GTK_BOX (hbox5), colorize_protocol_bg, TRUE, FALSE, 0);
-  gtk_tooltips_set_tip (tooltips, colorize_protocol_bg, ("Select color for data display"), NULL);
+  gtk_widget_show (colorize_filter_bg);
+  gtk_box_pack_start (GTK_BOX (hbox5), colorize_filter_bg, TRUE, FALSE, 0);
+  gtk_tooltips_set_tip (tooltips, colorize_filter_bg, ("Select color for data display"), NULL);
 
   hbox4 = gtk_hbox_new (FALSE, 0);
   gtk_widget_ref (hbox4);
@@ -1027,39 +1075,45 @@ create_colorize_win (colfilter *filter,
   gtk_box_pack_start (GTK_BOX (vbox3), hbox4, TRUE, FALSE, 5);
   gtk_widget_set_usize (hbox4, -2, 40);
 
-  colorize_proto_ok = gtk_button_new_with_label (("OK"));
-  gtk_widget_ref (colorize_proto_ok);
-  gtk_object_set_data_full (GTK_OBJECT (colorize_win), "colorize_proto_ok", colorize_proto_ok,
+  edit_color_filter_ok = gtk_button_new_with_label (("OK"));
+  gtk_widget_ref (edit_color_filter_ok);
+  gtk_object_set_data_full (GTK_OBJECT (colorize_win), "edit_color_filter_ok", edit_color_filter_ok,
                             (GtkDestroyNotify) gtk_widget_unref);
-  gtk_widget_set_usize (colorize_proto_ok, 50, 30);
-  gtk_widget_show (colorize_proto_ok);
-  gtk_box_pack_start (GTK_BOX (hbox4), colorize_proto_ok, TRUE, FALSE, 0);
-  gtk_tooltips_set_tip (tooltips, colorize_proto_ok, ("Accept filter color change"), NULL);
-
-  colorize_proto_cancel = gtk_button_new_with_label (("Cancel"));
-  gtk_widget_ref (colorize_proto_cancel);
-  gtk_object_set_data_full (GTK_OBJECT (colorize_win), "colorize_proto_cancel", colorize_proto_cancel,
+  gtk_widget_set_usize (edit_color_filter_ok, 50, 30);
+  gtk_widget_show (edit_color_filter_ok);
+  gtk_box_pack_start (GTK_BOX (hbox4), 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);
+  gtk_object_set_data_full (GTK_OBJECT (colorize_win), "edit_color_filter_cancel", edit_color_filter_cancel,
                             (GtkDestroyNotify) gtk_widget_unref);
-  gtk_widget_set_usize (colorize_proto_cancel, 50, 30);
-  gtk_widget_show (colorize_proto_cancel);
-  gtk_box_pack_start (GTK_BOX (hbox4), colorize_proto_cancel, TRUE, FALSE, 0);
-  gtk_tooltips_set_tip (tooltips, colorize_proto_cancel, ("Reject filter color change"), NULL);
+  gtk_widget_set_usize (edit_color_filter_cancel, 50, 30);
+  gtk_widget_show (edit_color_filter_cancel);
+  gtk_box_pack_start (GTK_BOX (hbox4), edit_color_filter_cancel, TRUE, FALSE, 0);
+  gtk_tooltips_set_tip (tooltips, edit_color_filter_cancel, ("Reject filter color change"), NULL);
 #if 0
   gtk_signal_connect (GTK_OBJECT (colorize_win), "destroy",
-                      GTK_SIGNAL_FUNC (colorize_cancel_cb),
+                      GTK_SIGNAL_FUNC (edit_color_filter_cancel_cb),
                       colorize_win);
 #endif
+  gtk_object_set_data(GTK_OBJECT (colorize_filter_fg), COLOR_FILTERS_CL,
+                      color_filters);
   gtk_signal_connect (GTK_OBJECT (colorize_filter_fg), "clicked",
-                      GTK_SIGNAL_FUNC (colorize_fg_cb),
+                      GTK_SIGNAL_FUNC (edit_color_filter_fg_cb),
                       filter);
-  gtk_signal_connect (GTK_OBJECT (colorize_protocol_bg), "clicked",
-                      GTK_SIGNAL_FUNC (colorize_bg_cb),
+  gtk_object_set_data(GTK_OBJECT (colorize_filter_bg), COLOR_FILTERS_CL,
+                      color_filters);
+  gtk_signal_connect (GTK_OBJECT (colorize_filter_bg), "clicked",
+                      GTK_SIGNAL_FUNC (edit_color_filter_bg_cb),
                       filter);
-  gtk_signal_connect (GTK_OBJECT (colorize_proto_ok), "clicked",
-                      GTK_SIGNAL_FUNC (colorize_ok_cb),
+  gtk_object_set_data(GTK_OBJECT (edit_color_filter_ok), COLOR_FILTERS_CL,
+                      color_filters);
+  gtk_signal_connect (GTK_OBJECT (edit_color_filter_ok), "clicked",
+                      GTK_SIGNAL_FUNC (edit_color_filter_ok_cb),
                       colorize_win);
-  gtk_signal_connect (GTK_OBJECT (colorize_proto_cancel), "clicked",
-                      GTK_SIGNAL_FUNC (colorize_cancel_cb),
+  gtk_signal_connect (GTK_OBJECT (edit_color_filter_cancel), "clicked",
+                      GTK_SIGNAL_FUNC (edit_color_filter_cancel_cb),
                       colorize_win);
 
   gtk_object_set_data (GTK_OBJECT (colorize_win), "tooltips", tooltips);