colors.c

   1 /* colors.c
   2  * Definitions for color structures and routines
   3  *
   4  * $Id: colors.c,v 1.3 1999/08/24 23:00:56 gram Exp $
   5  *
   6  * Ethereal - Network traffic analyzer
   7  * By Gerald Combs <gerald@zing.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <gtk/gtk.h>
  31
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35
  36 #include "ethereal.h"
  37 #include "packet.h"
  38 #include "colors.h"
  39 #include "file.h"
  40 #include "dfilter.h"
  41 #include "util.h"
  42
  43 extern capture_file cf;
  44
  45 static gboolean read_filters(capture_file *cf);
  46
  47 GdkColor        proto_colors[MAXCOLORS];
  48 GdkColormap*    sys_cmap;
  49
  50 static gchar *titles[2] = { "Name", "Filter String" };
  51 GdkColor        color_light_gray = { 0, 45000, 45000, 45000 };
  52 GdkColor        WHITE = { 0,65535, 65535, 65535};
  53 GdkColor        BLACK = { 0, 0, 0, 0};
  54
  55 /* This structure is used to allow you to compile in default colors if
  56  * you wish.  They can be later changed by a user.
  57  */
  58 #ifdef READ_DEFAULT_COLOR_LIST
  59 struct _default_colors {
  60         gchar* proto;
  61         gchar* color; /* background only */
  62 } default_colors[]  = {
  63         {"arp", "green2"},
  64         {"ip",  "light red"},
  65         {"tcp",  "light blue"}
  66 };
  67 #endif
  68
  69 void
  70 colors_init(capture_file *cf)
  71 {
  72
  73 #ifdef READ_DEFAULT_COLOR_LIST
  74   gint i;
  75   GdkColor color;
  76 #endif
  77   cf->colors = (colfilter *)g_malloc(sizeof(colfilter));
  78   cf->colors->num_of_filters = 0;
  79   cf->colors->color_filters = gtk_clist_new_with_titles(2, titles);
  80
  81   gtk_widget_ref(cf->colors->color_filters); /* so it doesn't go away */
  82   /* color_filters will ALWAYS be a GtkCList */
  83   sys_cmap = gdk_colormap_get_system();
  84
  85   /* Allocate "constant" colors. */
  86   if( !gdk_colormap_alloc_color(sys_cmap, &WHITE, TRUE, TRUE)){
  87         /* oops */
  88         simple_dialog(ESD_TYPE_WARN, NULL, "Could not allocate color white.");
  89         fprintf(stderr,"Color allocation failed\n");
  90         fflush(stderr);
  91   }
  92
  93   if( !gdk_colormap_alloc_color(sys_cmap, &BLACK, TRUE, TRUE)){
  94         /* oops */
  95         simple_dialog(ESD_TYPE_WARN, NULL, "Could not allocate color black.");
  96         fprintf(stderr,"Color allocation failed\n");
  97         fflush(stderr);
  98   }
  99
 100 #ifdef READ_DEFAULT_COLOR_LIST
 101   /* Now process defaults */
 102   for (i = 0 ; i < sizeof default_colors/sizeof (struct _default_colors); i++){
 103         gdk_color_parse(default_colors[i].color, &color);
 104
 105         if( !gdk_colormap_alloc_color(sys_cmap, &color, TRUE, TRUE)){
 106                 /* oops */
 107                 simple_dialog(ESD_TYPE_WARN, NULL, "Could not allocate color %s.",
 108                     default_colors[i].color);
 109                 fprintf(stderr,"Color allocation failed\n");
 110                 fflush(stderr);
 111         }
 112
 113         new_color_filter(cf->colors, default_colors[i].proto, default_colors[i].proto);
 114         color_filter(cf,i)->bg_color = color;
 115
 116         color_filter(cf,i)->c_colorfilter = dfilter_new();
 117         if(dfilter_compile((color_filter(cf,i)->c_colorfilter),
 118           default_colors[i].proto) != 0}{
 119                 simple_dialog(ESD_TYPE_WARN, NULL, "Cannot compile default filter %s.\n%s",
 120                   default_colors[i].proto, dfilter_error_msg);
 121                 /* should reject this filter */
 122         }
 123         cf->colors->num_of_filters++;
 124   }
 125 #endif
 126   if(!read_filters(cf))
 127     /* again, no window because it is not up, yet */
 128         fprintf(stderr,"Cound not open filter file\n");
 129
 130   fprintf(stderr,"Colors initialized\n");
 131   fflush(stderr);
 132 }
 133
 134 void
 135 set_color_filter_name(capture_file *cf, gint n, gchar *str)
 136 {
 137
 138         /* gtk_clist_set_text frees old text (if any) and allocates new space */
 139         gtk_clist_set_text(GTK_CLIST(cf->colors->color_filters),n,0,str);
 140 }
 141
 142
 143 gchar *
 144 get_color_filter_name(capture_file *cf, gint n)
 145 {
 146         gchar *filter_name;
 147         gtk_clist_get_text(GTK_CLIST(cf->colors->color_filters),n,0,
 148                 (gchar **)&filter_name);
 149         return filter_name;
 150 }
 151
 152 void
 153 set_color_filter_string(capture_file *cf, gint n, gchar *str)
 154 {
 155
 156         gtk_clist_set_text(GTK_CLIST(cf->colors->color_filters),n,1,str);
 157 }
 158
 159
 160 gchar *
 161 get_color_filter_string(capture_file *cf, gint n)
 162 {
 163         gchar *filter_string;
 164         gtk_clist_get_text(GTK_CLIST(cf->colors->color_filters),n,1,
 165                 (gchar **)&filter_string);
 166         return filter_string;
 167 }
 168
 169 color_filter_t *
 170 color_filter(capture_file *cf, gint n)
 171 {
 172         return gtk_clist_get_row_data(GTK_CLIST(cf->colors->color_filters),n);
 173 }
 174
 175 void
 176 new_color_filter(colfilter *filters, gchar *name, gchar *filter_string)
 177 {
 178         color_filter_t *colorf;
 179         gchar *data[2];
 180
 181         gint row;
 182
 183         data[0] = g_strdup(name);
 184         data[1] = g_strdup(filter_string);
 185         row = gtk_clist_append(GTK_CLIST(filters->color_filters), data);
 186
 187         colorf = (color_filter_t *)g_malloc(sizeof (color_filter_t));
 188         colorf->bg_color = WHITE;
 189         colorf->fg_color = BLACK;
 190         colorf->c_colorfilter = NULL;
 191         gtk_clist_set_row_data(GTK_CLIST(filters->color_filters), row, colorf);
 192 }
 193
 194 static gboolean
 195 read_filters(capture_file *cf)
 196 {
 197         /* TODO: Lots more syntax checking on the file */
 198         /* I hate these fixed length names! TODO: make more dynamic */
 199         gchar name[256],filter[256], buf[1024];
 200         guint16 fg_r, fg_g, fg_b, bg_r, bg_g, bg_b;
 201         GdkColor fg_color, bg_color;
 202
 203         int i;
 204         FILE *f;
 205         gchar *path;
 206         gchar *fname = PF_DIR "/colorfilters";
 207         /* decide what file to open (from dfilter code) */
 208
 209         /* should only be called by colors_init.
 210          * cf->colors->color_filters must exist
 211          */
 212         if(cf == NULL || cf->colors == NULL || cf->colors->color_filters == NULL)
 213                 return FALSE;
 214         /* we have a clist */
 215
 216         path = (gchar *) g_malloc(strlen(getenv("HOME")) + strlen(fname) +  4);
 217         sprintf(path, "%s/%s", getenv("HOME"), fname);
 218
 219         if ((f = fopen(path, "r")) == NULL) {
 220           g_free(path);
 221           return FALSE;
 222         }
 223
 224         i = 0;
 225
 226         do{
 227           if(!fgets(buf,sizeof buf, f))
 228                 break;
 229
 230           if(strspn( buf," \t") == (strchr(buf,'*') - buf)){
 231                 /* leading # comment */
 232                 continue;
 233           }
 234
 235           /* we get the @ delimiter.  It is not in any strings */
 236           if(sscanf(buf," @%[^@]@%[^@]@[%hu,%hu,%hu][%hu,%hu,%hu]",
 237                 name, filter, &bg_r, &bg_g, &bg_b, &fg_r, &fg_g, &fg_b) == 8){
 238                 /* we got a filter */
 239
 240             new_color_filter(cf->colors, name, filter);
 241             color_filter(cf,i)->c_colorfilter = dfilter_new();
 242             if(dfilter_compile((color_filter(cf,i)->c_colorfilter),filter) != 0){
 243                 simple_dialog(ESD_TYPE_WARN, NULL,
 244                  "Could not compile filter %s from saved filters because\n%s",
 245                  name, dfilter_error_msg);
 246             }
 247             cf->colors->num_of_filters++;
 248             fg_color.red = fg_r;
 249             fg_color.green = fg_g;
 250             fg_color.blue = fg_b;
 251             bg_color.red = bg_r;
 252             bg_color.green = bg_g;
 253             bg_color.blue = bg_b;
 254             if( !gdk_colormap_alloc_color(sys_cmap, &fg_color, TRUE, TRUE)){
 255                         /* oops */
 256                         simple_dialog(ESD_TYPE_WARN, NULL, "Could not allocate fg color specified"
 257                             "in input file for %s.", name);
 258
 259                         fprintf(stderr,"Color allocation failed\n");
 260                         fflush(stderr);
 261                         i++;
 262                         continue;
 263             }
 264                 if( !gdk_colormap_alloc_color(sys_cmap, &bg_color, TRUE, TRUE)){
 265                         /* oops */
 266                         simple_dialog(ESD_TYPE_WARN, NULL, "Could not allocate bg color specified"
 267                             "in input file for %s.", name);
 268                         fprintf(stderr,"Color allocation failed\n");
 269                         fflush(stderr);
 270                         i++;
 271                         continue;
 272             }
 273
 274         color_filter(cf,i)->bg_color = bg_color;
 275         color_filter(cf,i)->fg_color = fg_color;
 276         gtk_clist_set_foreground(GTK_CLIST(cf->colors->color_filters),
 277                         i,&fg_color);
 278         gtk_clist_set_background(GTK_CLIST(cf->colors->color_filters),
 279                         i,&bg_color);
 280
 281             i++;
 282           }    /* if sscanf */
 283         }   while( !feof(f));
 284         return TRUE;
 285 }
 286
 287 static gboolean
 288 write_filters(capture_file *cf)
 289 {
 290         int i;
 291         FILE *f;
 292         gchar *path;
 293         gchar *name = PF_DIR "/colorfilters";
 294         /* decide what file to open (from dfilter code) */
 295         path = (gchar *) g_malloc(strlen(getenv("HOME")) + strlen(name) +  4);
 296         sprintf(path, "%s/%s", getenv("HOME"), name);
 297
 298         if ((f = fopen(path, "w+")) == NULL) {
 299           simple_dialog(ESD_TYPE_WARN, NULL, "Could not open\n%s\nfor writing.",
 300                 path);
 301           g_free(path);
 302           return FALSE;
 303         }
 304         fprintf(f,"# DO NOT EDIT THIS FILE!  It was created by Ethereal\n");
 305         for(i = 0; i < cf->colors->num_of_filters; i++){
 306           fprintf(f,"@%s@%s@[%d,%d,%d][%d,%d,%d]\n",
 307                 get_color_filter_name(cf,i),
 308                 get_color_filter_string(cf,i),
 309                 color_filter(cf,i)->bg_color.red,
 310                 color_filter(cf,i)->bg_color.green,
 311                 color_filter(cf,i)->bg_color.blue,
 312                 color_filter(cf,i)->fg_color.red,
 313                 color_filter(cf,i)->fg_color.green,
 314                 color_filter(cf,i)->fg_color.blue);
 315         }
 316         fclose(f);
 317         g_free(path);
 318         return TRUE;
 319 }
 320
 321
 322 /* ===================== USER INTERFACE ====================== */
 323 void
 324 color_display_cb(GtkWidget *w, gpointer d)
 325 {
 326   /* cf already exists as a global */
 327   /* create the color dialog */
 328   create_color_win(&cf);
 329
 330 }
 331
 332 void
 333 color_cancel_cb                        (GtkWidget       *widget,
 334                                         gpointer         user_data)
 335 {
 336   GtkWidget *win = (GtkWidget *)user_data;
 337   /* delete the window */
 338   gtk_container_remove(GTK_CONTAINER(GTK_WIDGET(cf.colors->color_filters)->parent),
 339         cf.colors->color_filters);
 340   gtk_widget_destroy(win);
 341 }
 342
 343 void
 344 color_delete_cb(GtkWidget *widget, gpointer user_data)
 345 {
 346   if(cf.colors->row_selected != -1){
 347         gtk_clist_remove(GTK_CLIST(cf.colors->color_filters),
 348            cf.colors->row_selected);
 349         cf.colors->num_of_filters--;
 350         if(!cf.colors->num_of_filters){
 351                 cf.colors->row_selected = -1;
 352         } else {
 353                 cf.colors->row_selected--;
 354                 if(cf.colors->row_selected < 0)
 355                         cf.colors->row_selected = 0;
 356                 gtk_clist_select_row(GTK_CLIST(cf.colors->color_filters),
 357                   cf.colors->row_selected,0);
 358         }
 359   }
 360 }
 361
 362 /* Move the selected filter up in the list */
 363 void
 364 color_filt_up_cb                       (GtkButton       *button,
 365                                         gpointer         user_data)
 366 {
 367   colfilter *filter;
 368   gint filter_number;
 369
 370   filter = (colfilter *)user_data;
 371
 372   /* verify filter exists */
 373   filter_number = filter->row_selected;
 374   /* if it is filter number 0, it cannot be moved */
 375   if(filter != NULL &&
 376      (filter_number = filter->row_selected)  != 0 &&
 377       filter->num_of_filters >= 2){
 378         gtk_clist_swap_rows(GTK_CLIST(filter->color_filters),filter_number, filter_number-1);
 379         filter->row_selected--;
 380       }
 381   else {
 382         return;
 383   }
 384
 385 }
 386
 387 /* Move the selected filter down in the list */
 388 void
 389 color_filter_down_cb                   (GtkButton       *button,
 390                                         gpointer         user_data)
 391 {
 392   colfilter *filter;
 393   gint filter_number;
 394
 395   filter = (colfilter *)user_data;
 396   /* verify filter exists */
 397   filter_number = filter->row_selected;
 398   if(filter != NULL &&
 399      (filter_number = filter->row_selected) != filter->num_of_filters-1 &&
 400       filter->num_of_filters >= 2){
 401         gtk_clist_swap_rows(GTK_CLIST(filter->color_filters),filter_number+1, filter_number);
 402         filter->row_selected++;
 403   }
 404   else
 405         return;
 406 }
 407
 408 /* Set selected row in cf */
 409 void
 410 rembember_selected_row                 (GtkCList        *clist,
 411                                         gint             row,
 412                                         gint             column,
 413                                         GdkEvent        *event,
 414                                         gpointer         user_data)
 415 {
 416   capture_file *cf;
 417   cf = (capture_file *) user_data;
 418
 419   cf->colors->row_selected = row;
 420 }
 421
 422 /* change name to color_new_cb */
 423 static GtkWidget *filt_name_entry;
 424 static GtkWidget *filt_text_entry;
 425
 426 /* Create a new filter in the list */
 427 void
 428 create_new_cb                          (GtkButton       *button,
 429                                         gpointer         user_data)
 430 {
 431   colfilter *filter;
 432
 433   filter = (colfilter *)user_data;
 434   new_color_filter(filter, "name", "filter"); /* Adds at end! */
 435
 436   /* select the last row */
 437   cf.colors->row_selected = cf.colors->num_of_filters;
 438   cf.colors->num_of_filters++;
 439   gtk_clist_select_row(GTK_CLIST(cf.colors->color_filters),cf.colors->row_selected,0);
 440   /* this is the global cf! */
 441   create_colorize_win(&cf, &filt_name_entry, &filt_text_entry);
 442 }
 443
 444 /* Change a filter */
 445 /* probably should change name to color_edit_cb */
 446 void
 447 color_change_cb                        (GtkButton       *button,
 448                                         gpointer         user_data)
 449 {
 450   colfilter *filter;
 451   filter = (colfilter *)user_data;
 452
 453   if(cf.colors->row_selected == -1){
 454           /* select the first row */
 455           cf.colors->row_selected = 0;
 456           gtk_clist_select_row(GTK_CLIST(cf.colors->color_filters),cf.colors->row_selected,0);
 457   }
 458   /* this is the global cf! */
 459   /*Default colors are in cf in the e entry itself.*/
 460   create_colorize_win(&cf, &filt_name_entry, &filt_text_entry);
 461 }
 462
 463
 464 /* save filters in file */
 465 void
 466 color_save_cb                          (GtkButton       *button,
 467                                         gpointer         user_data)
 468 {
 469   capture_file *cf;
 470   cf = (capture_file *)user_data;
 471   if(!write_filters(cf))
 472         simple_dialog(ESD_TYPE_WARN, NULL, "Could not open filter file!");
 473
 474 }
 475
 476 /* Exit dialog and process list */
 477 void
 478 color_ok_cb                            (GtkButton       *button,
 479                                         gpointer         user_data)
 480 {
 481   GtkWidget *dialog;
 482   dialog = (GtkWidget *)user_data;
 483
 484   /* colorize list */
 485
 486   filter_packets(&cf);
 487   gtk_container_remove(GTK_CONTAINER(GTK_WIDGET(cf.colors->color_filters)->parent),
 488         cf.colors->color_filters);
 489   gtk_widget_destroy(dialog);
 490
 491 }
 492
 493 /* Process all data by applying filters in list */
 494 void
 495 color_apply_cb                         (GtkButton       *button,
 496                                         gpointer         user_data)
 497 {
 498   capture_file *cf;
 499   cf = (capture_file *)user_data;
 500   filter_packets(cf);
 501 }
 502
 503 /* Exit dialog and do not process list */
 504 void
 505 colorize_cancel_cb                     (GtkObject       *object,
 506                                         gpointer         user_data)
 507 {
 508
 509   GtkWidget *dialog;
 510   dialog = (GtkWidget *)user_data;
 511
 512   gtk_widget_destroy(dialog);
 513 }
 514
 515 static gint bg_set_flag; /* 0 -> setting foreground, 1-> setting background */
 516 /* Change the foreground color */
 517 void
 518 colorize_fg_cb                         (GtkButton       *button,
 519                                         gpointer         user_data)
 520 {
 521   colfilter *filter;
 522   filter = (colfilter *)user_data; /* UNUSED */
 523   create_color_sel_win(&cf);
 524   bg_set_flag = 0;
 525
 526 }
 527
 528 /* Change the background color */
 529 void
 530 colorize_bg_cb                         (GtkButton       *button,
 531                                         gpointer         user_data)
 532 {
 533   colfilter *filter;
 534   filter = (colfilter *)user_data; /* UNUSED */
 535   create_color_sel_win(&cf);
 536   bg_set_flag = 1;
 537
 538 }
 539
 540 /* accept color (and potential content) change */
 541 void
 542 colorize_ok_cb                         (GtkButton       *button,
 543                                         gpointer         user_data)
 544 {
 545   GtkWidget *dialog;
 546   GtkStyle *style;
 547   GdkColor new_fg_color;
 548   GdkColor new_bg_color;
 549   gchar *filter_name;
 550   gchar *filter_text;
 551   dfilter *compiled_filter;
 552
 553   dialog = (GtkWidget *)user_data;
 554
 555   style = gtk_widget_get_style(filt_name_entry);
 556   new_bg_color = style->base[GTK_STATE_NORMAL];
 557   new_fg_color = style->fg[GTK_STATE_NORMAL];
 558
 559   filter_name = g_strdup(gtk_entry_get_text(GTK_ENTRY(filt_name_entry)));
 560   filter_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(filt_text_entry)));
 561
 562   if(strchr(filter_name,'@') || strchr(filter_text,'@')){
 563         simple_dialog(ESD_TYPE_WARN,NULL, "Filter names and strings must not"
 564           " use the '@' character. Filter unchanged.");
 565         g_free(filter_name);
 566         g_free(filter_text);
 567         return;
 568   }
 569
 570
 571   color_filter(&cf,cf.colors->row_selected)->fg_color = new_fg_color;
 572   color_filter(&cf,cf.colors->row_selected)->bg_color = new_bg_color;
 573   gtk_clist_set_foreground(GTK_CLIST(cf.colors->color_filters),
 574         cf.colors->row_selected, &new_fg_color);
 575   gtk_clist_set_background(GTK_CLIST(cf.colors->color_filters),
 576         cf.colors->row_selected, &new_bg_color);
 577
 578
 579
 580   compiled_filter = dfilter_new();
 581
 582   if( dfilter_compile( compiled_filter, filter_text) != 0 ){
 583         simple_dialog(ESD_TYPE_WARN, NULL, "Filter \"%s\" did not compile correctly.\n"
 584                 " Please try again. Filter unchanged.\n%s\n", filter_name,dfilter_error_msg);
 585         dfilter_destroy(compiled_filter);
 586   } else {
 587
 588         if( color_filter(&cf, cf.colors->row_selected)->c_colorfilter != NULL)
 589             dfilter_destroy(color_filter(&cf,cf.colors->row_selected)->c_colorfilter);
 590         color_filter(&cf,cf.colors->row_selected)->c_colorfilter = compiled_filter;
 591         set_color_filter_string(&cf,cf.colors->row_selected,filter_text);
 592         set_color_filter_name(&cf,cf.colors->row_selected,filter_name);
 593         gtk_widget_destroy(dialog);
 594   }
 595   g_free(filter_name);
 596   g_free(filter_text);
 597
 598
 599 }
 600
 601 /* Revert to existing colors */
 602 void
 603 color_cel_cancel_cb                    (GtkObject       *object,
 604                                         gpointer         user_data)
 605 {
 606   GtkWidget *color_dialog;
 607   color_dialog = (GtkWidget *)user_data;
 608   /* nothing to change here.  Just get rid of the dialog box. */
 609
 610   gtk_widget_destroy(color_dialog);
 611 }
 612
 613 /* Retrieve selected color */
 614 void
 615 color_sel_ok_cb                        (GtkButton       *button,
 616                                         gpointer         user_data)
 617 {
 618   GdkColor new_color; /* Color from color selection dialog */
 619   gdouble new_colors[3];
 620   GtkWidget *color_dialog;
 621   GtkStyle  *style;
 622
 623   color_dialog = (GtkWidget *)user_data;
 624
 625   gtk_color_selection_get_color(GTK_COLOR_SELECTION(
 626    GTK_COLOR_SELECTION_DIALOG(color_dialog)->colorsel), new_colors);
 627
 628   new_color.red   = (guint16)(new_colors[0]*65535.0);
 629   new_color.green = (guint16)(new_colors[1]*65535.0);
 630   new_color.blue  = (guint16)(new_colors[2]*65535.0);
 631
 632   if ( ! gdk_colormap_alloc_color(sys_cmap, &new_color, TRUE, TRUE) ){
 633         simple_dialog(ESD_TYPE_WARN, NULL, "Could not allocate color.  Try again.");
 634   } else {
 635         gtk_widget_destroy(color_dialog);
 636
 637         /* now apply the change to the fore/background */
 638
 639         style = gtk_style_copy(gtk_widget_get_style(filt_name_entry));
 640         if( bg_set_flag)
 641           style->base[GTK_STATE_NORMAL] = new_color;
 642         else
 643           style->fg[GTK_STATE_NORMAL] = new_color;
 644         gtk_widget_set_style(filt_name_entry, style);
 645         gtk_widget_set_style(filt_text_entry, style);
 646   }
 647 }
 648
 649
 650
 651
 652
 653 GtkWidget*
 654 create_color_win (capture_file *cf)
 655 {
 656   GtkWidget *color_win;
 657   GtkWidget *vbox1;
 658   GtkWidget *hbox1;
 659   GtkWidget *vbox2;
 660   GtkWidget *color_filt_up;
 661   GtkWidget *label4;
 662   GtkWidget *color_filter_down;
 663   GtkWidget *scrolledwindow1;
 664   GtkWidget *clist1;
 665   GtkWidget *hbox2;
 666   GtkWidget *color_new;
 667   GtkWidget *color_change_colors;
 668   GtkWidget *color_delete;
 669   GtkWidget *color_save;
 670   GtkWidget *hbox3;
 671   GtkWidget *color_ok;
 672   GtkWidget *color_apply;
 673   GtkWidget *color_cancel;
 674   GtkTooltips *tooltips;
 675
 676   cf->colors->row_selected = -1; /* no row selected */
 677   tooltips = gtk_tooltips_new ();
 678
 679   color_win = gtk_window_new (GTK_WINDOW_DIALOG);
 680   gtk_object_set_data (GTK_OBJECT (color_win), "color_win", color_win);
 681   gtk_window_set_title (GTK_WINDOW (color_win), ("Add color to protocols"));
 682
 683   vbox1 = gtk_vbox_new (FALSE, 0);
 684   gtk_widget_ref (vbox1);
 685   gtk_object_set_data_full (GTK_OBJECT (color_win), "vbox1", vbox1,
 686                             (GtkDestroyNotify) gtk_widget_unref);
 687   gtk_widget_show (vbox1);
 688   gtk_container_add (GTK_CONTAINER (color_win), vbox1);
 689
 690   hbox1 = gtk_hbox_new (FALSE, 0);
 691   gtk_widget_ref (hbox1);
 692   gtk_object_set_data_full (GTK_OBJECT (color_win), "hbox1", hbox1,
 693                             (GtkDestroyNotify) gtk_widget_unref);
 694   gtk_widget_show (hbox1);
 695   gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
 696
 697   vbox2 = gtk_vbox_new (TRUE, 0);
 698   gtk_widget_ref (vbox2);
 699   gtk_object_set_data_full (GTK_OBJECT (color_win), "vbox2", vbox2,
 700                             (GtkDestroyNotify) gtk_widget_unref);
 701   gtk_widget_show (vbox2);
 702   gtk_box_pack_start (GTK_BOX (hbox1), vbox2, FALSE, TRUE, 0);
 703   gtk_widget_set_usize (vbox2, 150, -2);
 704
 705   color_filt_up = gtk_button_new_with_label (("Up"));
 706   gtk_widget_ref (color_filt_up);
 707   gtk_object_set_data_full (GTK_OBJECT (color_win), "color_filt_up", color_filt_up,
 708                             (GtkDestroyNotify) gtk_widget_unref);
 709   gtk_widget_show (color_filt_up);
 710   gtk_box_pack_start (GTK_BOX (vbox2), color_filt_up, FALSE, FALSE, 0);
 711   gtk_tooltips_set_tip (tooltips, color_filt_up, ("Move filter higher in list"), NULL);
 712
 713   label4 = gtk_label_new (("Move filter\nup or down\n[List is processed \nin order]"));
 714   gtk_widget_ref (label4);
 715   gtk_object_set_data_full (GTK_OBJECT (color_win), "label4", label4,
 716                             (GtkDestroyNotify) gtk_widget_unref);
 717   gtk_widget_show (label4);
 718   gtk_box_pack_start (GTK_BOX (vbox2), label4, FALSE, FALSE, 0);
 719
 720   color_filter_down = gtk_button_new_with_label (("Down"));
 721   gtk_widget_ref (color_filter_down);
 722   gtk_object_set_data_full (GTK_OBJECT (color_win), "color_filter_down", color_filter_down,
 723                             (GtkDestroyNotify) gtk_widget_unref);
 724   gtk_widget_show (color_filter_down);
 725   gtk_box_pack_start (GTK_BOX (vbox2), color_filter_down, FALSE, FALSE, 0);
 726   gtk_tooltips_set_tip (tooltips, color_filter_down, ("Move filter lower in list"), NULL);
 727
 728   scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
 729   gtk_widget_ref (scrolledwindow1);
 730   gtk_object_set_data_full (GTK_OBJECT (color_win), "scrolledwindow1", scrolledwindow1,
 731                             (GtkDestroyNotify) gtk_widget_unref);
 732   gtk_widget_show (scrolledwindow1);
 733   gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow1, TRUE, TRUE, 0);
 734
 735
 736   /* Do we have a list of filters, yet? */
 737   if( cf->colors->color_filters == NULL) {
 738         /* no color filters as of now.
 739          * This should probably be an assert...
 740          */
 741         fprintf(stderr,"Null clist\n");
 742                 fflush(stderr);
 743   }
 744
 745   clist1 = cf->colors->color_filters;
 746   gtk_widget_ref (clist1);
 747
 748 #if 0
 749   /* I don't seem to need this, but just in case, I'll if0 it */
 750   gtk_object_set_data_full (GTK_OBJECT (color_win), "clist1", clist1,
 751                             (GtkDestroyNotify) gtk_widget_unref);
 752 #endif
 753
 754   gtk_widget_show (clist1);
 755   gtk_container_add (GTK_CONTAINER (scrolledwindow1), clist1);
 756   gtk_widget_set_usize (clist1, 300, -2);
 757   gtk_clist_set_column_width (GTK_CLIST (clist1), 0, 80);
 758   gtk_clist_set_column_width (GTK_CLIST (clist1), 1, 80);
 759   gtk_clist_column_titles_show (GTK_CLIST (clist1));
 760
 761   hbox2 = gtk_hbox_new (FALSE, 0);
 762   gtk_widget_ref (hbox2);
 763   gtk_object_set_data_full (GTK_OBJECT (color_win), "hbox2", hbox2,
 764                             (GtkDestroyNotify) gtk_widget_unref);
 765   gtk_widget_show (hbox2);
 766   gtk_box_pack_start (GTK_BOX (vbox1), hbox2, TRUE, FALSE, 5);
 767   gtk_widget_set_usize (hbox2, -2, 40);
 768
 769   color_new = gtk_button_new_with_label (("New"));
 770   gtk_widget_ref (color_new);
 771   gtk_object_set_data_full (GTK_OBJECT (color_win), "color_new", color_new,
 772                             (GtkDestroyNotify) gtk_widget_unref);
 773   gtk_widget_show (color_new);
 774   gtk_box_pack_start (GTK_BOX (hbox2), color_new, TRUE, FALSE, 5);
 775   gtk_widget_set_usize (color_new, 50, 30);
 776   gtk_tooltips_set_tip (tooltips, color_new, ("Create a new colorization filter after selected filter"), NULL);
 777
 778   color_change_colors = gtk_button_new_with_label (("Edit"));
 779   gtk_widget_ref (color_change_colors);
 780   gtk_object_set_data_full (GTK_OBJECT (color_win), "color_change_colors", color_change_colors,
 781                             (GtkDestroyNotify) gtk_widget_unref);
 782   gtk_widget_show (color_change_colors);
 783   gtk_widget_set_usize(color_change_colors, 50, 30);
 784   gtk_box_pack_start (GTK_BOX (hbox2), color_change_colors, TRUE, FALSE, 5);
 785   gtk_tooltips_set_tip (tooltips, color_change_colors, ("Change color of selected filter"), NULL);
 786
 787   color_delete = gtk_button_new_with_label (("Delete"));
 788   gtk_widget_ref (color_delete);
 789   gtk_object_set_data_full (GTK_OBJECT (color_win), "color_delete", color_delete,
 790                             (GtkDestroyNotify) gtk_widget_unref);
 791   gtk_widget_show (color_delete);
 792   gtk_box_pack_start (GTK_BOX (hbox2), color_delete, TRUE, FALSE, 5);
 793   gtk_widget_set_usize (color_delete, 50, 30);
 794   gtk_tooltips_set_tip (tooltips, color_delete, ("Delete selected colorization filter"), NULL);
 795
 796   color_save = gtk_button_new_with_label (("Save"));
 797   gtk_widget_ref (color_save);
 798   gtk_object_set_data_full (GTK_OBJECT (color_win), "color_save", color_save,
 799                             (GtkDestroyNotify) gtk_widget_unref);
 800   gtk_widget_show (color_save);
 801   gtk_box_pack_start (GTK_BOX (hbox2), color_save, TRUE, FALSE, 5);
 802   gtk_widget_set_usize (color_save, 50, 30);
 803   gtk_tooltips_set_tip (tooltips, color_save, ("Save all filters to disk"), NULL);
 804
 805   hbox3 = gtk_hbox_new (FALSE, 0);
 806   gtk_widget_ref (hbox3);
 807   gtk_object_set_data_full (GTK_OBJECT (color_win), "hbox3", hbox3,
 808                             (GtkDestroyNotify) gtk_widget_unref);
 809   gtk_widget_show (hbox3);
 810   gtk_box_pack_start (GTK_BOX (vbox1), hbox3, TRUE, FALSE, 5);
 811   gtk_widget_set_usize (hbox3, 177, 40);
 812
 813   color_ok = gtk_button_new_with_label (("OK"));
 814   gtk_widget_ref (color_ok);
 815   gtk_object_set_data_full (GTK_OBJECT (color_win), "color_ok", color_ok,
 816                             (GtkDestroyNotify) gtk_widget_unref);
 817   gtk_widget_show (color_ok);
 818   gtk_box_pack_start (GTK_BOX (hbox3), color_ok, TRUE, FALSE, 0);
 819   gtk_widget_set_usize (color_ok, 50, 30);
 820   gtk_tooltips_set_tip (tooltips, color_ok, ("Accept filter list; apply changes"), NULL);
 821
 822   color_apply = gtk_button_new_with_label (("Apply"));
 823   gtk_widget_ref (color_apply);
 824   gtk_object_set_data_full (GTK_OBJECT (color_win), "color_apply", color_apply,
 825                             (GtkDestroyNotify) gtk_widget_unref);
 826   gtk_widget_show (color_apply);
 827   gtk_box_pack_start (GTK_BOX (hbox3), color_apply, TRUE, FALSE, 0);
 828   gtk_widget_set_usize (color_apply, 50, 30);
 829   gtk_tooltips_set_tip (tooltips, color_apply, ("Apply filters in list"), NULL);
 830
 831   color_cancel = gtk_button_new_with_label (("Cancel"));
 832   gtk_widget_ref (color_cancel);
 833   gtk_object_set_data_full (GTK_OBJECT (color_win), "color_cancel", color_cancel,
 834                             (GtkDestroyNotify) gtk_widget_unref);
 835   gtk_widget_show (color_cancel);
 836   gtk_box_pack_start (GTK_BOX (hbox3), color_cancel, TRUE, FALSE, 0);
 837   gtk_widget_set_usize (color_cancel, 50, 30);
 838   gtk_tooltips_set_tip (tooltips, color_cancel, ("No more filter changes; don't apply"), NULL);
 839
 840   gtk_signal_connect (GTK_OBJECT (color_filt_up), "clicked",
 841                       GTK_SIGNAL_FUNC (color_filt_up_cb),
 842                       cf->colors);
 843   gtk_signal_connect (GTK_OBJECT (color_filter_down), "clicked",
 844                       GTK_SIGNAL_FUNC (color_filter_down_cb),
 845                       cf->colors);
 846   gtk_signal_connect (GTK_OBJECT (clist1), "select_row",
 847                       GTK_SIGNAL_FUNC (rembember_selected_row),
 848                       cf);
 849   gtk_signal_connect (GTK_OBJECT (color_new), "clicked",
 850                       GTK_SIGNAL_FUNC (create_new_cb),
 851                       cf->colors);
 852   gtk_signal_connect (GTK_OBJECT (color_change_colors), "clicked",
 853                       GTK_SIGNAL_FUNC (color_change_cb),
 854                       cf->colors);
 855   gtk_signal_connect (GTK_OBJECT (color_delete), "clicked",
 856                       GTK_SIGNAL_FUNC (color_delete_cb),
 857                       color_delete);
 858   gtk_signal_connect (GTK_OBJECT (color_save), "clicked",
 859                       GTK_SIGNAL_FUNC (color_save_cb),
 860                       cf);
 861   gtk_signal_connect (GTK_OBJECT (color_ok), "clicked",
 862                       GTK_SIGNAL_FUNC (color_ok_cb),
 863                       color_win);
 864   gtk_signal_connect (GTK_OBJECT (color_apply), "clicked",
 865                       GTK_SIGNAL_FUNC (color_apply_cb),
 866                       cf);
 867   gtk_signal_connect (GTK_OBJECT (color_cancel), "clicked",
 868                       GTK_SIGNAL_FUNC (color_cancel_cb),
 869                       color_win);
 870
 871   gtk_widget_grab_focus (clist1);
 872   gtk_object_set_data (GTK_OBJECT (color_win), "tooltips", tooltips);
 873   gtk_widget_show (color_win);
 874
 875   return color_win;
 876 }
 877
 878 GtkWidget*
 879 create_colorize_win (capture_file *cf,
 880         GtkWidget **colorize_filter_name,
 881         GtkWidget **colorize_filter_text)
 882
 883 {
 884   GtkWidget *colorize_win;
 885   GtkWidget *vbox3;
 886   GtkWidget *hbox6;
 887   GtkWidget *color_filter_name;
 888   GtkWidget *hbox7;
 889   GtkWidget *color_filter_text;
 890   GtkWidget *hbox5;
 891   GtkWidget *colorize_filter_fg;
 892   GtkWidget *colorize_protocol_bg;
 893   GtkWidget *hbox4;
 894   GtkWidget *colorize_proto_ok;
 895   GtkWidget *colorize_proto_cancel;
 896   GtkTooltips *tooltips;
 897   GtkStyle  *style;
 898
 899   tooltips = gtk_tooltips_new ();
 900
 901   colorize_win = gtk_window_new (GTK_WINDOW_DIALOG);
 902   gtk_object_set_data (GTK_OBJECT (colorize_win), "colorize_win", colorize_win);
 903   gtk_window_set_title (GTK_WINDOW (colorize_win), ("Edit color filter"));
 904
 905   vbox3 = gtk_vbox_new (FALSE, 0);
 906   gtk_widget_ref (vbox3);
 907   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "vbox3", vbox3,
 908                             (GtkDestroyNotify) gtk_widget_unref);
 909   gtk_widget_show (vbox3);
 910   gtk_container_add (GTK_CONTAINER (colorize_win), vbox3);
 911
 912   hbox6 = gtk_hbox_new (FALSE, 0);
 913   gtk_widget_ref (hbox6);
 914   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "hbox6", hbox6,
 915                             (GtkDestroyNotify) gtk_widget_unref);
 916   gtk_widget_show (hbox6);
 917   gtk_box_pack_start (GTK_BOX (vbox3), hbox6, TRUE, FALSE, 5);
 918
 919   color_filter_name = gtk_label_new (("Name: "));
 920   gtk_widget_ref (color_filter_name);
 921   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "color_filter_name", color_filter_name,
 922                             (GtkDestroyNotify) gtk_widget_unref);
 923   gtk_widget_show (color_filter_name);
 924   gtk_box_pack_start (GTK_BOX (hbox6), color_filter_name, FALSE, FALSE, 0);
 925
 926   *colorize_filter_name = gtk_entry_new ();
 927   gtk_widget_ref (*colorize_filter_name);
 928   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "*colorize_filter_name", *colorize_filter_name,
 929                             (GtkDestroyNotify) gtk_widget_unref);
 930   gtk_entry_set_text(GTK_ENTRY(*colorize_filter_name),
 931         get_color_filter_name(cf, cf->colors->row_selected));
 932
 933   style = gtk_style_copy(gtk_widget_get_style(*colorize_filter_name));
 934   style->base[GTK_STATE_NORMAL] = color_filter(cf,cf->colors->row_selected)->bg_color;
 935   style->fg[GTK_STATE_NORMAL]   = color_filter(cf,cf->colors->row_selected)->fg_color;
 936   gtk_widget_set_style(*colorize_filter_name, style);
 937
 938   gtk_widget_show (*colorize_filter_name);
 939   gtk_box_pack_start (GTK_BOX (hbox6), *colorize_filter_name, TRUE, TRUE, 0);
 940   gtk_tooltips_set_tip (tooltips, *colorize_filter_name, ("This is the editable name of the filter. (No @ characters allowed.)"), NULL);
 941
 942   hbox7 = gtk_hbox_new (FALSE, 0);
 943   gtk_widget_ref (hbox7);
 944   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "hbox7", hbox7,
 945                             (GtkDestroyNotify) gtk_widget_unref);
 946   gtk_widget_show (hbox7);
 947   gtk_box_pack_start (GTK_BOX (vbox3), hbox7, TRUE, FALSE, 5);
 948
 949   color_filter_text = gtk_label_new (("Filter text:"));
 950   gtk_widget_ref (color_filter_text);
 951   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "color_filter_text", color_filter_text,
 952                             (GtkDestroyNotify) gtk_widget_unref);
 953   gtk_widget_show (color_filter_text);
 954   gtk_box_pack_start (GTK_BOX (hbox7), color_filter_text, FALSE, FALSE, 0);
 955
 956   *colorize_filter_text = gtk_entry_new ();
 957   gtk_widget_ref (*colorize_filter_text);
 958   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "*colorize_filter_text", *colorize_filter_text,
 959                             (GtkDestroyNotify) gtk_widget_unref);
 960   gtk_entry_set_text(GTK_ENTRY(*colorize_filter_text),
 961         get_color_filter_string(cf, cf->colors->row_selected));
 962 #if 0
 963   style = gtk_style_copy(gtk_widget_get_style(*colorize_filter_text));
 964   style->base[GTK_STATE_NORMAL] = color_filter(cf,cf->colors->row_selected)->bg_color;
 965   style->fg[GTK_STATE_NORMAL]   = color_filter(cf,cf->colors->row_selected)->fg_color;
 966 #endif
 967   gtk_widget_set_style(*colorize_filter_text, style);
 968   gtk_widget_show (*colorize_filter_text);
 969   gtk_box_pack_start (GTK_BOX (hbox7), *colorize_filter_text, TRUE, TRUE, 0);
 970   gtk_tooltips_set_tip (tooltips, *colorize_filter_text, ("This is the editable text of the filter"), NULL);
 971
 972   hbox5 = gtk_hbox_new (FALSE, 0);
 973   gtk_widget_ref (hbox5);
 974   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "hbox5", hbox5,
 975                             (GtkDestroyNotify) gtk_widget_unref);
 976   gtk_widget_show (hbox5);
 977   gtk_box_pack_start (GTK_BOX (vbox3), hbox5, FALSE, FALSE, 5);
 978   gtk_widget_set_usize (hbox5, -2, 60);
 979
 980   colorize_filter_fg = gtk_button_new_with_label (("Choose \nforeground\ncolor"));
 981   gtk_widget_ref (colorize_filter_fg);
 982   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "colorize_filter_fg", colorize_filter_fg,
 983                             (GtkDestroyNotify) gtk_widget_unref);
 984   gtk_widget_show (colorize_filter_fg);
 985   gtk_box_pack_start (GTK_BOX (hbox5), colorize_filter_fg, TRUE, FALSE, 0);
 986   gtk_tooltips_set_tip (tooltips, colorize_filter_fg, ("Select color for data display"), NULL);
 987
 988   colorize_protocol_bg = gtk_button_new_with_label (("Choose\nbackground\ncolor"));
 989   gtk_widget_ref (colorize_protocol_bg);
 990   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "colorize_protocol_bg", colorize_protocol_bg,
 991                             (GtkDestroyNotify) gtk_widget_unref);
 992   gtk_widget_show (colorize_protocol_bg);
 993   gtk_box_pack_start (GTK_BOX (hbox5), colorize_protocol_bg, TRUE, FALSE, 0);
 994   gtk_tooltips_set_tip (tooltips, colorize_protocol_bg, ("Select color for data display"), NULL);
 995
 996   hbox4 = gtk_hbox_new (FALSE, 0);
 997   gtk_widget_ref (hbox4);
 998   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "hbox4", hbox4,
 999                             (GtkDestroyNotify) gtk_widget_unref);
