"main_menu.[ch]" -> "menus.[ch]"; it handles not only the main menu, but
[obnox/wireshark/wip.git] / gtk / main_packet_list.c
1 /* main_packet_list.c
2  * packet list related functions   2002 Olivier Abad
3  *
4  * $Id$
5  *
6  * Wireshark - Network traffic analyzer
7  * By Gerald Combs <gerald@wireshark.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  */
24
25 #ifdef HAVE_CONFIG_H
26 # include "config.h"
27 #endif
28
29 #include <gtk/gtk.h>
30 #include <string.h>
31
32 #include <epan/epan.h>
33 #include <epan/column.h>
34 #include <epan/column_info.h>
35 #include <epan/prefs.h>
36 #include <epan/timestamp.h>
37
38 #include "../globals.h"
39 #include "../color.h"
40 #include "../color_filters.h"
41 #include "../ui_util.h"
42 #include "../progress_dlg.h"
43
44 #include "gtk/gtkglobals.h"
45 #include "gtk/gui_utils.h"
46 #include "gtk/color_utils.h"
47 #include "gtk/capture_file_dlg.h"
48 #include "gtk/keys.h"
49 #include "gtk/font_utils.h"
50 #include "gtk/packet_history.h"
51 #include "gtk/recent.h"
52 #include "gtk/main.h"
53 #include "gtk/menus.h"
54 #include "gtk/main_packet_list.h"
55 #include "gtk/main_statusbar.h"
56 #include "gtk/packet_win.h"
57
58 #include "image/clist_ascend.xpm"
59 #include "image/clist_descend.xpm"
60
61 #define N_PROGBAR_UPDATES 100
62
63 typedef struct column_arrows {
64   GtkWidget *table;
65   GtkWidget *ascend_pm;
66   GtkWidget *descend_pm;
67 } column_arrows;
68
69 GtkWidget *packet_list;
70 static gboolean last_at_end = FALSE;
71
72 /* GtkClist compare routine, overrides default to allow numeric comparison */
73
74 #define COMPARE_FRAME_NUM()     ((fdata1->num < fdata2->num) ? -1 : \
75                                  (fdata1->num > fdata2->num) ? 1 : \
76                                  0)
77
78 #define COMPARE_NUM(f)  ((fdata1->f < fdata2->f) ? -1 : \
79                          (fdata1->f > fdata2->f) ? 1 : \
80                          COMPARE_FRAME_NUM())
81
82 /* Compare time stamps.
83    A packet whose time is a reference time is considered to have
84    a lower time stamp than any frame with a non-reference time;
85    if both packets' times are reference times, we compare the
86    times of the packets. */
87 #define COMPARE_TS(ts) \
88                 ((fdata1->flags.ref_time && !fdata2->flags.ref_time) ? -1 : \
89                  (!fdata1->flags.ref_time && fdata2->flags.ref_time) ? 1 : \
90                  (fdata1->ts.secs < fdata2->ts.secs) ? -1 : \
91                  (fdata1->ts.secs > fdata2->ts.secs) ? 1 : \
92                  (fdata1->ts.nsecs < fdata2->ts.nsecs) ? -1 :\
93                  (fdata1->ts.nsecs > fdata2->ts.nsecs) ? 1 : \
94                  COMPARE_FRAME_NUM())
95 static gint
96 packet_list_compare(GtkCList *clist, gconstpointer  ptr1, gconstpointer  ptr2)
97 {
98   /* Get row data structures */
99   const GtkCListRow *row1 = (const GtkCListRow *)ptr1;
100   const GtkCListRow *row2 = (const GtkCListRow *)ptr2;
101
102   /* Get the frame data structures for the rows */
103   const frame_data *fdata1 = row1->data;
104   const frame_data *fdata2 = row2->data;
105
106   /* Get row text strings */
107   const char *text1 = GTK_CELL_TEXT (row1->cell[clist->sort_column])->text;
108   const char *text2 = GTK_CELL_TEXT (row2->cell[clist->sort_column])->text;
109
110   /* Attempt to convert to numbers */
111   double  num1;
112   double  num2;
113
114   /* For checking custom column type */
115   header_field_info *hfi;
116   gboolean custom_numeric = FALSE;
117
118   int ret;
119
120   gint  col_fmt = cfile.cinfo.col_fmt[clist->sort_column];
121
122   switch (col_fmt) {
123
124   case COL_NUMBER:
125     return COMPARE_FRAME_NUM();
126
127   case COL_CLS_TIME:
128     switch (timestamp_get_type()) {
129
130     case TS_ABSOLUTE:
131     case TS_ABSOLUTE_WITH_DATE:
132     case TS_EPOCH:
133       return COMPARE_TS(abs_ts);
134
135     case TS_RELATIVE:
136       return COMPARE_TS(rel_ts);
137
138     case TS_DELTA:
139       return COMPARE_TS(del_cap_ts);
140
141     case TS_DELTA_DIS:
142       return COMPARE_TS(del_dis_ts);
143
144     case TS_NOT_SET:
145       return 0;
146     }
147     return 0;
148
149   case COL_ABS_TIME:
150   case COL_ABS_DATE_TIME:
151     return COMPARE_TS(abs_ts);
152
153   case COL_REL_TIME:
154     return COMPARE_TS(rel_ts);
155
156   case COL_DELTA_TIME:
157     return COMPARE_TS(del_cap_ts);
158
159   case COL_DELTA_TIME_DIS:
160     return COMPARE_TS(del_dis_ts);
161
162   case COL_PACKET_LENGTH:
163     return COMPARE_NUM(pkt_len);
164
165   case COL_CUMULATIVE_BYTES:
166     return COMPARE_NUM(cum_bytes);
167
168   case COL_CUSTOM:
169     hfi = proto_registrar_get_byname(cfile.cinfo.col_custom_field[clist->sort_column]);
170     if (hfi == NULL) {
171         return COMPARE_FRAME_NUM();
172     } else if ((hfi->strings == NULL) &&
173                (((IS_FT_INT(hfi->type) || IS_FT_UINT(hfi->type)) &&
174                  ((hfi->display == BASE_DEC) || (hfi->display == BASE_DEC_HEX) ||
175                   (hfi->display == BASE_OCT))) ||
176                 (hfi->type == FT_DOUBLE) || (hfi->type == FT_FLOAT) ||
177                 (hfi->type == FT_BOOLEAN) || (hfi->type == FT_FRAMENUM) ||
178                 (hfi->type == FT_RELATIVE_TIME))) {
179       
180       /* Compare numeric column */
181       custom_numeric = TRUE;
182     }
183     /* FALLTHRU */
184   default:
185     num1 = atof(text1);
186     num2 = atof(text2);
187     if ((col_fmt == COL_UNRES_SRC_PORT) || (col_fmt == COL_UNRES_DST_PORT) ||
188         (custom_numeric) || 
189         ((num1 != 0) && (num2 != 0) && ((col_fmt == COL_DEF_SRC_PORT) ||
190                                         (col_fmt == COL_RES_SRC_PORT) || 
191                                         (col_fmt == COL_DEF_DST_PORT) ||
192                                         (col_fmt == COL_RES_DST_PORT)))) {
193
194       /* Compare numeric column */
195
196       if (num1 < num2)
197         return -1;
198       else if (num1 > num2)
199         return 1;
200       else
201         return COMPARE_FRAME_NUM();
202     }
203
204     else {
205
206       /* Compare text column */
207       if (!text2) {
208         if (text1)
209           return 1;
210         else
211           return COMPARE_FRAME_NUM();
212       }
213
214       if (!text1)
215         return -1;
216
217       ret = strcmp(text1, text2);
218       if (ret == 0)
219         return COMPARE_FRAME_NUM();
220       else
221         return ret;
222     }
223   }
224 }
225
226 /* What to do when a column is clicked */
227 static void
228 packet_list_click_column_cb(GtkCList *clist, gint column, gpointer data)
229 {
230   column_arrows *col_arrows = (column_arrows *) data;
231   int i;
232
233   gtk_clist_freeze(clist);
234
235   for (i = 0; i < cfile.cinfo.num_cols; i++) {
236     gtk_widget_hide(col_arrows[i].ascend_pm);
237     gtk_widget_hide(col_arrows[i].descend_pm);
238   }
239
240   if (column == clist->sort_column) {
241     if (clist->sort_type == GTK_SORT_ASCENDING) {
242       clist->sort_type = GTK_SORT_DESCENDING;
243       gtk_widget_show(col_arrows[column].descend_pm);
244     } else {
245       clist->sort_type = GTK_SORT_ASCENDING;
246       gtk_widget_show(col_arrows[column].ascend_pm);
247     }
248   }
249   else {
250     clist->sort_type = GTK_SORT_ASCENDING;
251     gtk_widget_show(col_arrows[column].ascend_pm);
252     gtk_clist_set_sort_column(clist, column);
253   }
254   gtk_clist_thaw(clist);
255
256   gtk_clist_sort(clist);
257 }
258
259 static void
260 packet_list_resize_column_cb(GtkCList *clist _U_, gint column, gint width, gpointer data _U_)
261 {
262   recent_set_column_width (column, width);
263 }
264
265 /* What to do when a list item is selected/unselected */
266 static void
267 packet_list_select_cb(GtkWidget *w _U_, gint row, gint col _U_, GdkEventButton *event _U_, gpointer evt _U_) 
268 {
269   frame_data *fdata;
270
271   /* Check if already selected */
272   if (cfile.current_frame && cfile.current_row == row)
273     return;
274
275   /* Remove the hex display tabbed pages */
276   while( (gtk_notebook_get_nth_page( GTK_NOTEBOOK(byte_nb_ptr), 0)))
277     gtk_notebook_remove_page( GTK_NOTEBOOK(byte_nb_ptr), 0);
278
279   cf_select_packet(&cfile, row);
280   gtk_widget_grab_focus(packet_list);
281
282   /* Lookup the frame number that corresponds to the list row number */
283   fdata = (frame_data *)packet_list_get_row_data(row);
284   if (fdata != NULL) {
285     packet_history_add(fdata->num);
286   }
287 }
288
289 static void
290 packet_list_unselect_cb(GtkWidget *w _U_, gint row _U_, gint col _U_, GdkEventButton *event _U_, gpointer evt _U_) 
291 {
292   cf_unselect_packet(&cfile);
293 }
294
295 /* mark packets */
296 static void
297 set_frame_mark(gboolean set, frame_data *frame, gint row)
298 {
299   GdkColor fg, bg;
300
301   if (row == -1)
302     return;
303   if (set) {
304     cf_mark_frame(&cfile, frame);
305     color_t_to_gdkcolor(&fg, &prefs.gui_marked_fg);
306     color_t_to_gdkcolor(&bg, &prefs.gui_marked_bg);
307     gtk_clist_set_foreground(GTK_CLIST(packet_list), row, &fg);
308     gtk_clist_set_background(GTK_CLIST(packet_list), row, &bg);
309   } else {
310     color_filter_t *cfilter = frame->color_filter;
311
312     cf_unmark_frame(&cfile, frame);
313     /* Restore the color from the matching color filter if any */
314     if (cfilter) { /* The packet matches a color filter */
315       color_t_to_gdkcolor(&fg, &cfilter->fg_color);
316       color_t_to_gdkcolor(&bg, &cfilter->bg_color);
317       gtk_clist_set_foreground(GTK_CLIST(packet_list), row, &fg);
318       gtk_clist_set_background(GTK_CLIST(packet_list), row, &bg);
319     } else { /* No color filter match */
320       gtk_clist_set_foreground(GTK_CLIST(packet_list), row, NULL);
321       gtk_clist_set_background(GTK_CLIST(packet_list), row, NULL);
322     }
323   }
324 }
325
326 /* call this after last set_frame_mark is done */
327 static void mark_frames_ready(void) 
328 {
329   file_save_update_dynamics();
330   packets_bar_update();
331 }
332
333 void packet_list_mark_frame_cb(GtkWidget *w _U_, gpointer data _U_) 
334 {
335   if (cfile.current_frame) {
336     set_frame_mark(!cfile.current_frame->flags.marked,
337                    cfile.current_frame, cfile.current_row);
338     mark_frames_ready();
339   }
340 }
341
342 static void mark_all_frames(gboolean set) 
343 {
344   frame_data *fdata;
345
346   /* XXX: we might need a progressbar here */
347   for (fdata = cfile.plist; fdata != NULL; fdata = fdata->next) {
348     set_frame_mark(set,
349                    fdata,
350                    gtk_clist_find_row_from_data(GTK_CLIST(packet_list), fdata));
351   }
352   mark_frames_ready();
353 }
354
355 void packet_list_update_marked_frames(void) 
356 {
357   frame_data *fdata;
358
359   if (cfile.plist == NULL) return;
360
361   /* XXX: we might need a progressbar here */
362   for (fdata = cfile.plist; fdata != NULL; fdata = fdata->next) {
363     if (fdata->flags.marked)
364       set_frame_mark(TRUE, fdata,
365                      gtk_clist_find_row_from_data(GTK_CLIST(packet_list),
366                                                   fdata));
367   }
368   mark_frames_ready();
369 }
370
371 void packet_list_mark_all_frames_cb(GtkWidget *w _U_, gpointer data _U_) 
372 {
373   mark_all_frames(TRUE);
374 }
375
376 void packet_list_unmark_all_frames_cb(GtkWidget *w _U_, gpointer data _U_) 
377 {
378   mark_all_frames(FALSE);
379 }
380
381 gboolean
382 packet_list_get_event_row_column(GtkWidget *w, GdkEventButton *event_button,
383                                  gint *row, gint *column)
384 {
385     return gtk_clist_get_selection_info(GTK_CLIST(w),
386                                  (gint) event_button->x, (gint) event_button->y,
387                                   row, column);
388 }
389
390 static gint
391 packet_list_button_pressed_cb(GtkWidget *w, GdkEvent *event, gpointer data _U_)
392 {
393     GdkEventButton *event_button = (GdkEventButton *)event;
394     gint row, column;
395
396     if (w == NULL || event == NULL)
397         return FALSE;
398
399     if (event->type == GDK_BUTTON_PRESS && event_button->button == 2 &&
400         event_button->window == GTK_CLIST(w)->clist_window &&
401         gtk_clist_get_selection_info(GTK_CLIST(w), (gint) event_button->x,
402                                      (gint) event_button->y, &row, &column)) {
403         frame_data *fdata = (frame_data *)gtk_clist_get_row_data(GTK_CLIST(w), row);
404         set_frame_mark(!fdata->flags.marked, fdata, row);
405         mark_frames_ready();
406         return TRUE;
407     }
408
409     if (event->type == GDK_2BUTTON_PRESS && event_button->button == 1 &&
410         event_button->window == GTK_CLIST(w)->clist_window ) {
411
412         new_window_cb(w);
413         return TRUE;
414     }
415
416     return FALSE;
417 }
418
419 /* Set the selection mode of the packet list window. */
420 void
421 packet_list_set_sel_browse(gboolean val, gboolean force_set)
422 {
423     GtkSelectionMode new_mode;
424     /* initialize with a mode we don't use, so that the mode == new_mode
425      * test will fail the first time */
426     static GtkSelectionMode mode = GTK_SELECTION_MULTIPLE;
427
428     /* Yeah, GTK uses "browse" in the case where we do not, but oh well. I
429      * think "browse" in Wireshark makes more sense than "SINGLE" in GTK+ */
430     new_mode = val ? GTK_SELECTION_SINGLE : GTK_SELECTION_BROWSE;
431
432     if ((mode == new_mode) && !force_set) {
433         /*
434          * The mode isn't changing, so don't do anything.
435          * In particular, don't gratuitiously unselect the
436          * current packet.
437          *
438          * XXX - why do we have to unselect the current packet
439          * ourselves?  The documentation for the GtkCList at
440          *
441          *      http://developer.gnome.org/doc/API/gtk/gtkclist.html
442          *
443          * says "Note that setting the widget's selection mode to
444          * one of GTK_SELECTION_BROWSE or GTK_SELECTION_SINGLE will
445          * cause all the items in the GtkCList to become deselected."
446          */
447       return;
448     }
449
450     if (cfile.finfo_selected)
451         cf_unselect_field(&cfile);
452
453     mode = new_mode;
454     gtk_clist_set_selection_mode(GTK_CLIST(packet_list), mode);
455 }
456
457 /* Set the font of the packet list window. */
458 void
459 packet_list_set_font(PangoFontDescription *font)
460 {
461     int i;
462     gint col_width;
463     PangoLayout *layout;
464
465     /* Manually set the font so it can be used right away in the
466      * pango_layout_get_pixel_size call below.  The gtk_widget_modify_font
467      * function only takes effect after the widget is displayed. */
468     packet_list->style->font_desc = pango_font_description_copy(font);
469
470     gtk_widget_modify_font(packet_list, font);
471
472     /* Compute default column sizes. */
473     for (i = 0; i < cfile.cinfo.num_cols; i++) {
474         col_width = recent_get_column_width(i);
475         if (col_width == -1) {
476             layout = gtk_widget_create_pango_layout(packet_list, get_column_width_string(get_column_format(i), i));
477             pango_layout_get_pixel_size(layout, &col_width, NULL);
478             g_object_unref(G_OBJECT(layout));
479         }
480         gtk_clist_set_column_width(GTK_CLIST(packet_list), i, col_width);
481     }
482 }
483
484 GtkWidget *
485 packet_list_new(e_prefs *prefs)
486 {
487     GtkWidget *pkt_scrollw;
488     header_field_info *hfi;
489     gboolean custom_right_justify;
490     int      i;
491
492     /* Packet list */
493     pkt_scrollw = scrolled_window_new(NULL, NULL);
494     /* The usual policy for scrolled windows is to set both scrollbars to automatic,
495      * meaning they'll only appear if the content doesn't fit into the window.
496      *
497      * As this doesn't seem to work in some cases for the vertical scrollbar
498      * (see http://bugs.wireshark.org/bugzilla/show_bug.cgi?id=220),
499      * we show that scrollbar always. */
500     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pkt_scrollw),
501                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
502     /* the gtk_clist will have it's own GTK_SHADOW_IN, so don't use a shadow
503      * for both widgets */
504     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(pkt_scrollw),
505                                     GTK_SHADOW_NONE);
506
507     packet_list = gtk_clist_new(cfile.cinfo.num_cols);
508     /* Column titles are filled in below */
509     gtk_container_add(GTK_CONTAINER(pkt_scrollw), packet_list);
510
511     packet_list_set_sel_browse(prefs->gui_plist_sel_browse, FALSE);
512     packet_list_set_font(user_font_get_regular());
513     gtk_widget_set_name(packet_list, "packet list");
514     g_signal_connect(packet_list, "select-row", G_CALLBACK(packet_list_select_cb), NULL);
515     g_signal_connect(packet_list, "unselect-row", G_CALLBACK(packet_list_unselect_cb), NULL);
516     for (i = 0; i < cfile.cinfo.num_cols; i++) {
517         /* For performance reasons, columns do not automatically resize,
518            but are resizeable by the user. */
519         gtk_clist_set_column_auto_resize(GTK_CLIST(packet_list), i, FALSE);
520         gtk_clist_set_column_resizeable(GTK_CLIST(packet_list), i, TRUE);
521
522         custom_right_justify = FALSE;
523         if (cfile.cinfo.col_fmt[i] == COL_CUSTOM) {
524           hfi = proto_registrar_get_byname(cfile.cinfo.col_custom_field[i]);
525           if ((hfi != NULL) && (hfi->strings == NULL) && 
526               ((hfi->type == FT_BOOLEAN) || (hfi->type == FT_FRAMENUM) ||
527                (((hfi->display == BASE_DEC) || (hfi->display == BASE_OCT)) &&
528                 (IS_FT_INT(hfi->type) || IS_FT_UINT(hfi->type)  || 
529                  (hfi->type == FT_INT64) || (hfi->type == FT_UINT64))))) {
530             custom_right_justify = TRUE;
531           }
532         }
533
534         /* Right-justify some special columns. */
535         if (cfile.cinfo.col_fmt[i] == COL_NUMBER ||
536             cfile.cinfo.col_fmt[i] == COL_PACKET_LENGTH ||
537             cfile.cinfo.col_fmt[i] == COL_CUMULATIVE_BYTES ||
538             cfile.cinfo.col_fmt[i] == COL_DCE_CALL ||
539             cfile.cinfo.col_fmt[i] == COL_DCE_CTX ||
540             custom_right_justify)
541             gtk_clist_set_column_justification(GTK_CLIST(packet_list), i,
542                                                GTK_JUSTIFY_RIGHT);
543     }
544     g_signal_connect(packet_list, "button_press_event", G_CALLBACK(popup_menu_handler),
545                    g_object_get_data(G_OBJECT(popup_menu_object), PM_PACKET_LIST_KEY));
546     g_signal_connect(packet_list, "button_press_event",
547                    G_CALLBACK(packet_list_button_pressed_cb), NULL);
548     g_object_set_data(G_OBJECT(popup_menu_object), E_MPACKET_LIST_KEY, packet_list);
549     gtk_clist_set_compare_func(GTK_CLIST(packet_list), packet_list_compare);
550     gtk_widget_show(packet_list);
551
552     return pkt_scrollw;
553 }
554
555 void
556 packet_list_recreate(void)
557 {
558     gtk_widget_destroy(pkt_scrollw);
559
560     prefs.num_cols = g_list_length(prefs.col_list);
561
562     build_column_format_array(&cfile.cinfo, FALSE);
563
564     pkt_scrollw = packet_list_new(&prefs);
565     gtk_widget_show(pkt_scrollw);
566     packet_list_set_column_titles();
567     packet_list_set_sel_browse(prefs.gui_plist_sel_browse, TRUE);
568
569     main_widgets_rearrange();
570
571     if(cfile.state != FILE_CLOSED)
572        redissect_packets();
573 }
574
575 void
576 packet_list_set_column_titles(void)
577 {
578     GtkStyle      *win_style;
579     GdkPixmap     *ascend_pm, *descend_pm;
580     GdkBitmap     *ascend_bm, *descend_bm;
581     column_arrows *col_arrows;
582     int            i;
583     GtkWidget     *column_lb;
584
585     win_style = gtk_widget_get_style(top_level);
586     ascend_pm = gdk_pixmap_create_from_xpm_d(top_level->window, &ascend_bm,
587                                              &win_style->bg[GTK_STATE_NORMAL],
588                                              (gchar **) clist_ascend_xpm);
589     descend_pm = gdk_pixmap_create_from_xpm_d(top_level->window, &descend_bm,
590                                               &win_style->bg[GTK_STATE_NORMAL],
591                                               (gchar **) clist_descend_xpm);
592
593     col_arrows = (column_arrows *) g_malloc(sizeof(column_arrows) *
594                                             cfile.cinfo.num_cols);
595     for (i = 0; i < cfile.cinfo.num_cols; i++) {
596         col_arrows[i].table = gtk_table_new(2, 2, FALSE);
597         gtk_table_set_col_spacings(GTK_TABLE(col_arrows[i].table), 5);
598         column_lb = gtk_label_new(cfile.cinfo.col_title[i]);
599         gtk_table_attach(GTK_TABLE(col_arrows[i].table), column_lb, 0, 1, 0, 2,
600                          GTK_SHRINK, GTK_SHRINK, 0, 0);
601         gtk_widget_show(column_lb);
602         col_arrows[i].ascend_pm = gtk_pixmap_new(ascend_pm, ascend_bm);
603         gtk_table_attach(GTK_TABLE(col_arrows[i].table),
604                          col_arrows[i].ascend_pm,
605                          1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
606         if (i == 0) {
607             gtk_widget_show(col_arrows[i].ascend_pm);
608         }
609         col_arrows[i].descend_pm = gtk_pixmap_new(descend_pm, descend_bm);
610         gtk_table_attach(GTK_TABLE(col_arrows[i].table),
611                          col_arrows[i].descend_pm,
612                          1, 2, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0);
613         gtk_clist_set_column_widget(GTK_CLIST(packet_list), i,
614                                     col_arrows[i].table);
615         gtk_widget_show(col_arrows[i].table);
616     }
617     gtk_clist_column_titles_show(GTK_CLIST(packet_list));
618     g_signal_connect(packet_list, "click-column", G_CALLBACK(packet_list_click_column_cb), col_arrows);
619     g_signal_connect(packet_list, "resize-column", G_CALLBACK(packet_list_resize_column_cb), NULL);
620 }
621
622 void
623 packet_list_clear(void)
624 {
625     packet_history_clear();
626
627     gtk_clist_clear(GTK_CLIST(packet_list));
628     gtk_widget_queue_draw(packet_list);
629 }
630
631 void
632 packet_list_freeze(void)
633 {
634     gtk_clist_freeze(GTK_CLIST(packet_list));
635 }
636
637 static void
638 packet_list_resize_columns(void) 
639 {
640     int         i;
641     int         progbar_nextstep;
642     int         progbar_quantum;
643     gboolean    progbar_stop_flag;
644     GTimeVal    progbar_start_time;
645     float       progbar_val;
646     progdlg_t  *progbar = NULL;
647     gchar       status_str[100];
648
649     /* Update the progress bar when it gets to this value. */
650     progbar_nextstep = 0;
651     /* When we reach the value that triggers a progress bar update,
652        bump that value by this amount. */
653     progbar_quantum = cfile.cinfo.num_cols/N_PROGBAR_UPDATES;
654     /* Progress so far. */
655     progbar_val = 0.0f;
656
657     progbar_stop_flag = FALSE;
658     g_get_current_time(&progbar_start_time);
659
660
661     main_window_update();
662
663     for (i = 0; i < cfile.cinfo.num_cols; i++) {
664       /* Create the progress bar if necessary.
665          We check on every iteration of the loop, so that it takes no
666          longer than the standard time to create it (otherwise, for a
667          large file, we might take considerably longer than that standard
668          time in order to get to the next progress bar step). */
669       if (progbar == NULL)
670          progbar = delayed_create_progress_dlg("Resizing", "Resize Columns",
671            TRUE, &progbar_stop_flag, &progbar_start_time, progbar_val);
672
673       if (i >= progbar_nextstep) {
674         /* let's not divide by zero. I should never be started
675          * with count == 0, so let's assert that
676          */
677         g_assert(cfile.cinfo.num_cols > 0);
678
679         progbar_val = (gfloat) i / cfile.cinfo.num_cols;
680
681         if (progbar != NULL) {
682           g_snprintf(status_str, sizeof(status_str),
683                      "%u of %u columns (%s)", i+1, cfile.cinfo.num_cols, cfile.cinfo.col_title[i]);
684           update_progress_dlg(progbar, progbar_val, status_str);
685         }
686
687         progbar_nextstep += progbar_quantum;
688       }
689
690       if (progbar_stop_flag) {
691         /* Well, the user decided to abort the resizing... */
692         break;
693       }
694
695       /* auto resize the current column */
696       gtk_clist_set_column_auto_resize(GTK_CLIST(packet_list), i, TRUE);
697
698       /* the current column should be resizeable by the user again */
699       /* (will turn off auto resize again) */
700       gtk_clist_set_column_resizeable(GTK_CLIST(packet_list), i, TRUE);
701     }
702
703     /* We're done resizing the columns; destroy the progress bar if it
704        was created. */
705     if (progbar != NULL)
706       destroy_progress_dlg(progbar);
707 }
708
709 void packet_list_resize_columns_cb(GtkWidget *widget _U_, gpointer data _U_)
710 {
711     packet_list_resize_columns();
712 }
713
714 void
715 packet_list_thaw(void)
716 {
717     gtk_clist_thaw(GTK_CLIST(packet_list));
718     packets_bar_update();
719     /*packet_list_resize_columns();*/
720 }
721
722 void
723 packet_list_select_row(gint row)
724 {
725     g_signal_emit_by_name(G_OBJECT(packet_list), "select_row", row);
726 }
727
728 static void
729 packet_list_next_prev(gboolean next)
730 {
731     GtkWidget *focus = gtk_window_get_focus(GTK_WINDOW(top_level));
732     g_signal_emit_by_name(G_OBJECT(packet_list), "scroll_vertical",
733         next ? GTK_SCROLL_STEP_FORWARD : GTK_SCROLL_STEP_BACKWARD, 0.0);
734     /* Set the focus back where it was */
735     if (focus)
736         gtk_window_set_focus(GTK_WINDOW(top_level), focus);
737 }
738
739 void
740 packet_list_next(void)
741 {
742     packet_list_next_prev(TRUE);
743 }
744
745 void
746 packet_list_prev(void)
747 {
748     packet_list_next_prev(FALSE);
749 }
750
751 void
752 packet_list_moveto_end(void)
753 {
754     gtk_clist_moveto(GTK_CLIST(packet_list),
755                      GTK_CLIST(packet_list)->rows - 1, -1, 1.0f, 1.0f);
756 }
757
758 gboolean
759 packet_list_check_end(void)
760 {
761     gboolean at_end = FALSE;
762     GtkAdjustment *adj;
763
764     g_return_val_if_fail (packet_list != NULL, FALSE);
765     adj = gtk_clist_get_vadjustment(GTK_CLIST(packet_list));
766     g_return_val_if_fail (adj != NULL, FALSE);
767
768     if (adj->value >= adj->upper - adj->page_size) {
769         at_end = TRUE;
770     }
771 #ifdef HAVE_LIBPCAP
772     if (adj->value > 0 && at_end != last_at_end && at_end != auto_scroll_live) {
773         menu_auto_scroll_live_changed(at_end);
774     }
775 #endif
776     last_at_end = at_end;
777     return at_end;
778 }
779
780 gint
781 packet_list_append(const gchar *text[], gpointer data)
782 {
783     gint row;
784
785     row = gtk_clist_append(GTK_CLIST(packet_list), (gchar **) text);
786     gtk_clist_set_row_data(GTK_CLIST(packet_list), row, data);
787     return row;
788 }
789
790 void
791 packet_list_set_colors(gint row, color_t *fg, color_t *bg)
792 {
793     GdkColor gdkfg, gdkbg;
794
795     if (fg)
796     {
797         color_t_to_gdkcolor(&gdkfg, fg);
798         gtk_clist_set_foreground(GTK_CLIST(packet_list), row, &gdkfg);
799     }
800     if (bg)
801     {
802         color_t_to_gdkcolor(&gdkbg, bg);
803         gtk_clist_set_background(GTK_CLIST(packet_list), row, &gdkbg);
804     }
805 }
806
807 gint
808 packet_list_find_row_from_data(gpointer data)
809 {
810     return gtk_clist_find_row_from_data(GTK_CLIST(packet_list), data);
811 }
812
813 void
814 packet_list_set_text(gint row, gint column, const gchar *text)
815 {
816     gtk_clist_set_text(GTK_CLIST(packet_list), row, column, text);
817 }
818
819 /* Set the column widths of those columns that show the time in
820  * "command-line-specified" format. */
821 void
822 packet_list_set_time_width(gint col_fmt, gint column)
823 {
824     gint      width = -1;
825     PangoLayout  *layout;
826
827     width = recent_get_column_width(column);
828     if (width == -1) {
829         layout = gtk_widget_create_pango_layout(packet_list,
830                      get_column_longest_string(col_fmt));
831         pango_layout_get_pixel_size(layout, &width, NULL);
832         g_object_unref(G_OBJECT(layout));
833     }
834     gtk_clist_set_column_width(GTK_CLIST(packet_list), column, width);
835 }
836
837 gpointer
838 packet_list_get_row_data(gint row)
839 {
840     return gtk_clist_get_row_data(GTK_CLIST(packet_list), row);
841 }
842
843
844 /* get the first fully visible row number, given row MUST be visible */
845 static gint
846 packet_list_first_full_visible_row(gint row) 
847 {
848         g_assert(gtk_clist_row_is_visible(GTK_CLIST(packet_list), row) == GTK_VISIBILITY_FULL);
849
850         while(gtk_clist_row_is_visible(GTK_CLIST(packet_list), row) == GTK_VISIBILITY_FULL) {
851                 row--;
852         }
853
854         return ++row;
855 }
856
857 /* get the last fully visible row number, given row MUST be visible */
858 static gint
859 packet_list_last_full_visible_row(gint row) 
860 {
861         g_assert(gtk_clist_row_is_visible(GTK_CLIST(packet_list), row) == GTK_VISIBILITY_FULL);
862
863         while(gtk_clist_row_is_visible(GTK_CLIST(packet_list), row) == GTK_VISIBILITY_FULL) {
864                 row++;
865         }
866
867         return --row;
868 }
869
870 /* Set the selected row and the focus row of the packet list to the specified
871  * row, and make it visible if it's not currently visible. */
872 void
873 packet_list_set_selected_row(gint row)
874 {
875     gint visible_rows;
876     gint first_row;
877     gboolean full_visible;
878
879     full_visible = gtk_clist_row_is_visible(GTK_CLIST(packet_list), row) ==  GTK_VISIBILITY_FULL;
880
881     /* XXX - why is there no "gtk_clist_set_focus_row()", so that we
882      * can make the row for the frame we found the focus row?
883      *
884      * See http://www.gnome.org/mailing-lists/archives/gtk-list/2000-January/0038.shtml
885      */
886     GTK_CLIST(packet_list)->focus_row = row;
887
888     gtk_clist_select_row(GTK_CLIST(packet_list), row, -1);
889
890     if (!full_visible) {
891         gtk_clist_freeze(GTK_CLIST(packet_list));
892
893         gtk_clist_moveto(GTK_CLIST(packet_list), row, -1, 0.0f, 0.0f);
894
895         /* even after move still invisible (happens with empty list) -> give up */
896         if(gtk_clist_row_is_visible(GTK_CLIST(packet_list), row) != GTK_VISIBILITY_FULL) {
897             gtk_clist_thaw(GTK_CLIST(packet_list));
898             return;
899         }
900
901         /* The now selected row will be the first visible row in the list.
902          * This is inconvenient, as the user is usually interested in some
903          * packets *before* the currently selected one too.
904          *
905          * Try to adjust the visible rows, so the currently selected row will
906          * be shown around the first third of the list screen.
907          *
908          * (This won't even do any harm if the current row is the first or the
909          * last in the list) */
910         visible_rows = packet_list_last_full_visible_row(row) - packet_list_first_full_visible_row(row);
911         first_row = row - visible_rows / 3;
912
913         gtk_clist_moveto(GTK_CLIST(packet_list), first_row >= 0 ? first_row : 0, -1, 0.0f, 0.0f);
914
915         gtk_clist_thaw(GTK_CLIST(packet_list));
916     }
917 }
918
919 /* Return the column number that the clist is currently sorted by */
920 gint
921 packet_list_get_sort_column(void)
922 {
923     return GTK_CLIST(packet_list)->sort_column;
924 }
925
926 void packet_list_copy_summary_cb(GtkWidget * w _U_, gpointer data _U_, copy_summary_type copy_type)
927 {
928     gint col;
929     gchar* celltext = NULL;
930     GString* text;
931
932     if(CS_CSV == copy_type) {
933         text = g_string_new("\"");
934     } else {
935         text = g_string_new("");
936     }
937
938     if (cfile.current_frame) {
939         for(col = 0; col < cfile.cinfo.num_cols; ++col) {
940             if(col != 0) {
941                 if(CS_CSV == copy_type) {
942                     g_string_append(text,"\",\"");
943                 } else {
944                     g_string_append_c(text, '\t');
945                 }
946             }
947             if(0 != gtk_clist_get_text(GTK_CLIST(packet_list),cfile.current_row,col,&celltext)) {
948                 g_string_append(text,celltext);
949             }
950         }
951         if(CS_CSV == copy_type) {
952             g_string_append_c(text,'"');
953         }
954         copy_to_clipboard(text);
955     }
956     g_string_free(text,TRUE);
957 }
958
959 /* Re-sort the clist by the previously selected sort */
960 void
961 packet_list_set_sort_column(void)
962 {
963     packet_list_freeze();
964
965     gtk_clist_set_sort_column(GTK_CLIST(packet_list), packet_list_get_sort_column());
966
967     gtk_clist_sort(GTK_CLIST(packet_list));
968
969     packet_list_thaw();
970 }
971
972 void
973 packet_list_recent_write_all(FILE *rf)
974 {
975   gint col;
976
977   fprintf (rf, "%s:", RECENT_KEY_COL_WIDTH);
978   for (col = 0; col < cfile.cinfo.num_cols; col++) {
979      if (cfile.cinfo.col_fmt[col] == COL_CUSTOM) {
980        fprintf (rf, " %%Cus:%s,", get_column_custom_field(col));
981      } else {
982        fprintf (rf, " %s,", col_format_to_string(cfile.cinfo.col_fmt[col]));
983      }
984      fprintf (rf, " %d", GTK_CLIST(packet_list)->column[col].width);
985      if (col != cfile.cinfo.num_cols-1) {
986        fprintf (rf, ",");
987      }
988    }
989    fprintf (rf, "\n");
990 }