gtk/color_dlg.c

   1 /* color_dlg.c
   2  * Definitions for dialog boxes for color filters
   3  *
   4  * $Id$
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include <string.h>
  30
  31 #include <gtk/gtk.h>
  32
  33 #include <epan/packet.h>
  34 #include <epan/dfilter/dfilter.h>
  35 #include <epan/prefs.h>
  36
  37 #include "../color.h"
  38 #include "../color_filters.h"
  39 #include "../file.h"
  40 #include "../simple_dialog.h"
  41
  42 #include "gtk/main.h"
  43 #include "gtk/color_utils.h"
  44 #include "gtk/color_dlg.h"
  45 #include "gtk/dlg_utils.h"
  46 #include "gtk/gui_utils.h"
  47 #include "gtk/dfilter_expr_dlg.h"
  48 #include "gtk/stock_icons.h"
  49 #include "gtk/filter_dlg.h"
  50 #include "gtk/capture_file_dlg.h"
  51 #include "gtk/gtkglobals.h"
  52 #include "gtk/help_dlg.h"
  53 #include "gtk/color_edit_dlg.h"
  54 #include "gtk/new_packet_list.h"
  55
  56
  57 #define BUTTON_SIZE_X -1
  58 #define BUTTON_SIZE_Y -1
  59
  60
  61 static GtkWidget* colorize_dialog_new(char *filter);
  62 static void add_filter_to_list(gpointer filter_arg, gpointer list_arg, gboolean prepend);
  63 static void color_filter_up_cb(GtkButton *button, gpointer user_data);
  64 static void color_filter_down_cb(GtkButton *button, gpointer user_data);
  65 static void remember_selected_row(GtkTreeSelection *sel, gpointer list);
  66 static void color_destroy_cb(GtkButton *button, gpointer user_data);
  67 static void destroy_edit_dialog_cb(gpointer filter_arg, gpointer dummy);
  68 static void create_new_color_filter(GtkButton *button, const char *filter);
  69 static void color_new_cb(GtkButton *button, gpointer user_data);
  70 static void color_edit_cb(GtkButton *button, gpointer user_data);
  71 static gboolean color_filters_button_cb(GtkWidget *, GdkEventButton *, gpointer);
  72 static void color_disable_cb(GtkWidget *widget, gboolean user_data);
  73 static void color_delete_cb(GtkWidget *widget, gpointer user_data);
  74 static void color_save_cb(GtkButton *button, gpointer user_data);
  75 static void color_ok_cb(GtkButton *button, gpointer user_data);
  76 static void color_cancel_cb(GtkWidget *widget, gpointer user_data);
  77 static void color_apply_cb(GtkButton *button, gpointer user_data);
  78 static void color_clear_cb(GtkWidget *button, gpointer user_data);
  79 static void color_import_cb(GtkButton *button, gpointer user_data );
  80 static void color_export_cb(GtkButton *button, gpointer user_data );
  81
  82
  83 static GtkWidget *colorize_win;
  84 gint      color_dlg_num_of_filters;  /* number of filters being displayed */
  85 gint      color_dlg_row_selected;    /* row in color_filters that is selected */
  86
  87 static gboolean  row_is_moving = FALSE;
  88
  89 /* This is a list of all current color filters in the dialog
  90  * (copied from color_filters.c and edited with the dialog).
  91  * The color filter items are not identical to the ones used for the
  92  * packet list display, so they can be safely edited.
  93  *
  94  * Keep the temporary filters in a separate list so that they are
  95  * not shown in the edit-dialog
  96  *
  97  * XXX - use the existing GTK list for this purpose and build temporary copies
  98  * e.g. for the save/export functions.
  99  * Problem: Don't know when able to safely throw away, e.g. while exporting.
 100  */
 101 static GSList *color_filter_edit_list = NULL;
 102 static GSList *color_filter_tmp_list = NULL;
 103
 104
 105 #define COLOR_UP_LB             "color_up_lb"
 106 #define COLOR_DOWN_LB           "color_down_lb"
 107 #define COLOR_EDIT_LB           "color_edit_lb"
 108 #define COLOR_ENABLE_LB         "color_enable_lb"
 109 #define COLOR_DISABLE_LB        "color_disable_lb"
 110 #define COLOR_DELETE_LB         "color_delete_lb"
 111 #define COLOR_FILTERS_CL        "color_filters_cl"
 112 #define COLOR_FILTER_LIST       "color_filter_list"
 113
 114
 115 /* Callback for the "Display:Coloring Rules" menu item. */
 116 void
 117 color_display_cb(GtkWidget *w _U_, gpointer d _U_)
 118 {
 119   if (colorize_win != NULL) {
 120     /* There's already a color dialog box active; reactivate it. */
 121     reactivate_window(colorize_win);
 122   } else {
 123     /* Create a new "Colorize Display" dialog. */
 124     colorize_win = colorize_dialog_new(NULL);
 125   }
 126 }
 127
 128 /* this opens the color dialog and presets the filter string */
 129 void
 130 color_display_with_filter(char *filter)
 131 {
 132   if (colorize_win != NULL) {
 133     /* There's already a color dialog box active; reactivate it. */
 134     reactivate_window(colorize_win);
 135   } else {
 136     /* Create a new "Colorize Display" dialog. */
 137     colorize_win = colorize_dialog_new(filter);
 138   }
 139 }
 140
 141 /* if this filter is selected - count it in the given int* */
 142 static void
 143 count_this_select(gpointer filter_arg, gpointer counter_arg)
 144 {
 145   color_filter_t *colorf = filter_arg;
 146   int * cnt = counter_arg;
 147
 148   if (colorf->selected)
 149     (*cnt)++;
 150 }
 151
 152 /* TODO: implement count of selected filters. Plug in to file_dlg update of "export selected" checkbox. */
 153 int color_selected_count(void)
 154 {
 155   int count = 0;
 156
 157   g_slist_foreach(color_filter_edit_list, count_this_select, &count);
 158
 159   return count;
 160 }
 161
 162 /* Create the "Coloring Rules" dialog. */
 163 static GtkWidget*
 164 colorize_dialog_new (char *filter)
 165 {
 166   GtkWidget *color_win;
 167   GtkWidget *dlg_vbox;
 168   GtkWidget *main_hbox;
 169   GtkWidget *ctrl_vbox;
 170 #if GTK_CHECK_VERSION(2,12,0)
 171 #else
 172   GtkTooltips *tooltips;
 173 #endif
 174   GtkWidget *order_fr;
 175   GtkWidget *order_vbox;
 176   GtkWidget *color_filter_up;
 177   GtkWidget *order_move_label;
 178   GtkWidget *color_filter_down;
 179
 180   GtkWidget *list_fr;
 181   GtkWidget *list_vbox;
 182   GtkWidget *scrolledwindow1;
 183   GtkWidget *color_filters;
 184   GtkWidget *list_label;
 185
 186   GtkWidget *edit_fr;
 187   GtkWidget *edit_vbox;
 188   GtkWidget *color_new;
 189   GtkWidget *color_edit;
 190   GtkWidget *color_enable;
 191   GtkWidget *color_disable;
 192   GtkWidget *color_delete;
 193
 194   GtkWidget *manage_fr;
 195   GtkWidget *manage_vbox;
 196   GtkWidget *color_import;
 197   GtkWidget *color_export;
 198   GtkWidget *color_clear;
 199
 200   GtkWidget *button_ok_hbox;
 201   GtkWidget *color_ok;
 202   GtkWidget *color_apply;
 203   GtkWidget *color_save;
 204   GtkWidget *color_cancel;
 205   GtkWidget *color_help;
 206
 207   GtkListStore      *store;
 208   GtkCellRenderer   *renderer;
 209   GtkTreeViewColumn *column;
 210   GtkTreeSelection  *selection;
 211   const gchar *titles[] = { "Name", "String" };
 212
 213
 214
 215   color_dlg_num_of_filters = 0;
 216   color_dlg_row_selected = -1; /* no row selected */
 217 #if GTK_CHECK_VERSION(2,12,0)
 218 #else
 219   tooltips = gtk_tooltips_new ();
 220 #endif
 221   /* Resizing of the dialog window is now reasonably done.
 222    * Default size is set so that it should fit into every usual screen resolution.
 223    * All other widgets are always packed depending on the current window size. */
 224   color_win = dlg_conf_window_new ("Wireshark: Coloring Rules");
 225   g_object_set_data(G_OBJECT(color_win), "color_win", color_win);
 226   gtk_window_set_default_size(GTK_WINDOW(color_win), DEF_WIDTH, DEF_HEIGHT * 2/3);
 227   dlg_vbox = gtk_vbox_new (FALSE, 0);
 228   gtk_container_set_border_width  (GTK_CONTAINER (dlg_vbox), 5);
 229   gtk_container_add (GTK_CONTAINER (color_win), dlg_vbox);
 230
 231   main_hbox = gtk_hbox_new (FALSE, 0);
 232   gtk_box_pack_start (GTK_BOX (dlg_vbox), main_hbox, TRUE, TRUE, 0);
 233
 234   ctrl_vbox = gtk_vbox_new (FALSE, 0);
 235   gtk_box_pack_start (GTK_BOX (main_hbox), ctrl_vbox, FALSE, FALSE, 0);
 236
 237   /* edit buttons frame */
 238   edit_fr = gtk_frame_new("Edit");
 239   gtk_box_pack_start (GTK_BOX (ctrl_vbox), edit_fr, TRUE, TRUE, 0);
 240
 241   /* edit_vbox is first button column (containing: new, edit and such) */
 242   edit_vbox = gtk_vbox_new(TRUE, 0);
 243   gtk_container_set_border_width  (GTK_CONTAINER (edit_vbox), 5);
 244   gtk_container_add(GTK_CONTAINER(edit_fr), edit_vbox);
 245
 246   color_new = gtk_button_new_from_stock(GTK_STOCK_NEW);
 247   gtk_box_pack_start (GTK_BOX (edit_vbox), color_new, FALSE, FALSE, 5);
 248 #if GTK_CHECK_VERSION(2,12,0)
 249   gtk_widget_set_tooltip_text(color_new, "Create a new filter at the top of the list");
 250 #else
 251   gtk_tooltips_set_tip (tooltips, color_new, ("Create a new filter at the top of the list"), NULL);
 252 #endif
 253
 254   color_edit = gtk_button_new_from_stock(WIRESHARK_STOCK_EDIT);
 255   gtk_box_pack_start (GTK_BOX (edit_vbox), color_edit, FALSE, FALSE, 5);
 256 #if GTK_CHECK_VERSION(2,12,0)
 257   gtk_widget_set_tooltip_text(color_edit, " If more than one filter is selected, edit the first selected one");
 258 #else
 259   gtk_tooltips_set_tip (tooltips, color_edit, ("Edit the properties of the selected filter."
 260       " If more than one filter is selected, edit the first selected one"), NULL);
 261 #endif
 262   gtk_widget_set_sensitive (color_edit, FALSE);
 263
 264   color_enable = gtk_button_new_from_stock(WIRESHARK_STOCK_ENABLE);
 265   gtk_box_pack_start (GTK_BOX (edit_vbox), color_enable, FALSE, FALSE, 5);
 266 #if GTK_CHECK_VERSION(2,12,0)
 267   gtk_widget_set_tooltip_text(color_enable, "Enable the selected filter(s)");
 268 #else
 269   gtk_tooltips_set_tip (tooltips, color_enable, ("Enable the selected filter(s)"), NULL);
 270 #endif
 271   gtk_widget_set_sensitive (color_enable, FALSE);
 272
 273   color_disable = gtk_button_new_from_stock(WIRESHARK_STOCK_DISABLE);
 274   gtk_box_pack_start (GTK_BOX (edit_vbox), color_disable, FALSE, FALSE, 5);
 275 #if GTK_CHECK_VERSION(2,12,0)
 276   gtk_widget_set_tooltip_text(color_disable, "Disable the selected filter(s)");
 277 #else
 278   gtk_tooltips_set_tip (tooltips, color_disable, ("Disable the selected filter(s)"), NULL);
 279 #endif
 280   gtk_widget_set_sensitive (color_disable, FALSE);
 281
 282   color_delete = gtk_button_new_from_stock(GTK_STOCK_DELETE);
 283   gtk_box_pack_start (GTK_BOX (edit_vbox), color_delete, FALSE, FALSE, 5);
 284 #if GTK_CHECK_VERSION(2,12,0)
 285   gtk_widget_set_tooltip_text(color_delete, "Delete the selected filter(s)");
 286 #else
 287   gtk_tooltips_set_tip (tooltips, color_delete, ("Delete the selected filter(s)"), NULL);
 288 #endif
 289   gtk_widget_set_sensitive (color_delete, FALSE);
 290   /* End edit buttons frame */
 291
 292
 293   /* manage buttons frame */
 294   manage_fr = gtk_frame_new("Manage");
 295   gtk_box_pack_start (GTK_BOX (ctrl_vbox), manage_fr, TRUE, TRUE, 0);
 296
 297   manage_vbox = gtk_vbox_new (TRUE, 0);
 298   gtk_container_set_border_width  (GTK_CONTAINER (manage_vbox), 5);
 299   gtk_container_add(GTK_CONTAINER(manage_fr), manage_vbox);
 300
 301   color_import = gtk_button_new_from_stock(WIRESHARK_STOCK_IMPORT);
 302   gtk_box_pack_start (GTK_BOX (manage_vbox), color_import, FALSE, FALSE, 5);
 303 #if GTK_CHECK_VERSION(2,12,0)
 304   gtk_widget_set_tooltip_text(color_import, "Load filters from a file and append them to the list");
 305 #else
 306   gtk_tooltips_set_tip(tooltips, color_import, ("Load filters from a file and append them to the list"), NULL);
 307 #endif
 308   color_export = gtk_button_new_from_stock(WIRESHARK_STOCK_EXPORT);
 309   gtk_box_pack_start (GTK_BOX (manage_vbox), color_export, FALSE, FALSE, 5);
 310 #if GTK_CHECK_VERSION(2,12,0)
 311   gtk_widget_set_tooltip_text(color_export, "Save all/selected filters to a file");
 312 #else
 313   gtk_tooltips_set_tip(tooltips, color_export, ("Save all/selected filters to a file"), NULL);
 314 #endif
 315   color_clear = gtk_button_new_from_stock(GTK_STOCK_CLEAR);
 316   gtk_box_pack_start(GTK_BOX (manage_vbox), color_clear, FALSE, FALSE, 5);
 317 #if GTK_CHECK_VERSION(2,12,0)
 318   gtk_widget_set_tooltip_text(color_clear, "Clear the filter list and revert to system-wide default filter set");
 319 #else
 320   gtk_tooltips_set_tip(tooltips, color_clear, ("Clear the filter list and revert to system-wide default filter set"), NULL);
 321 #endif
 322
 323   /* filter list frame */
 324   list_fr = gtk_frame_new("Filter");
 325   gtk_box_pack_start (GTK_BOX (main_hbox), list_fr, TRUE, TRUE, 0);
 326
 327   list_vbox = gtk_vbox_new (FALSE, 0);
 328   gtk_container_set_border_width  (GTK_CONTAINER (list_vbox), 5);
 329   gtk_container_add(GTK_CONTAINER(list_fr), list_vbox);
 330
 331   list_label = gtk_label_new (("List is processed in order until match is found"));
 332   gtk_box_pack_start (GTK_BOX (list_vbox), list_label, FALSE, FALSE, 0);
 333
 334   /* create the list of filters */
 335   scrolledwindow1 = scrolled_window_new(NULL, NULL);
 336   gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow1),
 337                                    GTK_SHADOW_IN);
 338   gtk_box_pack_start (GTK_BOX (list_vbox), scrolledwindow1, TRUE, TRUE, 0);
 339
 340   /* the list store contains : filter name, filter string, foreground
 341    * color, background color, pointer to color filter */
 342   store = gtk_list_store_new(6,
 343                                  G_TYPE_STRING,
 344                                  G_TYPE_STRING,
 345                                  G_TYPE_STRING,
 346                                  G_TYPE_STRING,
 347                                  G_TYPE_BOOLEAN,
 348                                  G_TYPE_POINTER);
 349   color_filters = tree_view_new(GTK_TREE_MODEL(store));
 350   g_object_unref(store);
 351   renderer = gtk_cell_renderer_text_new();
 352   column = gtk_tree_view_column_new_with_attributes(titles[0], renderer,
 353                                                     "text", 0,
 354                                                     "foreground", 2,
 355                                                     "background", 3,
 356                                                     "strikethrough", 4,
 357                                                     NULL);
 358   gtk_tree_view_column_set_fixed_width(column, 80);
 359   gtk_tree_view_append_column(GTK_TREE_VIEW(color_filters), column);
 360   renderer = gtk_cell_renderer_text_new();
 361   column = gtk_tree_view_column_new_with_attributes(titles[1], renderer,
 362                                                     "text", 1,
 363                                                     "foreground", 2,
 364                                                     "background", 3,
 365                                                     "strikethrough", 4,
 366                                                     NULL);
 367   gtk_tree_view_column_set_fixed_width(column, 300);
 368   gtk_tree_view_append_column(GTK_TREE_VIEW(color_filters), column);
 369   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(color_filters), TRUE);
 370   gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(color_filters), FALSE);
 371
 372   selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
 373   gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
 374
 375   gtk_container_add (GTK_CONTAINER (scrolledwindow1), color_filters);
 376
 377
 378   /* order frame */
 379   order_fr = gtk_frame_new("Order");
 380   gtk_box_pack_start (GTK_BOX (main_hbox), order_fr, FALSE, FALSE, 0);
 381
 382   order_vbox = gtk_vbox_new (TRUE, 0);
 383   gtk_container_set_border_width  (GTK_CONTAINER (order_vbox), 5);
 384   gtk_container_add(GTK_CONTAINER(order_fr), order_vbox);
 385
 386   color_filter_up = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
 387   gtk_box_pack_start (GTK_BOX (order_vbox), color_filter_up, FALSE, FALSE, 0);
 388 #if GTK_CHECK_VERSION(2,12,0)
 389   gtk_widget_set_tooltip_text(color_filter_up, "Move filter higher in list");
 390 #else
 391   gtk_tooltips_set_tip (tooltips, color_filter_up, ("Move filter higher in list"), NULL);
 392 #endif
 393   gtk_widget_set_sensitive (color_filter_up, FALSE);
 394
 395   order_move_label = gtk_label_new (("Move\nselected filter\nup or down"));
 396   gtk_box_pack_start (GTK_BOX (order_vbox), order_move_label, FALSE, FALSE, 0);
 397
 398   color_filter_down = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
 399   gtk_box_pack_start (GTK_BOX (order_vbox), color_filter_down, FALSE, FALSE, 0);
 400 #if GTK_CHECK_VERSION(2,12,0)
 401   gtk_widget_set_tooltip_text(color_filter_down, "Move filter lower in list");
 402 #else
 403   gtk_tooltips_set_tip (tooltips, color_filter_down, ("Move filter lower in list"), NULL);
 404 #endif
 405   gtk_widget_set_sensitive (color_filter_down, FALSE);
 406
 407
 408   /* Button row: OK, cancel and help buttons */
 409   button_ok_hbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_APPLY, GTK_STOCK_SAVE, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL);
 410   gtk_box_pack_start (GTK_BOX (dlg_vbox), button_ok_hbox, FALSE, FALSE, 5);
 411
 412   color_ok = g_object_get_data(G_OBJECT(button_ok_hbox), GTK_STOCK_OK);
 413 #if GTK_CHECK_VERSION(2,12,0)
 414   gtk_widget_set_tooltip_text(color_ok, "Apply the color filters to the display and close this dialog");
 415 #else
 416   gtk_tooltips_set_tip (tooltips, color_ok, ("Apply the color filters to the display and close this dialog"), NULL);
 417 #endif
 418   color_apply = g_object_get_data(G_OBJECT(button_ok_hbox), GTK_STOCK_APPLY);
 419 #if GTK_CHECK_VERSION(2,12,0)
 420   gtk_widget_set_tooltip_text(color_apply, "Apply the color filters to the display and keep this dialog open");
 421 #else
 422   gtk_tooltips_set_tip (tooltips, color_apply, ("Apply the color filters to the display and keep this dialog open"), NULL);
 423 #endif
 424
 425   color_save = g_object_get_data(G_OBJECT(button_ok_hbox), GTK_STOCK_SAVE);
 426 #if GTK_CHECK_VERSION(2,12,0)
 427   gtk_widget_set_tooltip_text(color_save, "Save the color filters permanently and keep this dialog open");
 428 #else
 429   gtk_tooltips_set_tip (tooltips, color_save, ("Save the color filters permanently and keep this dialog open"), NULL);
 430 #endif
 431   color_cancel = g_object_get_data(G_OBJECT(button_ok_hbox), GTK_STOCK_CANCEL);
 432   window_set_cancel_button(color_win, color_cancel, color_cancel_cb);
 433 #if GTK_CHECK_VERSION(2,12,0)
 434   gtk_widget_set_tooltip_text(color_cancel, "Cancel changes done (since last \"Apply\") and close this dialog");
 435 #else
 436   gtk_tooltips_set_tip (tooltips, color_cancel, ("Cancel changes done (since last \"Apply\") and close this dialog"), NULL);
 437 #endif
 438
 439   color_help = g_object_get_data(G_OBJECT(button_ok_hbox), GTK_STOCK_HELP);
 440 #if GTK_CHECK_VERSION(2,12,0)
 441   gtk_widget_set_tooltip_text(color_help, "Get help about this dialog");
 442 #else
 443   gtk_tooltips_set_tip (tooltips, color_help, ("Get help about this dialog"), NULL);
 444 #endif
 445   g_signal_connect(color_help, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_COLORING_RULES_DIALOG);
 446
 447   gtk_widget_grab_default(color_ok);
 448
 449   /* signals and such */
 450   g_signal_connect(color_win, "destroy", G_CALLBACK(color_destroy_cb), NULL);
 451   g_object_set_data(G_OBJECT(color_filter_up), COLOR_FILTERS_CL, color_filters);
 452   g_signal_connect(color_filter_up, "clicked", G_CALLBACK(color_filter_up_cb), NULL);
 453   g_object_set_data(G_OBJECT(color_filter_down), COLOR_FILTERS_CL, color_filters);
 454   g_signal_connect(color_filter_down, "clicked", G_CALLBACK(color_filter_down_cb), NULL);
 455   g_signal_connect(selection, "changed", G_CALLBACK(remember_selected_row), color_filters);
 456   g_signal_connect(color_filters, "button_press_event", G_CALLBACK(color_filters_button_cb), NULL);
 457   g_object_set_data(G_OBJECT(color_filters), COLOR_UP_LB, color_filter_up);
 458   g_object_set_data(G_OBJECT(color_filters), COLOR_DOWN_LB, color_filter_down);
 459   g_object_set_data(G_OBJECT(color_filters), COLOR_EDIT_LB, color_edit);
 460   g_object_set_data(G_OBJECT(color_filters), COLOR_ENABLE_LB, color_enable);
 461   g_object_set_data(G_OBJECT(color_filters), COLOR_DISABLE_LB, color_disable);
 462   g_object_set_data(G_OBJECT(color_filters), COLOR_DELETE_LB, color_delete);
 463   g_object_set_data(G_OBJECT(color_new), COLOR_FILTERS_CL, color_filters);
 464   g_signal_connect(color_new, "clicked", G_CALLBACK(color_new_cb), NULL);
 465   g_object_set_data(G_OBJECT(color_edit), COLOR_FILTERS_CL, color_filters);
 466   g_signal_connect(color_edit, "clicked", G_CALLBACK(color_edit_cb), NULL);
 467   g_object_set_data(G_OBJECT(color_enable), COLOR_FILTERS_CL, color_filters);
 468   g_signal_connect(color_enable, "clicked", G_CALLBACK(color_disable_cb), FALSE);
 469   g_object_set_data(G_OBJECT(color_disable), COLOR_FILTERS_CL, color_filters);
 470   g_signal_connect(color_disable, "clicked", G_CALLBACK(color_disable_cb), (gpointer)TRUE);
 471   g_object_set_data(G_OBJECT(color_delete), COLOR_EDIT_LB, color_edit);
 472   g_object_set_data(G_OBJECT(color_delete), COLOR_FILTERS_CL, color_filters);
 473   g_signal_connect(color_delete, "clicked", G_CALLBACK(color_delete_cb), NULL);
 474   g_object_set_data(G_OBJECT(color_import), COLOR_FILTERS_CL, color_filters);
 475   g_signal_connect(color_import, "clicked", G_CALLBACK(color_import_cb), NULL);
 476   g_signal_connect(color_export, "clicked", G_CALLBACK(color_export_cb), NULL);
 477   g_object_set_data(G_OBJECT(color_clear), COLOR_FILTERS_CL, color_filters);
 478   g_signal_connect(color_clear, "clicked", G_CALLBACK(color_clear_cb), NULL);
 479   g_signal_connect(color_ok, "clicked", G_CALLBACK(color_ok_cb), NULL);
 480   g_signal_connect(color_apply, "clicked", G_CALLBACK(color_apply_cb), NULL);
 481   g_signal_connect(color_save, "clicked", G_CALLBACK(color_save_cb), NULL);
 482
 483   g_signal_connect(color_win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
 484
 485   gtk_widget_grab_focus(color_filters);
 486
 487   /* prepare filter list content */
 488   color_filters_clone(color_filters);
 489   g_object_set_data(G_OBJECT(color_win), COLOR_FILTER_LIST, &color_filter_edit_list);
 490
 491   gtk_widget_show_all(color_win);
 492
 493   /* hide the Save button if the user uses implicit save */
 494   if(!prefs.gui_use_pref_save) {
 495     gtk_widget_hide(color_save);
 496   }
 497
 498   window_present(color_win);
 499
 500   if(filter){
 501     /* if we specified a preset filter string, open the new dialog and
 502        set the filter */
 503     create_new_color_filter(GTK_BUTTON(color_new), filter);
 504   }
 505
 506   return color_win;
 507 }
 508
 509 /* move a row in the list +/- one position up/down */
 510 static void move_this_row (GtkWidget   *color_filters,
 511                      gint         filter_number,
 512                      gint         amount)            /* only tested with +1(down) and -1(up) */
 513 {
 514   color_filter_t *colorf;
 515   GtkTreeModel   *model;
 516   GtkTreeIter     iter1, iter2;
 517   gchar          *name, *string, *fg_str, *bg_str;
 518   gboolean        disabled;
 519
 520   g_assert(amount == +1 || amount == -1);
 521   g_assert(amount == +1 || filter_number > 0);
 522   g_assert(amount == -1 || filter_number < color_dlg_num_of_filters - 1);
 523
 524   row_is_moving = TRUE;
 525   model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
 526   gtk_tree_model_iter_nth_child(model, &iter1, NULL, filter_number);
 527   gtk_tree_model_iter_nth_child(model, &iter2, NULL, filter_number + amount);
 528
 529   gtk_tree_model_get(model, &iter1, 0, &name, 1, &string,
 530                      2, &fg_str, 3, &bg_str, 4, &disabled, 5, &colorf, -1);
 531   gtk_list_store_remove(GTK_LIST_STORE(model), &iter1);
 532   if (amount < 0)
 533     gtk_list_store_insert_before(GTK_LIST_STORE(model), &iter1, &iter2);
 534   else
 535     gtk_list_store_insert_after(GTK_LIST_STORE(model), &iter1, &iter2);
 536
 537   gtk_list_store_set(GTK_LIST_STORE(model), &iter1,
 538           0, name,
 539           1, string,
 540           2, fg_str,
 541           3, bg_str,
 542           4, disabled,
 543           5, colorf, -1);
 544
 545   g_free(name);
 546   g_free(string);
 547   g_free(fg_str);
 548   g_free(bg_str);
 549   row_is_moving = FALSE;
 550
 551   /*
 552    * re-select the initial row
 553    */
 554   gtk_widget_grab_focus(color_filters);
 555   gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters)), &iter1);
 556
 557   color_filter_edit_list = g_slist_remove(color_filter_edit_list, colorf);
 558   color_filter_edit_list = g_slist_insert(color_filter_edit_list, colorf, filter_number + amount);
 559 }
 560
 561 /* User pressed the "Up" button: Move the selected filters up in the list */
 562 static void
 563 color_filter_up_cb(GtkButton *button, gpointer user_data _U_)
 564 {
 565   gint amount;
 566   gint filter_number;
 567   GtkWidget * color_filters;
 568   color_filter_t *colorf;
 569   GtkTreeIter       iter;
 570   GtkTreeModel     *model;
 571   GtkTreeSelection *sel;
 572
 573   amount = -1;
 574   color_filters = (GtkWidget *)g_object_get_data(G_OBJECT(button), COLOR_FILTERS_CL);
 575
 576   for (filter_number = 0; filter_number < color_dlg_num_of_filters; filter_number++)
 577   {
 578     model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
 579     gtk_tree_model_iter_nth_child(model, &iter, NULL, filter_number);
 580     gtk_tree_model_get(model, &iter, 5, &colorf, -1);
 581     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
 582     if (gtk_tree_selection_iter_is_selected(sel, &iter))
 583       move_this_row (color_filters, filter_number, amount);
 584   }
 585 }
 586
 587 /* User pressed the "Down" button: Move the selected filters down in the list */
 588 static void
 589 color_filter_down_cb(GtkButton *button, gpointer user_data _U_)
 590 {
 591   gint amount;
 592   gint filter_number;
 593   GtkWidget * color_filters;
 594   color_filter_t *colorf;
 595   GtkTreeIter     iter;
 596   GtkTreeModel   *model;
 597
 598   amount = +1;
 599   color_filters = (GtkWidget *)g_object_get_data(G_OBJECT(button), COLOR_FILTERS_CL);
 600
 601   for (filter_number = color_dlg_num_of_filters - 1; filter_number >= 0; filter_number--)
 602   {
 603     model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
 604     gtk_tree_model_iter_nth_child(model, &iter, NULL, filter_number);
 605     gtk_tree_model_get(model, &iter, 5, &colorf, -1);
 606     if (colorf->selected)
 607       move_this_row (color_filters, filter_number, amount);
 608   }
 609 }
 610
 611
 612 struct remember_data
 613 {
 614   gint count;               /* count of selected filters */
 615   gboolean first_selected;  /* true if the first filter in the list is selected */
 616   gboolean last_selected;   /* true if the last filter in the list is selected */
 617   gboolean all_enabled;     /* true if all selected coloring rules are enabled */
 618   gboolean all_disabled;    /* true if all selected coloring rules are disabled */
 619   gpointer color_filters;
 620 };
 621 /* called for each selected row in the tree.
 622  */
 623 static void remember_this_row (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer arg)
 624 {
 625   gint         *path_index;
 626   color_filter_t *colorf;
 627   struct remember_data *data = arg;
 628
 629   gtk_tree_model_get(model, iter, 5, &colorf, -1);
 630   colorf->selected = TRUE;
 631
 632   data->all_enabled  &= (!colorf->disabled);
 633   data->all_disabled &= colorf->disabled;
 634
 635   path_index = gtk_tree_path_get_indices(path);   /* not to be freed */
 636   if (path_index == NULL)       /* can return NULL according to API doc.*/
 637   {
 638     return;
 639   }
 640   color_dlg_row_selected = path_index[0];
 641
 642   if (color_dlg_row_selected == 0)
 643     data->first_selected = TRUE;
 644   if (color_dlg_row_selected == color_dlg_num_of_filters - 1)
 645     data->last_selected = TRUE;
 646
 647   data->count++;
 648
 649   gtk_tree_view_scroll_to_cell(data->color_filters, path, NULL, FALSE, 0.0f, 0.0f);
 650 }
 651
 652 /* clear the selection flag of this filter */
 653 static void
 654 clear_select_flag(gpointer filter_arg, gpointer arg _U_)
 655 {
 656   color_filter_t *colorf = filter_arg;
 657
 658   colorf->selected = FALSE;
 659 }
 660
 661 /* The gtk+2.0 version gets called for, (maybe multiple,) changes in the selection. */
 662 static void
 663 remember_selected_row(GtkTreeSelection *sel, gpointer color_filters)
 664 {
 665   GtkWidget    *button;
 666   struct remember_data data;
 667
 668   data.first_selected = data.last_selected = FALSE;
 669   data.all_enabled = data.all_disabled = TRUE;
 670   data.count = 0;
 671   data.color_filters = color_filters;
 672
 673   g_slist_foreach(color_filter_edit_list, clear_select_flag, NULL);
 674   gtk_tree_selection_selected_foreach(sel,remember_this_row, &data);
 675
 676   if (data.count > 0)
 677   {
 678     /*
 679      * One or more rows are selected, so we can operate on them.
 680      */
 681
 682     /* We can only edit if there is exactly one filter selected */
 683     button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_EDIT_LB);
 684     gtk_widget_set_sensitive (button, data.count == 1);
 685
 686     /* We can enable any number of filters */
 687     button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_ENABLE_LB);
 688     gtk_widget_set_sensitive (button, !data.all_enabled);
 689
 690     /* We can disable any number of filters */
 691     button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_DISABLE_LB);
 692     gtk_widget_set_sensitive (button, !data.all_disabled);
 693
 694     /* We can delete any number of filters */
 695     button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_DELETE_LB);
 696     gtk_widget_set_sensitive (button, TRUE);
 697
 698     /*
 699      * We can move them up *if* one of them isn't the top row,
 700      * and move them down *if* one of them isn't the bottom row.
 701      */
 702     button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_UP_LB);
 703     gtk_widget_set_sensitive(button, !data.first_selected);
 704     button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_DOWN_LB);
 705     gtk_widget_set_sensitive(button, !data.last_selected);
 706   }
 707   else
 708   {
 709     color_dlg_row_selected = -1;
 710
 711     /*
 712      * No row is selected, so we can't do operations that affect the
 713      * selected row.
 714      */
 715     if (!row_is_moving) {
 716       button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_UP_LB);
 717       gtk_widget_set_sensitive (button, FALSE);
 718       button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_DOWN_LB);
 719       gtk_widget_set_sensitive (button, FALSE);
 720     }
 721     button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_EDIT_LB);
 722     gtk_widget_set_sensitive (button, FALSE);
 723     button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_ENABLE_LB);
 724     gtk_widget_set_sensitive (button, FALSE);
 725     button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_DISABLE_LB);
 726     gtk_widget_set_sensitive (button, FALSE);
 727     button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_DELETE_LB);
 728     gtk_widget_set_sensitive (button, FALSE);
 729   }
 730 }
 731
 732
 733
 734 /* destroy a single color edit dialog */
 735 static void
 736 destroy_edit_dialog_cb(gpointer filter_arg, gpointer dummy _U_)
 737 {
 738   color_filter_t *colorf = (color_filter_t *)filter_arg;
 739
 740   if (colorf->edit_dialog != NULL)
 741     window_destroy(colorf->edit_dialog);
 742 }
 743
 744 /* Called when the dialog box is being destroyed; destroy any edit
 745  * dialogs opened from this dialog.
 746  */
 747 static void
 748 color_destroy_cb                       (GtkButton       *button _U_,
 749                                         gpointer         user_data _U_)
 750 {
 751   /* Destroy any edit dialogs we have open. */
 752   g_slist_foreach(color_filter_edit_list, destroy_edit_dialog_cb, NULL);
 753
 754   /* destroy the filter list itself */
 755   color_filter_list_delete(&color_filter_edit_list);
 756   color_filter_list_delete(&color_filter_tmp_list);
 757
 758   colorize_win = NULL;
 759 }
 760
 761
 762 static void
 763 select_row(GtkWidget *color_filters, int row)
 764 {
 765   GtkTreeModel     *model;
 766   GtkTreeIter       iter;
 767   GtkTreeSelection *sel;
 768
 769   /* select the new row */
 770   model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
 771   gtk_tree_model_iter_nth_child(model, &iter, NULL, row);
 772   sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
 773   gtk_tree_selection_select_iter(sel, &iter);
 774 }
 775
 776
 777 /* add a single color filter to the list */
 778 static void
 779 add_filter_to_list(gpointer filter_arg, gpointer list_arg, gboolean prepend)
 780 {
 781   color_filter_t *colorf = filter_arg;
 782     gchar           fg_str[14], bg_str[14];
 783     GtkListStore   *store;
 784     GtkTreeIter     iter;
 785
 786   if( strstr(colorf->filter_name,TEMP_COLOR_PREFIX)==NULL) {
 787     store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(list_arg)));
 788     if (prepend) {
 789       gtk_list_store_prepend(store, &iter);
 790     } else {
 791       gtk_list_store_append(store, &iter);
 792     }
 793     g_snprintf(fg_str, sizeof(fg_str), "#%04X%04X%04X",
 794             colorf->fg_color.red, colorf->fg_color.green, colorf->fg_color.blue);
 795     g_snprintf(bg_str, sizeof(bg_str), "#%04X%04X%04X",
 796             colorf->bg_color.red, colorf->bg_color.green, colorf->bg_color.blue);
 797     gtk_list_store_set(store, &iter,
 798                 0, colorf->filter_name,
 799                 1, colorf->filter_text,
 800                 2, fg_str,
 801                 3, bg_str,
 802                 4, colorf->disabled,
 803                 5, colorf, -1);
 804     if (prepend) {
 805       color_filter_edit_list = g_slist_prepend(color_filter_edit_list, colorf);
 806     } else {
 807       color_filter_edit_list = g_slist_append(color_filter_edit_list, colorf);
 808     }
 809     color_dlg_num_of_filters++;
 810   } else {
 811     /* But keep the temporary ones too, so they can be added again
 812      * when the user is done editing */
 813     color_filter_tmp_list = g_slist_append(color_filter_tmp_list, colorf);
 814   }
 815 }
 816
 817
 818 /* a new color filter was read in from a filter file */
 819 void
 820 color_filter_add_cb(color_filter_t *colorf, gpointer user_data)
 821 {
 822   GtkWidget        *color_filters = user_data;
 823
 824   add_filter_to_list(colorf, color_filters, FALSE);
 825
 826   gtk_widget_grab_focus(color_filters);
 827 }
 828
 829 /* Create a new filter, add it to the list, and pop up an
 830    "Edit color filter" dialog box to edit it. */
 831 static void
 832 create_new_color_filter(GtkButton *button, const char *filter)
 833 {
 834   color_filter_t   *colorf;
 835   GtkStyle         *style;
 836   color_t          bg_color, fg_color;
 837   GtkWidget        *color_filters;
 838   GtkTreeSelection *sel;
 839
 840   color_filters = (GtkWidget *)g_object_get_data(G_OBJECT(button), COLOR_FILTERS_CL);
 841
 842   /* unselect all filters */
 843   sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
 844   gtk_tree_selection_unselect_all (sel);
 845
 846   /* Use the default background and foreground colors as the colors. */
 847   style = gtk_widget_get_style(new_packet_list_get_widget());
 848   gdkcolor_to_color_t(&bg_color, &style->base[GTK_STATE_NORMAL]);
 849   gdkcolor_to_color_t(&fg_color, &style->text[GTK_STATE_NORMAL]);
 850
 851   colorf = color_filter_new("name", filter, &bg_color, &fg_color, FALSE);
 852   add_filter_to_list(colorf, color_filters, TRUE);
 853   select_row(color_filters, 0);
 854
 855   /* open the edit dialog */
 856   edit_color_filter_dialog(color_filters, TRUE /* is a new filter */);
 857
 858   gtk_widget_grab_focus(color_filters);
 859 }
 860
 861 /* User pressed the "New" button: Create a new filter in the list,
 862    and pop up an "Edit color filter" dialog box to edit it. */
 863 static void
 864 color_new_cb(GtkButton *button, gpointer user_data _U_)
 865 {
 866   create_new_color_filter(button, "filter");
 867 }
 868
 869 /* User pressed the "Edit" button: Pop up an "Edit color filter" dialog box
 870  * to edit an existing filter. */
 871 static void
 872 color_edit_cb(GtkButton *button, gpointer user_data _U_)
 873 {
 874   GtkWidget *color_filters;
 875
 876   color_filters = (GtkWidget *)g_object_get_data(G_OBJECT(button), COLOR_FILTERS_CL);
 877   g_assert(color_dlg_row_selected != -1);
 878   edit_color_filter_dialog(color_filters, FALSE /* is not a new filter */);
 879 }
 880
 881 /* User double-clicked on the coloring rule */
 882 static gboolean
 883 color_filters_button_cb(GtkWidget *list, GdkEventButton *event,
 884                           gpointer data _U_)
 885 {
 886   if (event->type == GDK_2BUTTON_PRESS) {
 887     edit_color_filter_dialog(list, FALSE);
 888   }
 889
 890   return FALSE;
 891 }
 892
 893 /* action_disable==TRUE  ==> User pressed the "Disable" button:
 894  *                           Disable the selected filters in the list.
 895  * action_disable==FALSE ==> User pressed the "Enable" button:
 896  *                           Enable the selected filters in the list.
 897  */
 898 static void
 899 color_disable_cb(GtkWidget *widget, gboolean action_disable)
 900 {
 901   gint filter_number;
 902   GtkWidget *button;
 903   GtkWidget * color_filters;
 904   color_filter_t *colorf;
 905   GtkTreeIter       iter;
 906   GtkTreeModel     *model;
 907   GtkTreeSelection *sel;
 908
 909   color_filters = (GtkWidget *)g_object_get_data(G_OBJECT(widget), COLOR_FILTERS_CL);
 910
 911   for (filter_number = 0; filter_number < color_dlg_num_of_filters; filter_number++)
 912   {
 913     model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
 914     gtk_tree_model_iter_nth_child(model, &iter, NULL, filter_number);
 915     gtk_tree_model_get(model, &iter, 5, &colorf, -1);
 916     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
 917     if (gtk_tree_selection_iter_is_selected(sel, &iter)) {
 918       colorf->disabled = action_disable;
 919       gtk_list_store_set(GTK_LIST_STORE(model), &iter,
 920                   4, action_disable, -1);
 921     }
 922   }
 923   button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_ENABLE_LB);
 924   gtk_widget_set_sensitive(button, action_disable);
 925   button = (GtkWidget *)g_object_get_data(G_OBJECT(color_filters), COLOR_DISABLE_LB);
 926   gtk_widget_set_sensitive(button, !action_disable);
 927 }
 928
 929 /* Delete a single color filter from the list and elsewhere. */
 930 void
 931 color_delete_single(gint row, GtkWidget *color_filters)
 932 {
 933   color_filter_t *colorf;
 934
 935   GtkTreeModel     *model;
 936   GtkTreeIter       iter;
 937
 938
 939   model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
 940   gtk_tree_model_iter_nth_child(model, &iter, NULL, row);
 941   gtk_tree_model_get(model, &iter, 5, &colorf, -1);
 942
 943   /* Remove this color filter from the CList displaying the
 944      color filters. */
 945   gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
 946   color_dlg_num_of_filters--;
 947
 948   /* Destroy any "Edit color filter" dialog boxes editing it. */
 949   if (colorf->edit_dialog != NULL)
 950     window_destroy(colorf->edit_dialog);
 951
 952   /* Delete the color filter from the list of color filters. */
 953   color_filter_edit_list = g_slist_remove(color_filter_edit_list, colorf);
 954   color_filter_delete(colorf);
 955
 956   /* If we grab the focus after updating the selection, the first
 957    * row is always selected, so we do it before */
 958   gtk_widget_grab_focus(color_filters);
 959 }
 960
 961 /* User pressed the "Delete" button: Delete the selected filters from the list.*/
 962 static void
 963 color_delete_cb(GtkWidget *widget, gpointer user_data _U_)
 964 {
 965   GtkWidget  *color_filters;
 966   gint row, num_filters;
 967   GtkTreeModel     *model;
 968   GtkTreeIter       iter;
 969   GtkTreeSelection *sel;
 970
 971   color_filters = (GtkWidget *)g_object_get_data(G_OBJECT(widget), COLOR_FILTERS_CL);
 972
 973   /* get the number of filters in the list */
 974   model = gtk_tree_view_get_model(GTK_TREE_VIEW(color_filters));
 975   num_filters = gtk_tree_model_iter_n_children(model, NULL);
 976   sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
 977
 978   /* iterate through the list and delete the selected ones */
 979   for (row = num_filters - 1; row >= 0; row--)
 980   {
 981     gtk_tree_model_iter_nth_child(model, &iter, NULL, row);
 982     if (gtk_tree_selection_iter_is_selected(sel, &iter))
 983       color_delete_single (row, color_filters);
 984   }
 985 }
 986
 987 /* User pressed "Import": Pop up an "Import color filter" dialog box. */
 988 static void
 989 color_import_cb(GtkButton *button, gpointer data _U_)
 990 {
 991   GtkWidget        *color_filters;
 992   GtkTreeSelection *sel;
 993
 994   color_filters = (GtkWidget *)g_object_get_data(G_OBJECT(button), COLOR_FILTERS_CL);
 995
 996   sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(color_filters));
 997   gtk_tree_selection_unselect_all (sel);
 998
 999   file_color_import_cmd_cb(color_filters, &color_filter_edit_list);