1000   gtk_widget_show (hbox4);
1001   gtk_box_pack_start (GTK_BOX (vbox3), hbox4, TRUE, FALSE, 5);
1002   gtk_widget_set_usize (hbox4, -2, 40);
1003
1004   colorize_proto_ok = gtk_button_new_with_label (("OK"));
1005   gtk_widget_ref (colorize_proto_ok);
1006   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "colorize_proto_ok", colorize_proto_ok,
1007                             (GtkDestroyNotify) gtk_widget_unref);
1008   gtk_widget_set_usize (colorize_proto_ok, 50, 30);
1009   gtk_widget_show (colorize_proto_ok);
1010   gtk_box_pack_start (GTK_BOX (hbox4), colorize_proto_ok, TRUE, FALSE, 0);
1011   gtk_tooltips_set_tip (tooltips, colorize_proto_ok, ("Accept filter color change"), NULL);
1012
1013   colorize_proto_cancel = gtk_button_new_with_label (("Cancel"));
1014   gtk_widget_ref (colorize_proto_cancel);
1015   gtk_object_set_data_full (GTK_OBJECT (colorize_win), "colorize_proto_cancel", colorize_proto_cancel,
1016                             (GtkDestroyNotify) gtk_widget_unref);
1017   gtk_widget_set_usize (colorize_proto_cancel, 50, 30);
1018   gtk_widget_show (colorize_proto_cancel);
1019   gtk_box_pack_start (GTK_BOX (hbox4), colorize_proto_cancel, TRUE, FALSE, 0);
1020   gtk_tooltips_set_tip (tooltips, colorize_proto_cancel, ("Reject filter color change"), NULL);
1021 #if 0
1022   gtk_signal_connect (GTK_OBJECT (colorize_win), "destroy",
1023                       GTK_SIGNAL_FUNC (colorize_cancel_cb),
1024                       colorize_win);
1025 #endif
1026   gtk_signal_connect (GTK_OBJECT (colorize_filter_fg), "clicked",
1027                       GTK_SIGNAL_FUNC (colorize_fg_cb),
1028                       cf->colors);
1029   gtk_signal_connect (GTK_OBJECT (colorize_protocol_bg), "clicked",
1030                       GTK_SIGNAL_FUNC (colorize_bg_cb),
1031                       cf->colors);
1032   gtk_signal_connect (GTK_OBJECT (colorize_proto_ok), "clicked",
1033                       GTK_SIGNAL_FUNC (colorize_ok_cb),
1034                       colorize_win);
1035   gtk_signal_connect (GTK_OBJECT (colorize_proto_cancel), "clicked",
1036                       GTK_SIGNAL_FUNC (colorize_cancel_cb),
1037                       colorize_win);
1038
1039   gtk_object_set_data (GTK_OBJECT (colorize_win), "tooltips", tooltips);
1040   gtk_widget_show (colorize_win);
1041   return colorize_win;
1042 }
1043
1044 GtkWidget*
1045 create_color_sel_win (capture_file *cf)
1046 {
1047   GtkWidget *color_sel_win;
1048   GtkWidget *color_sel_ok;
1049   GtkWidget *color_cel_cancel;
1050   GtkWidget *color_sel_help;
1051
1052   color_sel_win = gtk_color_selection_dialog_new (("Choose color"));
1053   gtk_object_set_data (GTK_OBJECT (color_sel_win), "color_sel_win", color_sel_win);
1054   gtk_container_set_border_width (GTK_CONTAINER (color_sel_win), 10);
1055
1056   color_sel_ok = GTK_COLOR_SELECTION_DIALOG (color_sel_win)->ok_button;
1057   gtk_object_set_data (GTK_OBJECT (color_sel_win), "color_sel_ok", color_sel_ok);
1058   gtk_widget_show (color_sel_ok);
1059   GTK_WIDGET_SET_FLAGS (color_sel_ok, GTK_CAN_DEFAULT);
1060
1061   color_cel_cancel = GTK_COLOR_SELECTION_DIALOG (color_sel_win)->cancel_button;
1062   gtk_object_set_data (GTK_OBJECT (color_sel_win), "color_cel_cancel", color_cel_cancel);
1063   gtk_widget_show (color_cel_cancel);
1064   GTK_WIDGET_SET_FLAGS (color_cel_cancel, GTK_CAN_DEFAULT);
1065
1066
1067   color_sel_help = GTK_COLOR_SELECTION_DIALOG (color_sel_win)->help_button;
1068   gtk_object_set_data (GTK_OBJECT (color_sel_win), "color_sel_help", color_sel_help);
1069   gtk_widget_show (color_sel_help);
1070
1071
1072   GTK_WIDGET_SET_FLAGS (color_sel_help, GTK_CAN_DEFAULT);
1073 #if 0
1074   gtk_signal_connect (GTK_OBJECT (color_sel_win), "destroy",
1075                       GTK_SIGNAL_FUNC (color_cel_cancel_cb),
1076                       color_sel_win);
1077 #endif
1078
1079   gtk_signal_connect (GTK_OBJECT (color_sel_ok), "clicked",
1080                       GTK_SIGNAL_FUNC (color_sel_ok_cb),
1081                       color_sel_win);
1082   gtk_signal_connect (GTK_OBJECT (color_cel_cancel), "clicked",
1083                       GTK_SIGNAL_FUNC (color_cel_cancel_cb),
1084                       color_sel_win);
1085
1086   gtk_widget_show(color_sel_win);
1087   return color_sel_win;
1088 }
1089