colors.c

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