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