ui/gtk/new_packet_list.c

   1 /* new_packet_list.c
   2  * Routines to implement a new GTK2 packet list using our custom model
   3  * Copyright 2008-2009, Stephen Fisher (see AUTHORS file)
   4  * Co-authors Anders Broman, Kovarththanan Rajaratnam and Stig Bjorlykke.
   5  *
   6  * $Id$
   7  *
   8  * Wireshark - Network traffic analyzer
   9  * By Gerald Combs <gerald@wireshark.org>
  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
  25  * USA.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #include <string.h>
  33
  34 #include <stdio.h>
  35 #include <gtk/gtk.h>
  36 #include <glib.h>
  37
  38 #include <epan/column_info.h>
  39 #include <epan/prefs.h>
  40 #include <epan/packet.h>
  41 #include <epan/epan_dissect.h>
  42 #include <epan/column.h>
  43 #include <epan/strutil.h>
  44 #include <epan/emem.h>
  45
  46 #include "ui/main_statusbar.h"
  47 #include "ui/progress_dlg.h"
  48 #include "ui/recent.h"
  49 #include "ui/recent_utils.h"
  50 #include "ui/simple_dialog.h"
  51 #include "ui/ui_util.h"
  52
  53 #include "gui_utils.h"
  54 #include "packet_list_store.h"
  55 #include "ui/gtk/new_packet_list.h"
  56 #include "globals.h"
  57 #include "ui/gtk/gtkglobals.h"
  58 #include "ui/gtk/font_utils.h"
  59 #include "ui/gtk/packet_history.h"
  60 #include "ui/gtk/keys.h"
  61 #include "ui/gtk/menus.h"
  62 #include "color.h"
  63 #include "color_filters.h"
  64 #include "ui/gtk/color_utils.h"
  65 #include "ui/gtk/capture_file_dlg.h"
  66 #include "ui/gtk/packet_win.h"
  67 #include "ui/gtk/main.h"
  68 #include "ui/gtk/prefs_column.h"
  69 #include "ui/gtk/prefs_dlg.h"
  70 #include "ui/gtk/dlg_utils.h"
  71 #include "ui/gtk/filter_dlg.h"
  72 #include "ui/gtk/filter_autocomplete.h"
  73
  74 #include "ui/gtk/old-gtk-compat.h"
  75
  76 #define COLUMN_WIDTH_MIN 40
  77
  78 #define COL_EDIT_COLUMN          "column"
  79 #define COL_EDIT_FORMAT_CMB      "format_cmb"
  80 #define COL_EDIT_TITLE_TE        "title_te"
  81 #define COL_EDIT_FIELD_LB        "field_lb"
  82 #define COL_EDIT_FIELD_TE        "field_te"
  83 #define COL_EDIT_OCCURRENCE_LB   "occurrence_lb"
  84 #define COL_EDIT_OCCURRENCE_TE   "occurrente_te"
  85
  86 static PacketList *packetlist;
  87 static gboolean last_at_end = FALSE;
  88 static gboolean enable_color;
  89 static gulong column_changed_handler_id;
  90
  91 static GtkWidget *create_view_and_model(void);
  92 static void scroll_to_and_select_iter(GtkTreeModel *model, GtkTreeSelection *selection, GtkTreeIter *iter);
  93 static void new_packet_list_select_cb(GtkTreeView *tree_view, gpointer data _U_);
  94 static void new_packet_list_double_click_cb(GtkTreeView *treeview,
  95                                             GtkTreePath *path _U_,
  96                                             GtkTreeViewColumn *col _U_,
  97                                             gpointer userdata _U_);
  98 static void show_cell_data_func(GtkTreeViewColumn *col,
  99                                 GtkCellRenderer *renderer,
 100                                 GtkTreeModel *model,
 101                                 GtkTreeIter *iter,
 102                                 gpointer data);
 103 static gint row_number_from_iter(GtkTreeIter *iter);
 104 static void scroll_to_current(void);
 105
 106 void new_packet_list_set_sel_browse(gboolean val, gboolean force_set);
 107
 108 GtkWidget *
 109 new_packet_list_create(void)
 110 {
 111         GtkWidget *view, *scrollwin;
 112
 113         scrollwin = scrolled_window_new(NULL, NULL);
 114
 115         view = create_view_and_model();
 116
 117         new_packet_list_set_sel_browse(prefs.gui_plist_sel_browse, FALSE);
 118
 119         gtk_container_add(GTK_CONTAINER(scrollwin), view);
 120
 121         g_object_set_data(G_OBJECT(popup_menu_object), E_MPACKET_LIST_KEY, view);
 122
 123         return scrollwin;
 124 }
 125
 126 /** @todo XXX - implement a smarter solution for recreating the packet list */
 127 void
 128 new_packet_list_recreate(void)
 129 {
 130         g_signal_handler_block(packetlist->view, column_changed_handler_id);
 131         gtk_widget_destroy(pkt_scrollw);
 132
 133         prefs.num_cols = g_list_length(prefs.col_list);
 134
 135         build_column_format_array(&cfile.cinfo, prefs.num_cols, FALSE);
 136
 137         pkt_scrollw = new_packet_list_create();
 138         gtk_widget_show_all(pkt_scrollw);
 139
 140         main_widgets_rearrange();
 141
 142         if(cfile.state != FILE_CLOSED)
 143                 redissect_packets();
 144 }
 145
 146 guint
 147 new_packet_list_append(column_info *cinfo _U_, frame_data *fdata, packet_info *pinfo _U_)
 148 {
 149         /* fdata should be filled with the stuff we need
 150          * strings are built at display time.
 151          */
 152         GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(packetlist->view));
 153         guint visible_pos = packet_list_append_record(packetlist, fdata);
 154         if(model)
 155                 /* If the model is connected there is no packetsbar_update from "thaw */
 156                 packets_bar_update();
 157         /* Return the _visible_ position */
 158
 159         return visible_pos;
 160 }
 161
 162 static gboolean
 163 right_justify_column (gint col)
 164 {
 165         header_field_info *hfi;
 166         gboolean right_justify = FALSE;
 167
 168         switch (cfile.cinfo.col_fmt[col]) {
 169
 170         case COL_NUMBER:
 171         case COL_PACKET_LENGTH:
 172         case COL_CUMULATIVE_BYTES:
 173         case COL_DCE_CALL:
 174         case COL_DSCP_VALUE:
 175         case COL_UNRES_DST_PORT:
 176         case COL_UNRES_SRC_PORT:
 177         case COL_DEF_DST_PORT:
 178         case COL_DEF_SRC_PORT:
 179                 right_justify = TRUE;
 180                 break;
 181
 182         case COL_CUSTOM:
 183                 hfi = proto_registrar_get_byname(cfile.cinfo.col_custom_field[col]);
 184                 /* Check if this is a valid field and we have no strings lookup table */
 185                 if ((hfi != NULL) && ((hfi->strings == NULL) || !get_column_resolved(col))) {
 186                         /* Check for bool, framenum and decimal/octal integer types */
 187                         if ((hfi->type == FT_BOOLEAN) || (hfi->type == FT_FRAMENUM) ||
 188                                 (((hfi->display == BASE_DEC) || (hfi->display == BASE_OCT)) &&
 189                                  (IS_FT_INT(hfi->type) || IS_FT_UINT(hfi->type)))) {
 190                                 right_justify = TRUE;
 191                         }
 192                 }
 193                 break;
 194
 195         default:
 196                 break;
 197         }
 198
 199         return right_justify;
 200 }
 201
 202 static gboolean
 203 resolve_column (gint col)
 204 {
 205         header_field_info *hfi;
 206         gboolean resolve = FALSE;
 207
 208         switch (cfile.cinfo.col_fmt[col]) {
 209
 210         case COL_CUSTOM:
 211                 hfi = proto_registrar_get_byname(cfile.cinfo.col_custom_field[col]);
 212                 /* Check if this is a valid field */
 213                 if (hfi != NULL) {
 214                         /* Check if we have an OID or a strings table with integer values */
 215                         if ((hfi->type == FT_OID) ||
 216                             ((hfi->strings != NULL) &&
 217                              ((hfi->type == FT_BOOLEAN) || (hfi->type == FT_FRAMENUM) ||
 218                               IS_FT_INT(hfi->type) || IS_FT_UINT(hfi->type)))) {
 219                                 resolve = TRUE;
 220                         }
 221                 }
 222                 break;
 223
 224         default:
 225                 break;
 226         }
 227
 228         return resolve;
 229 }
 230
 231 static void
 232 col_title_change_ok (GtkWidget *w, gpointer parent_w)
 233 {
 234         GtkTreeViewColumn *col;
 235         const gchar  *title, *name, *occurrence_text;
 236         gint          col_id, cur_fmt, occurrence, col_width;
 237         gchar        *escaped_title;
 238         gboolean      recreate = FALSE;
 239
 240         col = g_object_get_data (G_OBJECT(w), COL_EDIT_COLUMN);
 241         col_id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(col), E_MPACKET_LIST_COL_KEY));
 242
 243         title = gtk_entry_get_text(GTK_ENTRY(g_object_get_data (G_OBJECT(w), COL_EDIT_TITLE_TE)));
 244         name = gtk_entry_get_text(GTK_ENTRY(g_object_get_data (G_OBJECT(w), COL_EDIT_FIELD_TE)));
 245         cur_fmt =  gtk_combo_box_get_active(GTK_COMBO_BOX(g_object_get_data (G_OBJECT(w), COL_EDIT_FORMAT_CMB)));
 246         occurrence_text = gtk_entry_get_text(GTK_ENTRY(g_object_get_data (G_OBJECT(w), COL_EDIT_OCCURRENCE_TE)));
 247         occurrence = (gint)strtol(occurrence_text, NULL, 10);
 248
 249         escaped_title = ws_strdup_escape_char(title, '_');
 250         gtk_tree_view_column_set_title(col, escaped_title);
 251         g_free(escaped_title);
 252
 253         if (strcmp (title, get_column_title(col_id)) != 0) {
 254                 set_column_title (col_id, title);
 255         }
 256
 257         if (cur_fmt != get_column_format(col_id)) {
 258                 set_column_format (col_id, cur_fmt);
 259                 recreate = TRUE;
 260         }
 261
 262         if (cur_fmt == COL_CUSTOM) {
 263                 if (strcmp (name, get_column_custom_field(col_id)) != 0) {
 264                         set_column_custom_field (col_id, name);
 265                         recreate = TRUE;
 266                 }
 267
 268                 if (occurrence != get_column_custom_occurrence(col_id)) {
 269                         set_column_custom_occurrence (col_id, occurrence);
 270                         recreate = TRUE;
 271                 }
 272         }
 273
 274         col_width = get_default_col_size (packetlist->view, title);
 275         gtk_tree_view_column_set_min_width(col, col_width);
 276
 277         if (!prefs.gui_use_pref_save) {
 278                 prefs_main_write();
 279         }
 280
 281         rebuild_visible_columns_menu ();
 282
 283         if (recreate) {
 284                 new_packet_list_recreate();
 285         }
 286
 287         new_packet_list_resize_column (col_id);
 288         window_destroy(GTK_WIDGET(parent_w));
 289 }
 290
 291 static void
 292 col_title_change_cancel (GtkWidget *w _U_, gpointer parent_w)
 293 {
 294         window_destroy(GTK_WIDGET(parent_w));
 295 }
 296
 297 static void
 298 col_details_format_changed_cb(GtkWidget *w, gpointer data _U_)
 299 {
 300         GtkWidget *field_lb, *field_te, *occurrence_lb, *occurrence_te;
 301         gint       cur_fmt;
 302
 303         field_lb = g_object_get_data (G_OBJECT(w), COL_EDIT_FIELD_LB);
 304         field_te = g_object_get_data (G_OBJECT(w), COL_EDIT_FIELD_TE);
 305         occurrence_lb = g_object_get_data (G_OBJECT(w), COL_EDIT_OCCURRENCE_LB);
 306         occurrence_te = g_object_get_data (G_OBJECT(w), COL_EDIT_OCCURRENCE_TE);
 307
 308         cur_fmt = gtk_combo_box_get_active(GTK_COMBO_BOX(w));
 309
 310         if (cur_fmt == COL_CUSTOM) {
 311                 /* Changing to custom */
 312                 gtk_widget_set_sensitive(field_lb, TRUE);
 313                 gtk_widget_set_sensitive(field_te, TRUE);
 314                 gtk_widget_set_sensitive(occurrence_lb, TRUE);
 315                 gtk_widget_set_sensitive(occurrence_te, TRUE);
 316         } else {
 317                 /* Changing to non-custom */
 318                 gtk_widget_set_sensitive(field_lb, FALSE);
 319                 gtk_widget_set_sensitive(field_te, FALSE);
 320                 gtk_widget_set_sensitive(occurrence_lb, FALSE);
 321                 gtk_widget_set_sensitive(occurrence_te, FALSE);
 322         }
 323 }
 324
 325 static void
 326 col_details_edit_dlg (gint col_id, GtkTreeViewColumn *col)
 327 {
 328         const gchar *title = gtk_tree_view_column_get_title(col);
 329         gchar *unescaped_title = ws_strdup_unescape_char(title, '_');
 330
 331         GtkWidget *label, *field_lb, *occurrence_lb;
 332         GtkWidget *title_te, *format_cmb, *field_te, *occurrence_te;
 333         GtkWidget *win, *main_tb, *main_vb, *bbox, *cancel_bt, *ok_bt;
 334         char       custom_occurrence_str[8];
 335         gint       cur_fmt, i;
 336
 337         win = dlg_window_new("Wireshark: Edit Column Details");
 338
 339         gtk_window_set_resizable(GTK_WINDOW(win),FALSE);
 340         gtk_window_resize(GTK_WINDOW(win), 400, 100);
 341
 342         main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
 343         gtk_container_add(GTK_CONTAINER(win), main_vb);
 344         gtk_container_set_border_width(GTK_CONTAINER(main_vb), 6);
 345
 346         main_tb = gtk_table_new(2, 4, FALSE);
 347         gtk_box_pack_start(GTK_BOX(main_vb), main_tb, FALSE, FALSE, 0);
 348         gtk_table_set_col_spacings(GTK_TABLE(main_tb), 10);
 349         gtk_table_set_row_spacings(GTK_TABLE(main_tb), 5);
 350
 351         label = gtk_label_new(ep_strdup_printf("Title:"));
 352         gtk_table_attach_defaults(GTK_TABLE(main_tb), label, 0, 1, 0, 1);
 353         gtk_misc_set_alignment(GTK_MISC(label), 1.0f, 0.5f);
 354         gtk_widget_set_tooltip_text(label, "Packet list column title.");
 355
 356         title_te = gtk_entry_new();
 357         gtk_table_attach_defaults(GTK_TABLE(main_tb), title_te, 1, 2, 0, 1);
 358         gtk_entry_set_text(GTK_ENTRY(title_te), unescaped_title);
 359         g_free(unescaped_title);
 360         gtk_widget_set_tooltip_text(title_te, "Packet list column title.");
 361
 362         label = gtk_label_new(ep_strdup_printf("Field type:"));
 363         gtk_table_attach_defaults(GTK_TABLE(main_tb), label, 0, 1, 1, 2);
 364         gtk_misc_set_alignment(GTK_MISC(label), 1.0f, 0.5f);
 365         gtk_widget_set_tooltip_text(label, "Select which packet information to present in the column.");
 366
 367         format_cmb = gtk_combo_box_text_new();
 368         for (i = 0; i < NUM_COL_FMTS; i++) {
 369            gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(format_cmb), col_format_desc(i));
 370         }
 371         g_signal_connect(format_cmb, "changed", G_CALLBACK(col_details_format_changed_cb), NULL);
 372         gtk_table_attach_defaults(GTK_TABLE(main_tb), format_cmb, 1, 2, 1, 2);
 373         gtk_widget_set_tooltip_text(format_cmb, "Select which packet information to present in the column.");
 374
 375         field_lb = gtk_label_new(ep_strdup_printf("Field name:"));
 376         gtk_table_attach_defaults(GTK_TABLE(main_tb), field_lb, 0, 1, 2, 3);
 377         gtk_misc_set_alignment(GTK_MISC(field_lb), 1.0f, 0.5f);
 378         gtk_widget_set_tooltip_text(field_lb,
 379                               "Field name used when field type is \"Custom\". "
 380                               "This string has the same syntax as a display filter string.");
 381         field_te = gtk_entry_new();
 382         gtk_table_attach_defaults(GTK_TABLE(main_tb), field_te, 1, 2, 2, 3);
 383         g_object_set_data (G_OBJECT(field_te), E_FILT_FIELD_NAME_ONLY_KEY, "");
 384         g_signal_connect(field_te, "changed", G_CALLBACK(filter_te_syntax_check_cb), NULL);
 385         g_signal_connect(field_te, "key-press-event", G_CALLBACK (filter_string_te_key_pressed_cb), NULL);
 386         g_signal_connect(win, "key-press-event", G_CALLBACK (filter_parent_dlg_key_pressed_cb), NULL);
 387         gtk_widget_set_tooltip_text(field_te,
 388                               "Field name used when field type is \"Custom\". "
 389                               "This string has the same syntax as a display filter string.");
 390
 391         occurrence_lb = gtk_label_new(ep_strdup_printf("Occurrence:"));
 392         gtk_table_attach_defaults(GTK_TABLE(main_tb), occurrence_lb, 0, 1, 3, 4);
 393         gtk_misc_set_alignment(GTK_MISC(occurrence_lb), 1.0f, 0.5f);
 394         gtk_widget_set_tooltip_text (occurrence_lb,
 395                               "Field occurence to use. "
 396                               "0=all (default), 1=first, 2=second, ..., -1=last.");
 397
 398         occurrence_te = gtk_entry_new();
 399         gtk_entry_set_max_length (GTK_ENTRY(occurrence_te), 4);
 400         gtk_table_attach_defaults(GTK_TABLE(main_tb), occurrence_te, 1, 2, 3, 4);
 401         gtk_widget_set_tooltip_text (occurrence_te,
 402                               "Field occurence to use. "
 403                               "0=all (default), 1=first, 2=second, ..., -1=last.");
 404
 405         bbox = dlg_button_row_new(GTK_STOCK_CANCEL,GTK_STOCK_OK, NULL);
 406         gtk_box_pack_end(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0);
 407
 408         ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
 409         g_object_set_data (G_OBJECT(ok_bt), COL_EDIT_COLUMN, col);
 410         g_object_set_data (G_OBJECT(ok_bt), COL_EDIT_FORMAT_CMB, format_cmb);
 411         g_object_set_data (G_OBJECT(ok_bt), COL_EDIT_TITLE_TE, title_te);
 412         g_object_set_data (G_OBJECT(ok_bt), COL_EDIT_FIELD_TE, field_te);
 413         g_object_set_data (G_OBJECT(ok_bt), COL_EDIT_OCCURRENCE_TE, occurrence_te);
 414         g_object_set_data (G_OBJECT(format_cmb), COL_EDIT_FIELD_LB, field_lb);
 415         g_object_set_data (G_OBJECT(format_cmb), COL_EDIT_FIELD_TE, field_te);
 416         g_object_set_data (G_OBJECT(format_cmb), COL_EDIT_OCCURRENCE_LB, occurrence_lb);
 417         g_object_set_data (G_OBJECT(format_cmb), COL_EDIT_OCCURRENCE_TE, occurrence_te);
 418         g_signal_connect(ok_bt, "clicked", G_CALLBACK(col_title_change_ok), win);
 419
 420         cur_fmt = get_column_format (col_id);
 421         gtk_combo_box_set_active(GTK_COMBO_BOX(format_cmb), cur_fmt);
 422         if (cur_fmt == COL_CUSTOM) {
 423                 gtk_entry_set_text(GTK_ENTRY(field_te), get_column_custom_field(col_id));
 424                 g_snprintf(custom_occurrence_str, sizeof(custom_occurrence_str), "%d", get_column_custom_occurrence(col_id));
 425                 gtk_entry_set_text(GTK_ENTRY(occurrence_te), custom_occurrence_str);
 426         }
 427
 428         dlg_set_activate(title_te, ok_bt);
 429         dlg_set_activate(field_te, ok_bt);
 430         dlg_set_activate(occurrence_te, ok_bt);
 431
 432         cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
 433         g_signal_connect(cancel_bt, "clicked", G_CALLBACK(col_title_change_cancel), win);
 434         window_set_cancel_button(win, cancel_bt, NULL);
 435
 436         gtk_widget_grab_default(ok_bt);
 437         gtk_widget_show_all(win);
 438 }
 439
 440 /* Process sort request;
 441  *   order:          GTK_SORT_ASCENDING or GTK_SORT_DESCENDING
 442  *   sort_indicator: TRUE: set sort_indicator on column; FALSE: don't set ....
 443  *
 444  * If necessary, columns are first "columnized" for all rows in the packet-list; If this
 445  *  is not completed (i.e., stopped), then the sort request is aborted.
 446  */
 447 static void
 448 new_packet_list_sort_column (gint col_id, GtkTreeViewColumn *col, GtkSortType order, gboolean sort_indicator)
 449 {
 450         GtkTreeViewColumn *prev_col;
 451
 452         if (col == NULL) {
 453                 col = gtk_tree_view_get_column(GTK_TREE_VIEW(packetlist->view), col_id);
 454         }
 455         g_assert(col);
 456
 457         if (!packet_list_do_packet_list_dissect_and_cache_all(packetlist, col_id)) {
 458                 return;  /* "stopped": do not try to sort */
 459         }
 460
 461         prev_col = (GtkTreeViewColumn *)
 462           g_object_get_data(G_OBJECT(packetlist->view), E_MPACKET_LIST_PREV_COLUMN_KEY);
 463
 464         if (prev_col) {
 465                 gtk_tree_view_column_set_sort_indicator(prev_col, FALSE);
 466         }
 467         gtk_tree_view_column_set_sort_indicator(col, sort_indicator);
 468         gtk_tree_view_column_set_sort_order (col, order);
 469         g_object_set_data(G_OBJECT(packetlist->view), E_MPACKET_LIST_PREV_COLUMN_KEY, col);
 470         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(packetlist), col_id, order); /* triggers sort callback */
 471
 472         scroll_to_current ();
 473 }
 474
 475 /*
 476  * We have our own functionality to toggle sort order on a column to avoid
 477  * having empty sorting arrow widgets in the column header.
 478  */
 479 static void
 480 new_packet_list_column_clicked_cb (GtkTreeViewColumn *col, gpointer user_data _U_)
 481 {
 482         GtkSortType order = gtk_tree_view_column_get_sort_order (col);
 483         gint col_id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(col), E_MPACKET_LIST_COL_KEY));
 484
 485         if (cfile.state == FILE_READ_IN_PROGRESS)
 486                 return;
 487
 488         if (!gtk_tree_view_column_get_sort_indicator(col)) {
 489                 new_packet_list_sort_column (col_id, col, GTK_SORT_ASCENDING, TRUE);
 490         } else if (order == GTK_SORT_ASCENDING) {
 491                 new_packet_list_sort_column (col_id, col, GTK_SORT_DESCENDING, TRUE);
 492         } else {
 493                 new_packet_list_sort_column (0, NULL, GTK_SORT_ASCENDING, FALSE);
 494         }
 495 }
 496
 497 static gdouble
 498 get_xalign_value (gchar xalign, gboolean right_justify)
 499 {
 500         double value;
 501
 502         switch (xalign) {
 503         case COLUMN_XALIGN_RIGHT:
 504                 value = 1.0f;
 505                 break;
 506         case COLUMN_XALIGN_CENTER:
 507                 value = 0.5f;
 508                 break;
 509         case COLUMN_XALIGN_LEFT:
 510                 value = 0.0f;
 511                 break;
 512         case COLUMN_XALIGN_DEFAULT:
 513         default:
 514                 if (right_justify) {
 515                         value = 1.0f;
 516                 } else {
 517                         value = 0.0f;
 518                 }
 519                 break;
 520         }
 521
 522         return value;
 523 }
 524
 525 static void
 526 new_packet_list_xalign_column (gint col_id, GtkTreeViewColumn *col, gchar xalign)
 527 {
 528         GList *renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT(col));
 529         gboolean right_justify = right_justify_column(col_id);
 530         gdouble value = get_xalign_value (xalign, right_justify);
 531         GList *entry;
 532         GtkCellRenderer *renderer;
 533
 534         entry = g_list_first(renderers);
 535         while (entry) {
 536                 renderer = (GtkCellRenderer *)entry->data;
 537                 g_object_set(G_OBJECT(renderer), "xalign", value, NULL);
 538                 entry = g_list_next (entry);
 539         }
 540         g_list_free (renderers);
 541
 542         if ((xalign == COLUMN_XALIGN_LEFT && !right_justify) ||
 543             (xalign == COLUMN_XALIGN_RIGHT && right_justify)) {
 544                 /* Default value selected, save default in the recent settings */
 545                 xalign = COLUMN_XALIGN_DEFAULT;
 546         }
 547
 548         recent_set_column_xalign (col_id, xalign);
 549         gtk_widget_queue_draw (packetlist->view);
 550 }
 551
 552 static void
 553 new_packet_list_set_visible_column (gint col_id, GtkTreeViewColumn *col, gboolean visible)
 554 {
 555         gtk_tree_view_column_set_visible(col, visible);
 556         set_column_visible(col_id, visible);
 557
 558         if (!prefs.gui_use_pref_save) {
 559                 prefs_main_write();
 560         }
 561
 562         rebuild_visible_columns_menu ();
 563         gtk_widget_queue_draw (packetlist->view);
 564 }
 565
 566 void
 567 new_packet_list_toggle_visible_column (gint col_id)
 568 {
 569         GtkTreeViewColumn *col =
 570           gtk_tree_view_get_column(GTK_TREE_VIEW(packetlist->view), col_id);
 571
 572         new_packet_list_set_visible_column (col_id, col, get_column_visible(col_id) ? FALSE : TRUE);
 573 }
 574
 575 void
 576 new_packet_list_set_all_columns_visible (void)
 577 {
 578         GtkTreeViewColumn *col;
 579         int col_id;
 580
 581         for (col_id = 0; col_id < cfile.cinfo.num_cols; col_id++) {
 582                 col = gtk_tree_view_get_column(GTK_TREE_VIEW(packetlist->view), col_id);
 583                 gtk_tree_view_column_set_visible(col, TRUE);
 584                 set_column_visible(col_id, TRUE);
 585         }
 586
 587         if (!prefs.gui_use_pref_save) {
 588                 prefs_main_write();
 589         }
 590
 591         rebuild_visible_columns_menu ();
 592         gtk_widget_queue_draw (packetlist->view);
 593 }
 594
 595 static void
 596 new_packet_list_remove_column (gint col_id, GtkTreeViewColumn *col _U_)
 597 {
 598         column_prefs_remove(col_id);
 599
 600         if (!prefs.gui_use_pref_save) {
 601                 prefs_main_write();
 602         }
 603
 604         new_packet_list_recreate();
 605 }
 606
 607 static void
 608 new_packet_list_toggle_resolved (GtkWidget *w, gint col_id)
 609 {
 610         /* We have to check for skip-update because we get an emit in menus_set_column_resolved() */
 611         if (g_object_get_data(G_OBJECT(w), "skip-update") == NULL) {
 612                 set_column_resolved (col_id, get_column_resolved (col_id) ? FALSE : TRUE);
 613
 614                 if (!prefs.gui_use_pref_save) {
 615                         prefs_main_write();
 616                 }
 617
 618                 new_packet_list_recreate();
 619         }
 620 }
 621
 622 void
 623 new_packet_list_column_menu_cb (GtkWidget *w, gpointer user_data _U_, COLUMN_SELECTED_E action)
 624 {
 625         GtkTreeViewColumn *col = (GtkTreeViewColumn *)
 626           g_object_get_data(G_OBJECT(packetlist->view), E_MPACKET_LIST_COLUMN_KEY);
 627         gint col_id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(col), E_MPACKET_LIST_COL_KEY));
 628
 629         switch (action) {
 630         case COLUMN_SELECTED_SORT_ASCENDING:
 631                 new_packet_list_sort_column (col_id, col, GTK_SORT_ASCENDING, TRUE);
 632                 break;
 633         case COLUMN_SELECTED_SORT_DESCENDING:
 634                 new_packet_list_sort_column (col_id, col, GTK_SORT_DESCENDING, TRUE);
 635                 break;
 636         case COLUMN_SELECTED_SORT_NONE:
 637                 new_packet_list_sort_column (0, NULL, GTK_SORT_ASCENDING, FALSE);
 638                 break;
 639         case COLUMN_SELECTED_TOGGLE_RESOLVED:
 640                 new_packet_list_toggle_resolved (w, col_id);
 641                 break;
 642         case COLUMN_SELECTED_ALIGN_LEFT:
 643                 new_packet_list_xalign_column (col_id, col, COLUMN_XALIGN_LEFT);
 644                 break;
 645         case COLUMN_SELECTED_ALIGN_CENTER:
 646                 new_packet_list_xalign_column (col_id, col, COLUMN_XALIGN_CENTER);
 647                 break;
 648         case COLUMN_SELECTED_ALIGN_RIGHT:
 649                 new_packet_list_xalign_column (col_id, col, COLUMN_XALIGN_RIGHT);
 650                 break;
 651         case COLUMN_SELECTED_ALIGN_DEFAULT:
 652                 new_packet_list_xalign_column (col_id, col, COLUMN_XALIGN_DEFAULT);
 653                 break;
 654         case COLUMN_SELECTED_RESIZE:
 655                 new_packet_list_resize_column (col_id);
 656                 break;
 657         case COLUMN_SELECTED_CHANGE:
 658                 col_details_edit_dlg (col_id, col);
 659                 break;
 660         case COLUMN_SELECTED_HIDE:
 661                 new_packet_list_set_visible_column (col_id, col, FALSE);
 662                 break;
 663         case COLUMN_SELECTED_REMOVE:
 664                 new_packet_list_remove_column (col_id, col);
 665                 break;
 666         default:
 667                 g_assert_not_reached();
 668                 break;
 669         }
 670 }
 671
 672 static gboolean
 673 new_packet_list_column_button_pressed_cb (GtkWidget *widget, GdkEvent *event, gpointer data)
 674 {
 675         GtkWidget *col = (GtkWidget *) data;
 676         GtkWidget *menu = g_object_get_data(G_OBJECT(popup_menu_object), PM_PACKET_LIST_COL_KEY);
 677         gint       col_id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(col), E_MPACKET_LIST_COL_KEY));
 678         gboolean   right_justify = right_justify_column (col_id);
 679
 680         menus_set_column_align_default (right_justify);
 681         menus_set_column_resolved (get_column_resolved (col_id), resolve_column (col_id));
 682         g_object_set_data(G_OBJECT(packetlist->view), E_MPACKET_LIST_COLUMN_KEY, col);
 683         return popup_menu_handler (widget, event, menu);
 684 }
 685
 686 static void
 687 column_dnd_changed_cb(GtkTreeView *tree_view, gpointer data _U_)
 688 {
 689         GtkTreeViewColumn  *column;
 690         GtkTreeSelection   *selection;
 691         GtkTreeModel  *model;
 692         GtkTreeIter    iter;
 693         GList         *columns, *list, *clp, *new_col_list = NULL;
 694         gint           old_col_id, new_col_id = 0;
 695         fmt_data      *cfmt;
 696
 697         selection = gtk_tree_view_get_selection(tree_view);
 698         if (!gtk_tree_selection_get_selected(selection, &model, &iter))
 699                 return;
 700
 701         list = columns = gtk_tree_view_get_columns(tree_view);
 702         while (columns) {
 703                 column = columns->data;
 704                 old_col_id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(column), E_MPACKET_LIST_COL_KEY));
 705
 706                 clp = g_list_nth (prefs.col_list, old_col_id);
 707                 cfmt = (fmt_data *) clp->data;
 708                 new_col_list = g_list_append (new_col_list, cfmt);
 709                 columns = g_list_next (columns);
 710                 new_col_id++;
 711         }
 712         g_list_free (list);
 713         g_list_free (prefs.col_list);
 714
 715         prefs.col_list = new_col_list;
 716
 717         if (!prefs.gui_use_pref_save) {
 718                 prefs_main_write();
 719         }
 720
 721         new_packet_list_recreate();
 722 }
 723
 724 static GtkWidget *
 725 create_view_and_model(void)
 726 {
 727         GtkTreeViewColumn *col;
 728         GtkCellRenderer *renderer;
 729         gint i, col_width;
 730         gdouble value;
 731         gchar *tooltip_text;
 732         header_field_info *hfi;
 733         gint col_min_width;
 734         gchar *escaped_title;
 735
 736         packetlist = new_packet_list_new();
 737
 738         packetlist->view = tree_view_new(GTK_TREE_MODEL(packetlist));
 739
 740         gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(packetlist->view),
 741                                                 TRUE);
 742         g_signal_connect(packetlist->view, "cursor-changed",
 743                          G_CALLBACK(new_packet_list_select_cb), NULL);
 744         g_signal_connect(packetlist->view, "row-activated",
 745                          G_CALLBACK(new_packet_list_double_click_cb), NULL);
 746         g_signal_connect(packetlist->view, "button_press_event", G_CALLBACK(popup_menu_handler),
 747                                    g_object_get_data(G_OBJECT(popup_menu_object), PM_PACKET_LIST_KEY));
 748         column_changed_handler_id = g_signal_connect(packetlist->view, "columns-changed", G_CALLBACK(column_dnd_changed_cb), NULL);
 749         g_object_set_data(G_OBJECT(popup_menu_object), E_MPACKET_LIST_KEY, packetlist);
 750
 751         /*              g_object_unref(packetlist); */ /* Destroy automatically with view for now */ /* XXX - Messes up freezing & thawing */
 752
 753 #if GTK_CHECK_VERSION(3,0,0)
 754         gtk_widget_override_font(packetlist->view, user_font_get_regular());
 755 #else
 756         gtk_widget_modify_font(packetlist->view, user_font_get_regular());
 757 #endif
 758
 759         /* We need one extra column to store the entire PacketListRecord */
 760         for(i = 0; i < cfile.cinfo.num_cols; i++) {
 761                 renderer = gtk_cell_renderer_text_new();
 762                 col = gtk_tree_view_column_new();
 763                 gtk_tree_view_column_pack_start(col, renderer, TRUE);
 764                 value = get_xalign_value(recent_get_column_xalign(i), right_justify_column(i));
 765                 g_object_set(G_OBJECT(renderer),
 766                              "xalign", value,
 767                              NULL);
 768                 g_object_set(renderer,
 769                              "ypad", 0,
 770                              NULL);
 771                 gtk_tree_view_column_set_cell_data_func(col, renderer,
 772                                                         show_cell_data_func,
 773                                                         GINT_TO_POINTER(i),
 774                                                         NULL);
 775                 if (cfile.cinfo.col_fmt[i] == COL_CUSTOM) {
 776                         hfi = proto_registrar_get_byname(cfile.cinfo.col_custom_field[i]);
 777                         /* Check if this is a valid custom_field */
 778                         if (hfi != NULL) {
 779                                 if (hfi->parent != -1) {
 780                                         /* Prefix with protocol name */
 781                                         if (cfile.cinfo.col_custom_occurrence[i] != 0) {
 782                                                 tooltip_text = g_strdup_printf("%s\n%s (%s#%d)", proto_get_protocol_name(hfi->parent), hfi->name, hfi->abbrev, cfile.cinfo.col_custom_occurrence[i]);
 783                                         } else {
 784                                                 tooltip_text = g_strdup_printf("%s\n%s (%s)", proto_get_protocol_name(hfi->parent), hfi->name, hfi->abbrev);
 785                                         }
 786                                 } else {
 787                                         tooltip_text = g_strdup_printf("%s (%s)", hfi->name, hfi->abbrev);
 788                                 }
 789                         } else {
 790                                 tooltip_text = g_strdup_printf("Unknown Field: %s", get_column_custom_field(i));
 791                         }
 792                 } else {
 793                         tooltip_text = g_strdup(col_format_desc(cfile.cinfo.col_fmt[i]));
 794                 }
 795                 escaped_title = ws_strdup_escape_char(cfile.cinfo.col_title[i], '_');
 796                 gtk_tree_view_column_set_title(col, escaped_title);
 797                 g_free (escaped_title);
 798                 gtk_tree_view_column_set_clickable(col, TRUE);
 799                 gtk_tree_view_column_set_resizable(col, TRUE);
 800                 gtk_tree_view_column_set_visible(col, get_column_visible(i));
 801                 gtk_tree_view_column_set_sizing(col,GTK_TREE_VIEW_COLUMN_FIXED);
 802                 gtk_tree_view_column_set_reorderable(col, TRUE); /* XXX - Should this be saved in the prefs? */
 803
 804                 g_object_set_data(G_OBJECT(col), E_MPACKET_LIST_COL_KEY, GINT_TO_POINTER(i));
 805                 g_signal_connect(col, "clicked", G_CALLBACK(new_packet_list_column_clicked_cb), NULL);
 806
 807                 /*
 808                  * The column can't be adjusted to a size smaller than this
 809                  * XXX The minimum size will be the size of the title
 810                  * should that be limited for long titles?
 811                  */
 812                 col_min_width = get_default_col_size (packetlist->view, cfile.cinfo.col_title[i]);
 813                 if(col_min_width<COLUMN_WIDTH_MIN){
 814                         gtk_tree_view_column_set_min_width(col, COLUMN_WIDTH_MIN);
 815                 }else{
 816                         gtk_tree_view_column_set_min_width(col, col_min_width);
 817                 }
 818
 819                 /* Set the size the column will be displayed with */
 820                 col_width = recent_get_column_width(i);
 821                 if(col_width < 1) {
 822                         gint fmt;
 823                         const gchar *long_str;
 824
 825                         fmt = get_column_format(i);
 826                         long_str = get_column_width_string(fmt, i);
 827                         if(long_str){
 828                                 col_width = get_default_col_size (packetlist->view, long_str);
 829                         }else{
 830                                 col_width = COLUMN_WIDTH_MIN;
 831                         }
 832                         gtk_tree_view_column_set_fixed_width(col, col_width);
 833                 }else{
 834                         gtk_tree_view_column_set_fixed_width(col, col_width);
 835                 }
 836
 837                 gtk_tree_view_append_column(GTK_TREE_VIEW(packetlist->view), col);
 838
 839                 gtk_widget_set_tooltip_text(gtk_tree_view_column_get_button(col), tooltip_text);
 840                 g_free(tooltip_text);
 841                 g_signal_connect(gtk_tree_view_column_get_button(col), "button_press_event",
 842                                  G_CALLBACK(new_packet_list_column_button_pressed_cb), col);
 843
 844                 if (i == 0) {  /* Default sort on first column */
 845                         g_object_set_data(G_OBJECT(packetlist->view), E_MPACKET_LIST_COLUMN_KEY, col);
 846                         g_object_set_data(G_OBJECT(packetlist->view), E_MPACKET_LIST_PREV_COLUMN_KEY, col);
 847                 }
 848         }
 849
 850         rebuild_visible_columns_menu ();
 851
 852         return packetlist->view;
 853 }
 854
 855 static frame_data *
 856 new_packet_list_get_record(GtkTreeModel *model, GtkTreeIter *iter)
 857 {
 858         frame_data *fdata;
 859         /* The last column is reserved for frame_data */
 860         gint record_column = gtk_tree_model_get_n_columns(model)-1;
 861
 862         gtk_tree_model_get(model, iter,
 863                            record_column,
 864                            &fdata,
 865                            -1);
 866
 867         return fdata;
 868 }
 869
 870 void
 871 new_packet_list_clear(void)
 872 {
 873         packet_history_clear();
 874
 875         new_packet_list_store_clear(packetlist);
 876         gtk_widget_queue_draw(packetlist->view);
 877         /* XXX is this correct in all cases?
 878          * Reset the sort column, use packetlist as model in case the list is frozen.
 879          */
 880         new_packet_list_sort_column(0, NULL, GTK_SORT_ASCENDING, FALSE);
 881 }
 882
 883 void
 884 new_packet_list_freeze(void)
 885 {
 886         /* So we don't lose the model by the time we want to thaw it */
 887         g_object_ref(packetlist);
 888
 889         /* Detach view from model */
 890         gtk_tree_view_set_model(GTK_TREE_VIEW(packetlist->view), NULL);
 891 }
 892
 893 void
 894 new_packet_list_thaw(void)
 895 {
 896         /* Apply model */
 897         gtk_tree_view_set_model( GTK_TREE_VIEW(packetlist->view), GTK_TREE_MODEL(packetlist));
 898
 899         /* Remove extra reference added by new_packet_list_freeze() */
 900         g_object_unref(packetlist);
 901
 902         packets_bar_update();
 903 }
 904
 905 void
 906 new_packet_list_recreate_visible_rows(void)
 907 {
 908         packet_list_recreate_visible_rows(packetlist);
 909 }
 910
 911 void new_packet_list_resize_column(gint col)
 912 {
 913         GtkTreeViewColumn *column;
 914         gint col_width;
 915         const gchar *long_str;
 916
 917         long_str = packet_list_get_widest_column_string(packetlist, col);
 918         if(!long_str || strcmp("",long_str)==0)
 919                 /* If we get an empty string leave the width unchanged */
 920                 return;
 921         column = gtk_tree_view_get_column (GTK_TREE_VIEW(packetlist->view), col);
 922         col_width = get_default_col_size (packetlist->view, long_str);
 923         gtk_tree_view_column_set_fixed_width(column, col_width);
 924 }
 925
 926 static void
 927 new_packet_list_resize_columns(void)
 928 {
 929         gint            progbar_loop_max;
 930         gint            progbar_loop_var;
 931
 932         progbar_loop_max = cfile.cinfo.num_cols;
 933
 934         for (progbar_loop_var = 0; progbar_loop_var < progbar_loop_max; ++progbar_loop_var)
 935                 new_packet_list_resize_column(progbar_loop_var);
 936 }
 937
 938 void
 939 new_packet_list_resize_columns_cb(GtkWidget *widget _U_, gpointer data _U_)
 940 {
 941         new_packet_list_resize_columns();
 942 }
 943
 944 static void
 945 scroll_to_current(void)
 946 {
 947         GtkTreeSelection *selection;
 948         GtkTreeIter iter;
 949         GtkTreeModel *model;
 950         GtkWidget *focus = gtk_window_get_focus(GTK_WINDOW(top_level));
 951
 952         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(packetlist->view));
 953         /* model is filled with the current model as a convenience. */
 954         if (!gtk_tree_selection_get_selected(selection, &model, &iter))
 955                 return;
 956
 957         scroll_to_and_select_iter(model, selection, &iter);
 958
 959         /* Set the focus back where it was */
 960         if (focus)
 961                 gtk_window_set_focus(GTK_WINDOW(top_level), focus);
 962 }
 963
 964 void
 965 new_packet_list_next(void)
 966 {
 967         GtkTreeSelection *selection;
 968         GtkTreeIter iter;
 969         GtkTreeModel *model;
 970         GtkWidget *focus = gtk_window_get_focus(GTK_WINDOW(top_level));
 971
 972         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(packetlist->view));
 973         /* model is filled with the current model as a convenience. */
 974         if (!gtk_tree_selection_get_selected(selection, &model, &iter))
 975                 return;
 976
 977         if (!gtk_tree_model_iter_next(model, &iter))
 978                 return;
 979
 980         scroll_to_and_select_iter(model, selection, &iter);
 981
 982         /* Set the focus back where it was */
 983         if (focus)
 984                 gtk_window_set_focus(GTK_WINDOW(top_level), focus);
 985 }
 986
 987 void
 988 new_packet_list_prev(void)
 989 {
 990         GtkTreeSelection *selection;
 991         GtkTreeIter iter;
 992         GtkTreeModel *model;
 993         GtkTreePath *path;
 994         GtkWidget *focus = gtk_window_get_focus(GTK_WINDOW(top_level));
 995
 996         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(packetlist->view));
 997         /* model is filled with the current model as a convenience. */
 998         if (!gtk_tree_selection_get_selected(selection, &model, &iter))
 999                 return;
