gtk/range_utils.c

   1 /* range_utils.c
   2  * Packet range routines (save, print, ...) for GTK things
   3  *
   4  * $Id$
   5  *
   6  * Ulf Lamping <ulf.lamping@web.de>
   7  *
   8  * Ethereal - Network traffic analyzer
   9  * By Gerald Combs <gerald@ethereal.com>
  10  * Copyright 1998 Gerald Combs
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include <gtk/gtk.h>
  32
  33 #include "globals.h"
  34
  35 #include "packet-range.h"
  36 #include "gui_utils.h"
  37 #include "dlg_utils.h"
  38 #include "compat_macros.h"
  39 #include "simple_dialog.h"
  40 #include "range_utils.h"
  41
  42
  43 #define RANGE_VALUES_KEY                "range_values"
  44 #define RANGE_CAPTURED_BT_KEY           "range_captured_button"
  45 #define RANGE_DISPLAYED_BT_KEY          "range_displayed_button"
  46
  47 #define RANGE_SELECT_ALL_C_KEY          "range_select_all_c_lb"
  48 #define RANGE_SELECT_ALL_D_KEY          "range_select_all_d_lb"
  49 #define RANGE_SELECT_CURR_KEY           "range_select_curr_rb"
  50 #define RANGE_SELECT_CURR_C_KEY         "range_select_curr_c_lb"
  51 #define RANGE_SELECT_CURR_D_KEY         "range_select_curr_d_lb"
  52 #define RANGE_SELECT_MARKED_KEY         "range_select_marked_only_rb"
  53 #define RANGE_SELECT_MARKED_C_KEY       "range_select_marked_only_c_lb"
  54 #define RANGE_SELECT_MARKED_D_KEY       "range_select_marked_only_d_lb"
  55 #define RANGE_SELECT_MARKED_RANGE_KEY   "range_select_marked_range_rb"
  56 #define RANGE_SELECT_MARKED_RANGE_C_KEY "range_select_marked_range_c_lb"
  57 #define RANGE_SELECT_MARKED_RANGE_D_KEY "range_select_marked_range_d_lb"
  58 #define RANGE_SELECT_USER_KEY           "range_select_user_range_rb"
  59 #define RANGE_SELECT_USER_C_KEY         "range_select_user_range_c_lb"
  60 #define RANGE_SELECT_USER_D_KEY         "range_select_user_range_d_lb"
  61 #define RANGE_SELECT_USER_ENTRY_KEY     "range_select_user_range_entry"
  62
  63 gboolean
  64 range_check_validity(packet_range_t *range)
  65 {
  66   switch (packet_range_check(range)) {
  67
  68   case CVT_NO_ERROR:
  69     return TRUE;
  70
  71   case CVT_SYNTAX_ERROR:
  72     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
  73       "The specified range of packets isn't a valid range.");
  74     return FALSE;
  75
  76   case CVT_NUMBER_TOO_BIG:
  77     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
  78       "The specified range of packets has a packet number that's too large.");
  79     return FALSE;
  80
  81   default:
  82     g_assert_not_reached();
  83     return FALSE;
  84   }
  85 }
  86
  87 /* update all "dynamic" things */
  88 void
  89 range_update_dynamics(gpointer data) {
  90   gboolean      filtered_active;
  91   gchar         label_text[100];
  92   gint          selected_num;
  93   GtkWidget     *bt;
  94   packet_range_t *range;
  95
  96
  97   range = OBJECT_GET_DATA(data, RANGE_VALUES_KEY);
  98
  99
 100   bt = OBJECT_GET_DATA(data, RANGE_DISPLAYED_BT_KEY);
 101   filtered_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(bt));
 102
 103   gtk_widget_set_sensitive(bt, TRUE);
 104
 105   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_ALL_C_KEY), !filtered_active);
 106   g_snprintf(label_text, sizeof(label_text), "%u", cfile.count);
 107   gtk_label_set_text(GTK_LABEL(OBJECT_GET_DATA(data, RANGE_SELECT_ALL_C_KEY)), label_text);
 108   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_ALL_D_KEY), filtered_active);
 109   g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_cnt);
 110
 111   gtk_label_set_text(GTK_LABEL(OBJECT_GET_DATA(data, RANGE_SELECT_ALL_D_KEY)), label_text);
 112
 113   selected_num = (cfile.current_frame) ? cfile.current_frame->num : 0;
 114   /* XXX: how to update the radio button label but keep the mnemonic? */
 115 /*  g_snprintf(label_text, sizeof(label_text), "_Selected packet #%u only", selected_num);
 116   gtk_label_set_text(GTK_LABEL(GTK_BIN(select_curr_rb)->child), label_text);*/
 117   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_CURR_KEY), selected_num);
 118   g_snprintf(label_text, sizeof(label_text), "%u", selected_num ? 1 : 0);
 119   gtk_label_set_text(GTK_LABEL(OBJECT_GET_DATA(data, RANGE_SELECT_CURR_C_KEY)), label_text);
 120   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_CURR_C_KEY), selected_num && !filtered_active);
 121   g_snprintf(label_text, sizeof(label_text), "%u", selected_num ? 1 : 0);
 122   gtk_label_set_text(GTK_LABEL(OBJECT_GET_DATA(data, RANGE_SELECT_CURR_D_KEY)), label_text);
 123   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_CURR_D_KEY), selected_num && filtered_active);
 124
 125   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_KEY), cfile.marked_count > 0);
 126   g_snprintf(label_text, sizeof(label_text), "%u", cfile.marked_count);
 127   gtk_label_set_text(GTK_LABEL(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_C_KEY)), label_text);
 128   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_C_KEY), cfile.marked_count > 0 && !filtered_active);
 129   g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_marked_cnt);
 130   gtk_label_set_text(GTK_LABEL(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_D_KEY)), label_text);
 131   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_D_KEY), range->displayed_marked_cnt && filtered_active);
 132
 133   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_RANGE_KEY), range->mark_range_cnt);
 134   g_snprintf(label_text, sizeof(label_text), "%u", range->mark_range_cnt);
 135   gtk_label_set_text(GTK_LABEL(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_RANGE_C_KEY)), label_text);
 136   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_RANGE_C_KEY), range->mark_range_cnt && !filtered_active);
 137   g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_mark_range_cnt);
 138   gtk_label_set_text(GTK_LABEL(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_RANGE_D_KEY)), label_text);
 139   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_RANGE_D_KEY), range->displayed_mark_range_cnt && filtered_active);
 140
 141   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_USER_KEY), TRUE);
 142   g_snprintf(label_text, sizeof(label_text), "%u", range->user_range_cnt);
 143   gtk_label_set_text(GTK_LABEL(OBJECT_GET_DATA(data, RANGE_SELECT_USER_C_KEY)), label_text);
 144   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_USER_C_KEY), !filtered_active);
 145   g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_user_range_cnt);
 146   gtk_label_set_text(GTK_LABEL(OBJECT_GET_DATA(data, RANGE_SELECT_USER_D_KEY)), label_text);
 147   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_USER_D_KEY), filtered_active);
 148 }
 149
 150
 151 static void
 152 toggle_captured_cb(GtkWidget *widget, gpointer data)
 153 {
 154   GtkWidget *bt;
 155   packet_range_t *range;
 156
 157
 158   range = OBJECT_GET_DATA(data, RANGE_VALUES_KEY);
 159
 160   /* is the button now active? */
 161   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget))) {
 162     /* They changed the state of the "captured" button. */
 163     range->process_filtered = FALSE;
 164
 165     bt = OBJECT_GET_DATA(data, RANGE_CAPTURED_BT_KEY);
 166     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bt), TRUE);
 167     bt = OBJECT_GET_DATA(data, RANGE_DISPLAYED_BT_KEY);
 168     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bt), FALSE);
 169
 170     range_update_dynamics(data);
 171   }
 172 }
 173
 174 static void
 175 toggle_filtered_cb(GtkWidget *widget, gpointer data)
 176 {
 177   GtkWidget *bt;
 178   packet_range_t *range;
 179
 180
 181   range = OBJECT_GET_DATA(data, RANGE_VALUES_KEY);
 182
 183   /* is the button now active? */
 184   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget))) {
 185     range->process_filtered = TRUE;
 186     bt = OBJECT_GET_DATA(data, RANGE_CAPTURED_BT_KEY);
 187     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bt), FALSE);
 188     bt = OBJECT_GET_DATA(data, RANGE_DISPLAYED_BT_KEY);
 189     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bt), TRUE);
 190
 191     range_update_dynamics(data);
 192   }
 193 }
 194
 195 static void
 196 toggle_select_all(GtkWidget *widget, gpointer data)
 197 {
 198   packet_range_t *range;
 199
 200
 201   range = OBJECT_GET_DATA(data, RANGE_VALUES_KEY);
 202
 203   /* is the button now active? */
 204   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget))) {
 205     range->process = range_process_all;
 206     range_update_dynamics(data);
 207   }
 208 }
 209
 210 static void
 211 toggle_select_selected(GtkWidget *widget, gpointer data)
 212 {
 213   packet_range_t *range;
 214
 215
 216   range = OBJECT_GET_DATA(data, RANGE_VALUES_KEY);
 217
 218   /* is the button now active? */
 219   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget))) {
 220     range->process = range_process_selected;
 221     range_update_dynamics(data);
 222   }
 223 }
 224
 225 static void
 226 toggle_select_marked_only(GtkWidget *widget, gpointer data)
 227 {
 228   packet_range_t *range;
 229
 230
 231   range = OBJECT_GET_DATA(data, RANGE_VALUES_KEY);
 232
 233   /* is the button now active? */
 234   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget))) {
 235     range->process = range_process_marked;
 236     range_update_dynamics(data);
 237   }
 238 }
 239
 240 static void
 241 toggle_select_marked_range(GtkWidget *widget, gpointer data)
 242 {
 243   packet_range_t *range;
 244
 245
 246   range = OBJECT_GET_DATA(data, RANGE_VALUES_KEY);
 247
 248   /* is the button now active? */
 249   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget))) {
 250     range->process = range_process_marked_range;
 251     range_update_dynamics(data);
 252   }
 253 }
 254
 255 static void
 256 toggle_select_user_range(GtkWidget *widget, gpointer data)
 257 {
 258   packet_range_t *range;
 259
 260
 261   range = OBJECT_GET_DATA(data, RANGE_VALUES_KEY);
 262
 263   /* is the button now active? */
 264   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget))) {
 265     range->process = range_process_user_range;
 266     range_update_dynamics(data);
 267   }
 268
 269   /* Make the entry widget sensitive or insensitive */
 270   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_USER_ENTRY_KEY), range->process == range_process_user_range);
 271
 272   /* When selecting user specified range, then focus on the entry */
 273   if (range->process == range_process_user_range)
 274       gtk_widget_grab_focus(OBJECT_GET_DATA(data, RANGE_SELECT_USER_ENTRY_KEY));
 275
 276 }
 277
 278
 279 static void
 280 range_entry(GtkWidget *widget _U_, gpointer data)
 281 {
 282   const gchar   *entry_text;
 283   GtkWidget     *entry;
 284   packet_range_t *range;
 285
 286
 287   range = OBJECT_GET_DATA(data, RANGE_VALUES_KEY);
 288   entry = OBJECT_GET_DATA(data, RANGE_SELECT_USER_ENTRY_KEY);
 289
 290   gtk_toggle_button_set_active(OBJECT_GET_DATA(data, RANGE_SELECT_USER_KEY), TRUE);
 291   entry_text = gtk_entry_get_text (GTK_ENTRY (entry));
 292   packet_range_convert_str(range, entry_text);
 293   range_update_dynamics(data);
 294 }
 295
 296
 297 static void
 298 range_entry_in_event(GtkWidget *widget, GdkEventFocus *event _U_, gpointer user_data)
 299 {
 300     range_entry(widget, user_data);
 301 }
 302
 303
 304 /* set the "Process only marked packets" toggle button as appropriate */
 305 void
 306 range_set_marked_sensitive(gpointer data, gboolean marked_valid)
 307 {
 308   packet_range_t *range;
 309
 310
 311   range = OBJECT_GET_DATA(data, RANGE_VALUES_KEY);
 312
 313   /* We can request that only the marked packets be processed only if we
 314      if there *are* marked packets. */
 315   if (marked_valid) {
 316     gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_KEY), TRUE);
 317     gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_RANGE_KEY), TRUE);
 318   }
 319   else {
 320     /* Force the "Process only marked packets" toggle to "false", turn
 321        off the flag it controls. */
 322     range->process = range_process_all;
 323     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_KEY)), FALSE);
 324     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_RANGE_KEY)), FALSE);
 325     gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_KEY),  FALSE);
 326     gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_SELECT_MARKED_RANGE_KEY), FALSE);
 327   }
 328 }
 329
 330
 331 /* set the "displayed" button as appropriate */
 332 void
 333 range_set_displayed_sensitive(gpointer data, gboolean displayed_valid)
 334 {
 335
 336   gtk_widget_set_sensitive(OBJECT_GET_DATA(data, RANGE_DISPLAYED_BT_KEY), displayed_valid);
 337 }
 338
 339
 340 /* create a new range "widget" */
 341 GtkWidget *range_new(packet_range_t *range
 342 #if GTK_MAJOR_VERSION < 2
 343 , GtkAccelGroup *accel_group
 344 #endif
 345 ) {
 346   GtkWidget     *range_tb;
 347   GtkWidget     *captured_bt;
 348   GtkWidget     *displayed_bt;
 349
 350   GtkWidget     *select_all_rb;
 351   GtkWidget     *select_all_c_lb;
 352   GtkWidget     *select_all_d_lb;
 353   GtkWidget     *select_curr_rb;
 354   GtkWidget     *select_curr_c_lb;
 355   GtkWidget     *select_curr_d_lb;
 356   GtkWidget     *select_marked_only_rb;
 357   GtkWidget     *select_marked_only_c_lb;
 358   GtkWidget     *select_marked_only_d_lb;
 359   GtkWidget     *select_marked_range_rb;
 360   GtkWidget     *select_marked_range_c_lb;
 361   GtkWidget     *select_marked_range_d_lb;
 362   GtkWidget     *select_user_range_rb;
 363   GtkWidget     *select_user_range_c_lb;
 364   GtkWidget     *select_user_range_d_lb;
 365   GtkWidget     *select_user_range_entry;
 366
 367   GtkTooltips   *tooltips;
 368
 369
 370   /* Enable tooltips */
 371   tooltips = gtk_tooltips_new();
 372
 373   /* range table */
 374   range_tb = gtk_table_new(7, 3, FALSE);
 375   gtk_container_border_width(GTK_CONTAINER(range_tb), 5);
 376
 377   /* captured button */
 378   captured_bt = TOGGLE_BUTTON_NEW_WITH_MNEMONIC("_Captured", accel_group);
 379   gtk_table_attach_defaults(GTK_TABLE(range_tb), captured_bt, 1, 2, 0, 1);
 380   SIGNAL_CONNECT(captured_bt, "toggled", toggle_captured_cb, range_tb);
 381   gtk_tooltips_set_tip (tooltips,captured_bt,("Process all the below chosen packets"), NULL);
 382
 383   /* displayed button */
 384   displayed_bt = TOGGLE_BUTTON_NEW_WITH_MNEMONIC("_Displayed", accel_group);
 385   gtk_table_attach_defaults(GTK_TABLE(range_tb), displayed_bt, 2, 3, 0, 1);
 386   SIGNAL_CONNECT(displayed_bt, "toggled", toggle_filtered_cb, range_tb);
 387   gtk_tooltips_set_tip (tooltips,displayed_bt,("Process only the below chosen packets, which also passes the current display filter"), NULL);
 388
 389
 390   /* Process all packets */
 391   select_all_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC(NULL, "_All packets", accel_group);
 392   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_all_rb, 0, 1, 1, 2);
 393   gtk_tooltips_set_tip (tooltips, select_all_rb,
 394       ("Process all packets"), NULL);
 395   SIGNAL_CONNECT(select_all_rb, "toggled", toggle_select_all, range_tb);
 396
 397   select_all_c_lb = gtk_label_new("?");
 398   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_all_c_lb, 1, 2, 1, 2);
 399   select_all_d_lb = gtk_label_new("?");
 400   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_all_d_lb, 2, 3, 1, 2);
 401
 402
 403   /* Process currently selected */
 404   select_curr_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC(select_all_rb, "_Selected packet only", accel_group);
 405   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_curr_rb, 0, 1, 2, 3);
 406   gtk_tooltips_set_tip (tooltips, select_curr_rb, ("Process the currently selected packet only"), NULL);
 407   SIGNAL_CONNECT(select_curr_rb, "toggled", toggle_select_selected, range_tb);
 408
 409   select_curr_c_lb = gtk_label_new("?");
 410   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_curr_c_lb, 1, 2, 2, 3);
 411   select_curr_d_lb = gtk_label_new("?");
 412   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_curr_d_lb, 2, 3, 2, 3);
 413
 414
 415   /* Process marked packets */
 416   select_marked_only_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC(select_all_rb, "_Marked packets only", accel_group);
 417   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_marked_only_rb, 0, 1, 3, 4);
 418   gtk_tooltips_set_tip (tooltips, select_marked_only_rb, ("Process marked packets only"), NULL);
 419   SIGNAL_CONNECT(select_marked_only_rb, "toggled", toggle_select_marked_only, range_tb);
 420
 421   select_marked_only_c_lb = gtk_label_new("?");
 422   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_marked_only_c_lb, 1, 2, 3, 4);
 423   select_marked_only_d_lb = gtk_label_new("?");
 424   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_marked_only_d_lb, 2, 3, 3, 4);
 425
 426
 427   /* Process packet range between first and last packet */
 428   select_marked_range_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC(select_all_rb, "From first _to last marked packet", accel_group);
 429   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_marked_range_rb, 0, 1, 4, 5);
 430   gtk_tooltips_set_tip (tooltips,select_marked_range_rb,("Process all packets between the first and last marker"), NULL);
 431   SIGNAL_CONNECT(select_marked_range_rb, "toggled", toggle_select_marked_range, range_tb);
 432
 433   select_marked_range_c_lb = gtk_label_new("?");
 434   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_marked_range_c_lb, 1, 2, 4, 5);
 435   select_marked_range_d_lb = gtk_label_new("?");
 436   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_marked_range_d_lb, 2, 3, 4, 5);
 437
 438
 439   /* Process a user specified provided packet range : -10,30,40-70,80- */
 440   select_user_range_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC(select_all_rb, "Specify a packet _range:", accel_group);
 441   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_user_range_rb, 0, 1, 5, 6);
 442   gtk_tooltips_set_tip (tooltips,select_user_range_rb,("Process a specified packet range"), NULL);
 443   SIGNAL_CONNECT(select_user_range_rb, "toggled", toggle_select_user_range, range_tb);
 444
 445   select_user_range_c_lb = gtk_label_new("?");
 446   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_user_range_c_lb, 1, 2, 5, 6);
 447   select_user_range_d_lb = gtk_label_new("?");
 448   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_user_range_d_lb, 2, 3, 5, 6);
 449
 450
 451   /* The entry part */
 452   select_user_range_entry = gtk_entry_new();
 453   gtk_entry_set_max_length (GTK_ENTRY (select_user_range_entry), 254);
 454   gtk_table_attach_defaults(GTK_TABLE(range_tb), select_user_range_entry, 0, 1, 6, 7);
 455   gtk_tooltips_set_tip (tooltips,select_user_range_entry,
 456         ("Specify a range of packet numbers :     \nExample :  1-10,18,25-100,332-"), NULL);
 457   SIGNAL_CONNECT(select_user_range_entry,"changed", range_entry, range_tb);
 458   SIGNAL_CONNECT(select_user_range_entry,"activate", range_entry_in_event, range_tb);
 459
 460
 461   gtk_widget_show_all(range_tb);
 462
 463
 464   OBJECT_SET_DATA(range_tb, RANGE_VALUES_KEY,               range);
 465   OBJECT_SET_DATA(range_tb, RANGE_CAPTURED_BT_KEY,          captured_bt);
 466   OBJECT_SET_DATA(range_tb, RANGE_DISPLAYED_BT_KEY,         displayed_bt);
 467
 468   OBJECT_SET_DATA(range_tb, RANGE_SELECT_ALL_C_KEY,         select_all_c_lb);
 469   OBJECT_SET_DATA(range_tb, RANGE_SELECT_ALL_D_KEY,         select_all_d_lb);
 470
 471   OBJECT_SET_DATA(range_tb, RANGE_SELECT_CURR_KEY,          select_curr_rb);
 472   OBJECT_SET_DATA(range_tb, RANGE_SELECT_CURR_C_KEY,        select_curr_c_lb);
 473   OBJECT_SET_DATA(range_tb, RANGE_SELECT_CURR_D_KEY,        select_curr_d_lb);
 474   OBJECT_SET_DATA(range_tb, RANGE_SELECT_CURR_D_KEY,        select_curr_d_lb);
 475   OBJECT_SET_DATA(range_tb, RANGE_SELECT_MARKED_KEY,        select_marked_only_rb);
 476   OBJECT_SET_DATA(range_tb, RANGE_SELECT_MARKED_C_KEY,      select_marked_only_c_lb);
 477   OBJECT_SET_DATA(range_tb, RANGE_SELECT_MARKED_D_KEY,      select_marked_only_d_lb);
 478   OBJECT_SET_DATA(range_tb, RANGE_SELECT_MARKED_RANGE_KEY,  select_marked_range_rb);
 479   OBJECT_SET_DATA(range_tb, RANGE_SELECT_MARKED_RANGE_C_KEY,select_marked_range_c_lb);
 480   OBJECT_SET_DATA(range_tb, RANGE_SELECT_MARKED_RANGE_D_KEY,select_marked_range_d_lb);
 481   OBJECT_SET_DATA(range_tb, RANGE_SELECT_USER_KEY,          select_user_range_rb);
 482   OBJECT_SET_DATA(range_tb, RANGE_SELECT_USER_C_KEY,        select_user_range_c_lb);
 483   OBJECT_SET_DATA(range_tb, RANGE_SELECT_USER_D_KEY,        select_user_range_d_lb);
 484   OBJECT_SET_DATA(range_tb, RANGE_SELECT_USER_ENTRY_KEY,    select_user_range_entry);
 485
 486   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(captured_bt), !range->process_filtered);
 487   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(displayed_bt), range->process_filtered);
 488
 489   switch(range->process) {
 490   case(range_process_all):
 491     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(select_all_rb),  TRUE);
 492     break;
 493   case(range_process_selected):
 494     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(select_curr_rb),  TRUE);
 495     break;
 496   case(range_process_marked):
 497     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(select_marked_only_rb),  TRUE);
 498     break;
 499   case(range_process_marked_range):
 500     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(select_marked_range_rb),  TRUE);
 501     break;
 502   case(range_process_user_range):
 503     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(select_user_range_rb),  TRUE);
 504     break;
 505   default:
 506       g_assert_not_reached();
 507   }
 508
 509   return range_tb;
 510 }