1000 }
1001
1002 /* User pressed "Export": Pop up an "Export color filter" dialog box. */
1003 static void
1004 color_export_cb(GtkButton *button, gpointer data _U_)
1005 {
1006   GtkWidget        *color_filters;
1007
1008   color_filters = (GtkWidget *)g_object_get_data(G_OBJECT(button), COLOR_FILTERS_CL);
1009
1010   file_color_export_cmd_cb(color_filters, color_filter_edit_list);
1011 }
1012
1013 /* User confirmed the clear operation: Remove all user defined color filters and
1014    revert to the global file. */
1015 static void
1016 color_clear_cmd(GtkWidget *widget)
1017 {
1018   GtkWidget * color_filters;
1019
1020   color_filters = (GtkWidget *)g_object_get_data(G_OBJECT(widget), COLOR_FILTERS_CL);
1021
1022   while (color_dlg_num_of_filters > 0)
1023   {
1024     color_delete_single (color_dlg_num_of_filters-1, color_filters);
1025   }
1026
1027   /* try to read the global filters */
1028   color_filters_read_globals(color_filters);
1029 }
1030
1031 /* Clear button: user responded to question */
1032 static void color_clear_answered_cb(gpointer dialog _U_, gint btn, gpointer data)
1033 {
1034   switch(btn) {
1035   case(ESD_BTN_CLEAR):
1036     color_clear_cmd(data);
1037     break;
1038   case(ESD_BTN_CANCEL):
1039     break;
1040   default:
1041     g_assert_not_reached();
1042   }
1043 }
1044
1045 /* User pressed "clear" button: ask user before really doing it */
1046 void
1047 color_clear_cb(GtkWidget *widget, gpointer data _U_) {
1048   gpointer  dialog;
1049
1050   /* ask user, if he/she is really sure */
1051   dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTN_CLEAR | ESD_BTN_CANCEL,
1052                          "%sRemove all your personal color settings?%s\n\n"
1053                          "This will revert the color settings to global defaults.\n\n"
1054                          "Are you really sure?",
1055                          simple_dialog_primary_start(), simple_dialog_primary_end());
1056
1057   simple_dialog_set_cb(dialog, color_clear_answered_cb, widget);
1058 }
1059
1060
1061
1062 /* User pressed "Ok" button: Exit dialog and apply new list of
1063    color filters to the capture. */
1064 static void
1065 color_ok_cb(GtkButton *button _U_, gpointer user_data _U_)
1066 {
1067   /* Apply the new coloring rules... */
1068   color_apply_cb(button,user_data);
1069
1070   /* ... and destroy the dialog box. */
1071   window_destroy(colorize_win);
1072 }
1073
1074 /* User pressed "Apply" button: apply the new list of color filters
1075    to the capture. */
1076 static void
1077 color_apply_cb(GtkButton *button _U_, gpointer user_data _U_)
1078 {
1079   /* if we don't have a Save button, just save the settings now */
1080   if (!prefs.gui_use_pref_save) {
1081       if (!color_filters_write(color_filter_edit_list))
1082             simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
1083                 "Could not open filter file: %s", g_strerror(errno));
1084   }
1085
1086   /* Apply the coloring rules, both the temporary ones in
1087    * color_filter_tmp_list as the permanent ones in color_filter_edit_list
1088    * */
1089   color_filters_apply(color_filter_tmp_list, color_filter_edit_list);
1090
1091   /* colorize list */
1092   new_packet_list_colorize_packets();
1093 }
1094
1095 /* User pressed the "Save" button: save the color filters to the
1096    color filter file. */
1097 static void
1098 color_save_cb(GtkButton *button _U_, gpointer user_data _U_)
1099 {
1100
1101   if (!color_filters_write(color_filter_edit_list))
1102         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
1103             "Could not open filter file: %s", g_strerror(errno));
1104 }
1105
1106 /* User pressed "Cancel" button (or "ESC" or the 'X'):
1107    Exit dialog without colorizing packets with the new list. */
1108 static void
1109 color_cancel_cb(GtkWidget *widget _U_, gpointer user_data _U_)
1110 {
1111   /* Destroy the dialog box. */
1112   window_destroy(colorize_win);
1113 }
1114