1000
1001         path = gtk_tree_model_get_path(model, &iter);
1002
1003         if (!gtk_tree_path_prev(path))
1004                 return;
1005
1006         if (!gtk_tree_model_get_iter(model, &iter, path))
1007                 return;
1008
1009         scroll_to_and_select_iter(model, selection, &iter);
1010
1011         gtk_tree_path_free(path);
1012
1013         /* Set the focus back where it was */
1014         if (focus)
1015                 gtk_window_set_focus(GTK_WINDOW(top_level), focus);
1016 }
1017
1018 static void
1019 scroll_to_and_select_iter(GtkTreeModel *model, GtkTreeSelection *selection, GtkTreeIter *iter)
1020 {
1021         GtkTreePath *path;
1022
1023         g_assert(model);
1024
1025         /* Select the row */
1026         if(!selection)
1027                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(packetlist->view));
1028         gtk_tree_selection_select_iter (selection, iter);
1029         path = gtk_tree_model_get_path(model, iter);
1030         gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(packetlist->view),
1031                         path,
1032                         NULL,
1033                         TRUE,   /* use_align */
1034                         0.5,    /* row_align determines where the row is placed, 0.5 means center */
1035                         0);     /* The horizontal alignment of the column */
1036
1037         /* "cursor-changed" signal triggers new_packet_list_select_cb() */
1038         /*  which will update the middle and bottom panes.              */
1039         gtk_tree_view_set_cursor(GTK_TREE_VIEW(packetlist->view),
1040                         path,
1041                         NULL,
1042                         FALSE); /* start_editing */
1043
1044         gtk_tree_path_free(path);
1045 }
1046
1047 void
1048 new_packet_list_select_first_row(void)
1049 {
1050         GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(packetlist->view));
1051         GtkTreeIter iter;
1052
1053         if(!gtk_tree_model_get_iter_first(model, &iter))
1054                 return;
1055
1056         scroll_to_and_select_iter(model, NULL, &iter);
1057         gtk_widget_grab_focus(packetlist->view);
1058 }
1059
1060 void
1061 new_packet_list_select_last_row(void)
1062 {
1063         GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(packetlist->view));
1064         GtkTreeIter iter;
1065         gint children;
1066         guint last_row;
1067
1068         if((children = gtk_tree_model_iter_n_children(model, NULL)) == 0)
1069                 return;
1070
1071         last_row = children-1;
1072         if(!gtk_tree_model_iter_nth_child(model, &iter, NULL, last_row))
1073                 return;
1074
1075         scroll_to_and_select_iter(model, NULL, &iter);
1076 }
1077
1078 void
1079 new_packet_list_moveto_end(void)
1080 {
1081         GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(packetlist->view));
1082         GtkTreeIter iter;
1083         GtkTreePath *path;
1084         gint children;
1085         guint last_row;
1086
1087         if((children = gtk_tree_model_iter_n_children(model, NULL)) == 0)
1088                 return;
1089
1090         last_row = children-1;
1091         if(!gtk_tree_model_iter_nth_child(model, &iter, NULL, last_row))
1092                 return;
1093
1094         path = gtk_tree_model_get_path(model, &iter);
1095
1096         gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(packetlist->view),
1097                         path,
1098                         NULL,
1099                         TRUE,   /* use_align */
1100                         0.5,    /* row_align determines where the row is placed, 0.5 means center */
1101                         0);     /* The horizontal alignment of the column */
1102
1103         gtk_tree_path_free(path);
1104
1105 }
1106
1107 gboolean
1108 new_packet_list_check_end(void)
1109 {
1110         gboolean at_end = FALSE;
1111         GtkAdjustment *adj;
1112
1113 #if GTK_CHECK_VERSION(3,0,0)
1114         adj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (packetlist->view));
1115 #else
1116         adj = gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(packetlist->view));
1117 #endif
1118         g_return_val_if_fail(adj != NULL, FALSE);
1119
1120         if (gtk_adjustment_get_value(adj) >= gtk_adjustment_get_upper(adj) - gtk_adjustment_get_page_size(adj)) {
1121                 at_end = TRUE;
1122         }
1123 #ifdef HAVE_LIBPCAP
1124         if (gtk_adjustment_get_value(adj) > 0 && at_end != last_at_end && at_end != auto_scroll_live) {
1125                 main_auto_scroll_live_changed(at_end);
1126         }
1127 #endif
1128         last_at_end = at_end;
1129         return at_end;
1130 }
1131
1132 /*
1133  * Given a frame_data structure, scroll to and select the row in the
1134  * packet list corresponding to that frame.  If there is no such
1135  * row, return FALSE, otherwise return TRUE.
1136  */
1137 gboolean
1138 new_packet_list_select_row_from_data(frame_data *fdata_needle)
1139 {
1140         GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(packetlist->view));
1141         GtkTreeIter iter;
1142
1143         /* Initializes iter with the first iterator in the tree (the one at the path "0")
1144          * and returns TRUE. Returns FALSE if the tree is empty
1145          */
1146         if(!gtk_tree_model_get_iter_first(model, &iter))
1147                 return FALSE;
1148
1149         do {
1150                 frame_data *fdata;
1151
1152                 fdata = new_packet_list_get_record(model, &iter);
1153
1154                 if(fdata == fdata_needle) {
1155                         scroll_to_and_select_iter(model, NULL, &iter);
1156
1157                         return TRUE;
1158                 }
1159         } while (gtk_tree_model_iter_next(model, &iter));
1160
1161         return FALSE;
1162 }
1163
1164 void
1165 new_packet_list_set_selected_row(gint row)
1166 {
1167         GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(packetlist->view));
1168         GtkTreeIter iter;
1169         GtkTreeSelection *selection;
1170         GtkTreePath *path;
1171
1172         path = gtk_tree_path_new_from_indices(row-1, -1);
1173
1174         if (!gtk_tree_model_get_iter(model, &iter, path))
1175                 return;
1176
1177         /* Select the row */
1178         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(packetlist->view));
1179         gtk_tree_selection_select_iter (selection, &iter);
1180
1181         /* "cursor-changed" signal triggers new_packet_list_select_cb() */
1182         /*  which will update the middle and bottom panes.              */
1183         gtk_tree_view_set_cursor(GTK_TREE_VIEW(packetlist->view),
1184                         path,
1185                         NULL,
1186                         FALSE); /* start_editing */
1187
1188         gtk_tree_path_free(path);
1189 }
1190
1191 static gint
1192 row_number_from_iter(GtkTreeIter *iter)
1193 {
1194         gint row;
1195         gint *indices;
1196         GtkTreePath *path;
1197         GtkTreeModel *model;
1198
1199         model = gtk_tree_view_get_model(GTK_TREE_VIEW(packetlist->view));
1200         path = gtk_tree_model_get_path(model, iter);
1201         indices = gtk_tree_path_get_indices(path);
1202         g_assert(indices);
1203         /* Indices start from 0, but rows start from 1. Hence +1 */
1204         row = indices[0] + 1;
1205
1206         gtk_tree_path_free(path);
1207
1208         return row;
1209 }
1210
1211 static void
1212 new_packet_list_select_cb(GtkTreeView *tree_view, gpointer data _U_)
1213 {
1214         GtkTreeSelection *selection;
1215         GtkTreeIter iter;
1216         gint row;
1217
1218         if ((selection = gtk_tree_view_get_selection(tree_view)) == NULL)
1219                 return;
1220
1221         if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
1222                 return;
1223
1224         row = row_number_from_iter(&iter);
1225
1226         /* Check if already selected
1227          */
1228         if (cfile.current_frame && cfile.current_row == row)
1229                 return;
1230
1231         /* Remove the hex display tab pages */
1232         while(gtk_notebook_get_nth_page(GTK_NOTEBOOK(byte_nb_ptr_gbl), 0))
1233                 gtk_notebook_remove_page(GTK_NOTEBOOK(byte_nb_ptr_gbl), 0);
1234
1235         cf_select_packet(&cfile, row);
1236         /* If searching the tree, set the focus there; otherwise, focus on the packet list */
1237         if (cfile.search_in_progress && (cfile.decode_data || cfile.decode_data)) {
1238                 gtk_widget_grab_focus(tree_view_gbl);
1239         } else {
1240                 gtk_widget_grab_focus(packetlist->view);
1241         }
1242
1243         /* Add newly selected frame to packet history (breadcrumbs) */
1244         packet_history_add(row);
1245 }
1246
1247 static void
1248 new_packet_list_double_click_cb(GtkTreeView *treeview, GtkTreePath *path _U_,
1249                                 GtkTreeViewColumn *col _U_, gpointer userdata _U_)
1250 {
1251         new_packet_window(GTK_WIDGET(treeview), FALSE);
1252 }
1253
1254 gboolean
1255 new_packet_list_get_event_row_column(GdkEventButton *event_button,
1256                                      gint *physical_row, gint *row, gint *column)
1257 {
1258         GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(packetlist->view));
1259         GtkTreePath *path;
1260         GtkTreeViewColumn *view_column;
1261
1262         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(packetlist->view),
1263                                           (gint) event_button->x,
1264                                           (gint) event_button->y,
1265                                           &path, &view_column, NULL, NULL)) {
1266                 GtkTreeIter iter;
1267                 GList *cols;
1268                 gint *indices;
1269                 frame_data *fdata;
1270
1271                 /* Fetch indices */
1272                 gtk_tree_model_get_iter(model, &iter, path);
1273                 indices = gtk_tree_path_get_indices(path);
1274                 g_assert(indices);
1275                 /* Indices start from 0. Hence +1 */
1276                 *row = indices[0] + 1;
1277                 gtk_tree_path_free(path);
1278
1279                 /* Fetch physical row */
1280                 fdata = new_packet_list_get_record(model, &iter);
1281                 *physical_row = fdata->num;
1282
1283                 /* Fetch column */
1284                 /* XXX -doesn't work if columns are re-arranged? */
1285                 cols = gtk_tree_view_get_columns(GTK_TREE_VIEW(packetlist->view));
1286                 *column = g_list_index(cols, (gpointer) view_column);
1287                 g_list_free(cols);
1288
1289                 return TRUE;
1290         }
1291         else
1292                 return FALSE;
1293 }
1294
1295 frame_data *
1296 new_packet_list_get_row_data(gint row)
1297 {
1298         GtkTreePath *path = gtk_tree_path_new();
1299         GtkTreeIter iter;
1300         frame_data *fdata;
1301
1302         gtk_tree_path_append_index(path, row-1);
1303         gtk_tree_model_get_iter(GTK_TREE_MODEL(packetlist), &iter, path);
1304
1305         fdata = new_packet_list_get_record(GTK_TREE_MODEL(packetlist), &iter);
1306
1307         gtk_tree_path_free(path);
1308
1309         return fdata;
1310 }
1311
1312 static void
1313 show_cell_data_func(GtkTreeViewColumn *col _U_, GtkCellRenderer *renderer,
1314                         GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
1315 {
1316         guint col_num = GPOINTER_TO_INT(data);
1317         frame_data *fdata;
1318         gchar *cell_text;
1319
1320         gtk_tree_model_get(model, iter,
1321                         col_num, &cell_text,
1322                         /* The last column is reserved for frame_data */
1323                         gtk_tree_model_get_n_columns(model)-1, &fdata,
1324                         -1);
1325
1326         g_assert(cell_text);
1327
1328         if((fdata->color_filter)||(fdata->flags.marked)||(fdata->flags.ignored)){
1329                 gboolean color_on = enable_color;
1330                 GdkColor fg_gdk;
1331                 GdkColor bg_gdk;
1332                 if(fdata->flags.ignored){
1333                         color_t_to_gdkcolor(&fg_gdk, &prefs.gui_ignored_fg);
1334                         color_t_to_gdkcolor(&bg_gdk, &prefs.gui_ignored_bg);
1335                         color_on = TRUE;
1336                 }else if(fdata->flags.marked){
1337                         color_t_to_gdkcolor(&fg_gdk, &prefs.gui_marked_fg);
1338                         color_t_to_gdkcolor(&bg_gdk, &prefs.gui_marked_bg);
1339                         color_on = TRUE;
1340                 }else{
1341                         color_t fg_color_t;
1342                         color_t bg_color_t;
1343                         const color_filter_t *color_filter = fdata->color_filter;
1344
1345                         fg_color_t = color_filter->fg_color;
1346                         bg_color_t = color_filter->bg_color;
1347                         color_t_to_gdkcolor(&fg_gdk, &fg_color_t);
1348                         color_t_to_gdkcolor(&bg_gdk, &bg_color_t);
1349                 }
1350                 g_object_set(renderer,
1351                          "text", cell_text,
1352                          "foreground-gdk", &fg_gdk,
1353                          "foreground-set", color_on,
1354                          "background-gdk", &bg_gdk,
1355                          "background-set", color_on,
1356                          NULL);
1357         }else{
1358                 g_object_set(renderer,
1359                          "text", cell_text,
1360                          "foreground-set", FALSE,
1361                          "background-set", FALSE,
1362                          NULL);
1363         }
1364         g_free(cell_text);
1365 }
1366
1367 void
1368 new_packet_list_enable_color(gboolean enable)
1369 {
1370         enable_color = enable;
1371         gtk_widget_queue_draw (packetlist->view);
1372 }
1373
1374 /* Redraw the packet list *and* currently-selected detail */
1375 void
1376 new_packet_list_queue_draw(void)
1377 {
1378         GtkTreeSelection *selection;
1379         GtkTreeIter iter;
1380         gint row;
1381
1382         gtk_widget_queue_draw (packetlist->view);
1383
1384         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(packetlist->view));
1385         if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
1386                 return;
1387         row = row_number_from_iter(&iter);
1388         cf_select_packet(&cfile, row);
1389 }
1390
1391 /* Set the selection mode of the packet list window. */
1392 void
1393 new_packet_list_set_sel_browse(gboolean val, gboolean force_set)
1394 {
1395         GtkSelectionMode new_mode;
1396         /* initialize with a mode we don't use, so that the mode == new_mode
1397          * test will fail the first time */
1398         static GtkSelectionMode mode = GTK_SELECTION_MULTIPLE;
1399
1400         /* Yeah, GTK uses "browse" in the case where we do not, but oh well. I
1401          * think "browse" in Wireshark makes more sense than "SINGLE" in GTK+ */
1402         new_mode = val ? GTK_SELECTION_SINGLE : GTK_SELECTION_BROWSE;
1403
1404         if ((mode == new_mode) && !force_set) {
1405                 /*
1406                  * The mode isn't changing, so don't do anything.
1407                  * In particular, don't gratuitiously unselect the
1408                  * current packet.
1409                  *
1410                  * XXX - Copied code from "old" packet list
1411                  *  - I don't know if the comment below is still true...
1412                  * XXX - why do we have to unselect the current packet
1413                  * ourselves?  The documentation for the GtkCList at
1414                  *
1415                  *      http://developer.gnome.org/doc/API/gtk/gtkclist.html
1416                  *
1417                  * says "Note that setting the widget's selection mode to
1418                  * one of GTK_SELECTION_BROWSE or GTK_SELECTION_SINGLE will
1419                  * cause all the items in the GtkCList to become deselected."
1420                  */
1421                 return;
1422         }
1423
1424         if (cfile.finfo_selected)
1425                 cf_unselect_field(&cfile);
1426
1427         mode = new_mode;
1428         gtk_tree_selection_set_mode (gtk_tree_view_get_selection(GTK_TREE_VIEW(packetlist->view)), mode);
1429 }
1430
1431 void
1432 new_packet_list_set_font(PangoFontDescription *font)
1433 {
1434 #if GTK_CHECK_VERSION(3,0,0)
1435     gtk_widget_override_font(packetlist->view, font);
1436 #else
1437         gtk_widget_modify_font(packetlist->view, font);
1438 #endif
1439 }
1440
1441
1442 /* call this after last set_frame_mark is done */
1443 static void
1444 mark_frames_ready(void)
1445 {
1446         packets_bar_update();
1447         new_packet_list_queue_draw();
1448 }
1449
1450 static void
1451 set_frame_mark(gboolean set, frame_data *fdata)
1452 {
1453         if (set)
1454                 cf_mark_frame(&cfile, fdata);
1455         else
1456                 cf_unmark_frame(&cfile, fdata);
1457 }
1458
1459 void
1460 new_packet_list_mark_frame_cb(GtkWidget *w _U_, gpointer data _U_)
1461 {
1462         GtkTreeModel *model;
1463         GtkTreeSelection *selection;
1464         GtkTreeIter iter;
1465         frame_data *fdata;
1466
1467         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(packetlist->view));
1468         /* model is filled with the current model as a convenience. */
1469         if (!gtk_tree_selection_get_selected(selection, &model, &iter))
1470                 return;
1471
1472         fdata = new_packet_list_get_record(model, &iter);
1473
1474         set_frame_mark(!fdata->flags.marked, fdata);
1475         mark_frames_ready();
1476 }
1477
1478 static void
1479 mark_all_displayed_frames(gboolean set)
1480 {
1481         /* XXX: we might need a progressbar here */
1482         guint32 framenum;
1483         frame_data *fdata;
1484         for (framenum = 1; framenum <= cfile.count; framenum++) {
1485                 fdata = frame_data_sequence_find(cfile.frames, framenum);
1486                 if( fdata->flags.passed_dfilter )
1487                         set_frame_mark(set, fdata);
1488         }
1489 }
1490
1491 void
1492 new_packet_list_mark_all_displayed_frames_cb(GtkWidget *w _U_, gpointer data _U_)
1493 {
1494         mark_all_displayed_frames(TRUE);
1495         mark_frames_ready();
1496 }
1497
1498 void
1499 new_packet_list_unmark_all_displayed_frames_cb(GtkWidget *w _U_, gpointer data _U_)
1500 {
1501         mark_all_displayed_frames(FALSE);
1502         mark_frames_ready();
1503 }
1504
1505 static void
1506 toggle_mark_all_displayed_frames(void)
1507 {
1508         /* XXX: we might need a progressbar here */
1509         guint32 framenum;
1510         frame_data *fdata;
1511         for (framenum = 1; framenum <= cfile.count; framenum++) {
1512                 fdata = frame_data_sequence_find(cfile.frames, framenum);
1513                 if( fdata->flags.passed_dfilter )
1514                         set_frame_mark(!fdata->flags.marked, fdata);
1515         }
1516 }
1517
1518 void
1519 new_packet_list_toggle_mark_all_displayed_frames_cb(GtkWidget *w _U_, gpointer data _U_)
1520 {
1521         toggle_mark_all_displayed_frames();
1522         mark_frames_ready();
1523 }
1524
1525
1526 static void
1527 set_frame_ignore(gboolean set, frame_data *fdata)
1528 {
1529         if (set)
1530                 cf_ignore_frame(&cfile, fdata);
1531         else
1532                 cf_unignore_frame(&cfile, fdata);
1533 }
1534
1535 void
1536 new_packet_list_ignore_frame_cb(GtkWidget *w _U_, gpointer data _U_)
1537 {
1538         GtkTreeModel *model;
1539         GtkTreeSelection *selection;
1540         GtkTreeIter iter;
1541         frame_data *fdata;
1542
1543         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(packetlist->view));
1544         /* model is filled with the current model as a convenience. */
1545         if (!gtk_tree_selection_get_selected(selection, &model, &iter))
1546                 return;
1547
1548         fdata = new_packet_list_get_record(model, &iter);
1549         set_frame_ignore(!fdata->flags.ignored, fdata);
1550         redissect_packets();
1551 }
1552
1553 static void
1554 ignore_all_displayed_frames(gboolean set)
1555 {
1556         guint32 framenum;
1557         frame_data *fdata;
1558
1559         /* XXX: we might need a progressbar here */
1560         for (framenum = 1; framenum <= cfile.count; framenum++) {
1561                 fdata = frame_data_sequence_find(cfile.frames, framenum);
1562                 if( fdata->flags.passed_dfilter )
1563                         set_frame_ignore(set, fdata);
1564         }
1565         redissect_packets();
1566 }
1567
1568 void
1569 new_packet_list_ignore_all_displayed_frames_cb(GtkWidget *w _U_, gpointer data _U_)
1570 {
1571         if(cfile.displayed_count < cfile.count){
1572                 frame_data *fdata;
1573                 /* Due to performance impact with large captures, don't check the filtered list for
1574                 an ignored frame; just check the first. If a ignored frame exists but isn't first and
1575                 the user wants to unignore all the displayed frames, they will just re-exec the shortcut. */
1576                 fdata = frame_data_sequence_find(cfile.frames, cfile.first_displayed);
1577                 if (fdata->flags.ignored==TRUE) {
1578                         ignore_all_displayed_frames(FALSE);
1579                 } else {
1580                         ignore_all_displayed_frames(TRUE);
1581                 }
1582         }
1583 }
1584
1585 static void
1586 unignore_all_frames(void)
1587 {
1588         guint32 framenum;
1589         frame_data *fdata;
1590
1591         /* XXX: we might need a progressbar here */
1592         for (framenum = 1; framenum <= cfile.count; framenum++) {
1593                 fdata = frame_data_sequence_find(cfile.frames, framenum);
1594                 set_frame_ignore(FALSE, fdata);
1595         }
1596         redissect_packets();
1597 }
1598
1599 void
1600 new_packet_list_unignore_all_frames_cb(GtkWidget *w _U_, gpointer data _U_)
1601 {
1602         unignore_all_frames();
1603 }
1604
1605
1606 static void
1607 untime_reference_all_frames(void)
1608 {
1609         /* XXX: we might need a progressbar here */
1610         guint32 framenum;
1611         frame_data *fdata;
1612         for (framenum = 1; framenum <= cfile.count && cfile.ref_time_count > 0; framenum++) {
1613                 fdata = frame_data_sequence_find(cfile.frames, framenum);
1614                 if (fdata->flags.ref_time == 1) {
1615                         set_frame_reftime(FALSE, fdata, cfile.current_row);
1616                 }
1617         }
1618 }
1619
1620 void
1621 new_packet_list_untime_reference_all_frames_cb(GtkWidget *w _U_, gpointer data _U_)
1622 {
1623         untime_reference_all_frames();
1624 }
1625
1626
1627 guint
1628 new_packet_list_get_column_id (gint col_num)
1629 {
1630         GtkTreeViewColumn *column = gtk_tree_view_get_column (GTK_TREE_VIEW(packetlist->view), col_num);
1631         gint col_id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(column), E_MPACKET_LIST_COL_KEY));
1632
1633         return col_id;
1634 }
1635
1636 void
1637 new_packet_list_copy_summary_cb(gpointer data _U_, copy_summary_type copy_type)
1638 {
1639         gint col;
1640         gchar *celltext;
1641         GString* text;
1642         GtkTreeModel *model;
1643         GtkTreeSelection *selection;
1644         GtkTreeIter iter;
1645
1646         if(CS_CSV == copy_type) {
1647                 text = g_string_new("\"");
1648         } else {
1649                 text = g_string_new("");
1650         }
1651
1652         if (cfile.current_frame) {
1653                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(packetlist->view));
1654                 /* model is filled with the current model as a convenience.  */
1655                 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
1656                         return;
1657
1658                 for(col = 0; col < cfile.cinfo.num_cols; ++col) {
1659                         if(col != 0) {
1660                                 if(CS_CSV == copy_type) {
1661                                         g_string_append(text,"\",\"");
1662                                 } else {
1663                                         g_string_append_c(text, '\t');
1664                                 }
1665                         }
1666
1667                         gtk_tree_model_get(model, &iter, new_packet_list_get_column_id(col), &celltext, -1);
1668                         g_string_append(text,celltext);
1669                         g_free(celltext);
1670
1671                 }
1672                 if(CS_CSV == copy_type) {
1673                         g_string_append_c(text,'"');
1674                 }
1675                 copy_to_clipboard(text);
1676         }
1677         g_string_free(text,TRUE);
1678 }
1679
1680 gchar *
1681 new_packet_list_get_packet_comment(void)
1682 {
1683         GtkTreeModel *model;
1684         GtkTreeSelection *selection;
1685         GtkTreeIter iter;
1686         frame_data *fdata;
1687
1688         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(packetlist->view));
1689         /* model is filled with the current model as a convenience. */
1690         if (!gtk_tree_selection_get_selected(selection, &model, &iter))
1691                 return NULL;
1692
1693         fdata = new_packet_list_get_record(model, &iter);
1694
1695         return fdata->opt_comment;
1696 }
1697
1698 void
1699 new_packet_list_update_packet_comment(gchar *new_packet_comment)
1700 {
1701
1702         GtkTreeModel *model;
1703         GtkTreeSelection *selection;
1704         GtkTreeIter iter;
1705         frame_data *fdata;
1706
1707         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(packetlist->view));
1708         /* model is filled with the current model as a convenience. */
1709         if (!gtk_tree_selection_get_selected(selection, &model, &iter))
1710                 return;
1711
1712         fdata = new_packet_list_get_record(model, &iter);
1713
1714         /* Check if the comment has changed */
1715         if (fdata->opt_comment) {
1716                 if (strcmp(fdata->opt_comment, new_packet_comment) == 0) {
1717                         g_free(new_packet_comment);
1718                         return;
1719                 }
1720         }
1721
1722         /* Check if we are clearing the comment */
1723         if(strlen(new_packet_comment) == 0) {
1724                 g_free(new_packet_comment);
1725                 new_packet_comment = NULL;
1726         }
1727
1728         /* The comment has changed, let's update it */
1729         cf_update_packet_comment(&cfile, fdata, new_packet_comment);
1730
1731         /* Update the main window, as we now have unsaved changes. */
1732         main_update_for_unsaved_changes(&cfile);
1733
1734         new_packet_list_queue_draw();
1735
1736 }
1737
1738 void
1739 new_packet_list_recent_write_all(FILE *rf)
1740 {
1741         gint col, width, num_cols, col_fmt;
1742         GtkTreeViewColumn *tree_column;
1743         gchar xalign;
1744
1745         fprintf (rf, "%s:", RECENT_KEY_COL_WIDTH);
1746         num_cols = g_list_length(prefs.col_list);
1747         for (col = 0; col < num_cols; col++) {
1748                 col_fmt = get_column_format(col);
1749                 if (col_fmt == COL_CUSTOM) {
1750                         fprintf (rf, " %%Cus:%s,", get_column_custom_field(col));
1751                 } else {
1752                         fprintf (rf, " %s,", col_format_to_string(col_fmt));
1753                 }
1754                 tree_column = gtk_tree_view_get_column(GTK_TREE_VIEW(packetlist->view), col);
1755                 width = gtk_tree_view_column_get_width(tree_column);
1756                 xalign = recent_get_column_xalign (col);
1757                 if (width == 0) {
1758                         /* We have not initialized the packet list yet, use old values */
1759                         width = recent_get_column_width (col);
1760                 }
1761                 fprintf (rf, " %d", width);
1762                 if (xalign != COLUMN_XALIGN_DEFAULT) {
1763                         fprintf (rf, ":%c", xalign);
1764                 }
1765                 if (col != num_cols-1) {
1766                         fprintf (rf, ",");
1767                 }
1768         }
1769         fprintf (rf, "\n");
1770 }
1771
1772 GtkWidget *
1773 new_packet_list_get_widget(void)
1774 {
1775         g_assert(packetlist);
1776         g_assert(packetlist->view);
1777         return packetlist->view;
1778 }
1779
1780 void
1781 new_packet_list_colorize_packets(void)
1782 {
1783         packet_list_reset_colorized(packetlist);
1784         gtk_widget_queue_draw (packetlist->view);
1785 }