colors.c

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