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