gtk/column_prefs.c

   1 /* column_prefs.c
   2  * Dialog box for column preferences
   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
  31 #include "globals.h"
  32 #include "column_prefs.h"
  33 #include "gtkglobals.h"
  34 #include <epan/prefs.h>
  35 #include <epan/column.h>
  36 #include "compat_macros.h"
  37 #include "gui_utils.h"
  38 #include "packet_list.h"
  39 #include "filter_dlg.h"
  40
  41 static GtkWidget *column_l, *del_bt, *title_te, *field_te, *fmt_m, *up_bt, *dn_bt;
  42 static gint       cur_fmt, cur_row;
  43
  44 static void   column_list_select_cb(GtkTreeSelection *, gpointer);
  45 static void   column_entry_changed_cb(GtkEditable *, gpointer);
  46 static void   column_field_changed_cb(GtkEditable *, gpointer);
  47 static void   column_list_new_cb(GtkWidget *, gpointer);
  48 static void   column_menu_changed_cb(GtkWidget *, gpointer);
  49 static void   column_list_delete_cb(GtkWidget *, gpointer);
  50 static void   column_arrow_cb(GtkWidget *, gpointer);
  51 void          column_set_arrow_button_sensitivity(GList *);
  52
  53 #define E_COL_NAME_KEY "column_name"
  54 #define E_COL_LBL_KEY  "column_label"
  55 #define E_COL_CM_KEY   "in_col_cancel_mode"
  56
  57 /* Create and display the column selection widgets. */
  58 /* Called when the 'Columns' preference notebook page is selected. */
  59 GtkWidget *
  60 column_prefs_show() {
  61   GtkWidget         *main_vb, *top_hb, *new_bt,
  62                     *tb, *lb, *menu, *mitem;
  63   GtkWidget         *order_fr, *order_vb, *order_lb;
  64   GtkWidget         *list_fr, *list_vb, *list_lb, *list_sc;
  65   GtkWidget         *edit_fr, *edit_vb;
  66   GtkWidget         *props_fr, *props_hb;
  67   GList             *clp = NULL;
  68   fmt_data          *cfmt;
  69   gint               i;
  70   gchar             *fmt;
  71   const gchar       *column_titles[] = {"Title", "Format"};
  72   GtkListStore      *store;
  73   GtkCellRenderer   *renderer;
  74   GtkTreeViewColumn *column;
  75   GtkTreeSelection  *sel;
  76   GtkTreeIter        iter;
  77   GtkTreeIter        first_iter;
  78   gint               first_row = TRUE;
  79
  80   /* Container for each row of widgets */
  81   main_vb = gtk_vbox_new(FALSE, 5);
  82   gtk_container_border_width(GTK_CONTAINER(main_vb), 5);
  83   gtk_widget_show(main_vb);
  84   g_object_set_data(G_OBJECT(GTK_OBJECT(main_vb)), E_COL_CM_KEY, (gpointer)FALSE);
  85
  86   /* Top row: Column list and buttons */
  87   top_hb = gtk_hbox_new(FALSE, 5);
  88   gtk_container_add(GTK_CONTAINER(main_vb), top_hb);
  89   gtk_widget_show(top_hb);
  90
  91
  92   /* edit frame */
  93   edit_fr = gtk_frame_new("Edit");
  94   gtk_box_pack_start (GTK_BOX (top_hb), edit_fr, FALSE, FALSE, 0);
  95   gtk_widget_show(edit_fr);
  96
  97   edit_vb = gtk_vbox_new (TRUE, 0);
  98   gtk_container_set_border_width  (GTK_CONTAINER (edit_vb), 5);
  99   gtk_container_add(GTK_CONTAINER(edit_fr), edit_vb);
 100   gtk_widget_show(edit_vb);
 101
 102   new_bt = gtk_button_new_from_stock(GTK_STOCK_NEW);
 103   g_signal_connect(new_bt, "clicked", G_CALLBACK(column_list_new_cb), NULL);
 104   gtk_box_pack_start (GTK_BOX (edit_vb), new_bt, FALSE, FALSE, 5);
 105   gtk_widget_show(new_bt);
 106
 107   del_bt = gtk_button_new_from_stock(GTK_STOCK_DELETE);
 108   gtk_widget_set_sensitive(del_bt, FALSE);
 109   g_signal_connect(del_bt, "clicked", G_CALLBACK(column_list_delete_cb), NULL);
 110   gtk_box_pack_start (GTK_BOX (edit_vb), del_bt, FALSE, FALSE, 5);
 111   gtk_widget_show(del_bt);
 112
 113
 114   /* columns list frame */
 115   list_fr = gtk_frame_new("Columns");
 116   gtk_box_pack_start (GTK_BOX (top_hb), list_fr, TRUE, TRUE, 0);
 117   gtk_widget_show(list_fr);
 118
 119   list_vb = gtk_vbox_new (FALSE, 0);
 120   gtk_container_set_border_width  (GTK_CONTAINER (list_vb), 5);
 121   gtk_widget_show (list_vb);
 122   gtk_container_add(GTK_CONTAINER(list_fr), list_vb);
 123
 124   list_lb = gtk_label_new (("[First list entry will be displayed left]"));
 125   gtk_widget_show (list_lb);
 126   gtk_box_pack_start (GTK_BOX (list_vb), list_lb, FALSE, FALSE, 0);
 127
 128   list_sc = scrolled_window_new(NULL, NULL);
 129   gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(list_sc),
 130                                    GTK_SHADOW_IN);
 131   gtk_container_add(GTK_CONTAINER(list_vb), list_sc);
 132   gtk_widget_show(list_sc);
 133
 134   store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
 135   column_l = tree_view_new(GTK_TREE_MODEL(store));
 136   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(column_l), TRUE);
 137   gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(column_l), FALSE);
 138   renderer = gtk_cell_renderer_text_new();
 139   column = gtk_tree_view_column_new_with_attributes(column_titles[0], renderer,
 140                                                     "text", 0, NULL);
 141   gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 142   gtk_tree_view_append_column(GTK_TREE_VIEW(column_l), column);
 143   renderer = gtk_cell_renderer_text_new();
 144   column = gtk_tree_view_column_new_with_attributes(column_titles[1], renderer,
 145                                                     "text", 1, NULL);
 146   gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 147   gtk_tree_view_append_column(GTK_TREE_VIEW(column_l), column);
 148   /* XXX - make this match the packet list prefs? */
 149   sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(column_l));
 150   gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
 151
 152   g_signal_connect(sel, "changed", G_CALLBACK(column_list_select_cb), NULL);
 153   gtk_container_add(GTK_CONTAINER(list_sc), column_l);
 154   gtk_widget_show(column_l);
 155
 156   clp = g_list_first(prefs.col_list);
 157   while (clp) {
 158     cfmt    = (fmt_data *) clp->data;
 159     cur_fmt = get_column_format_from_str(cfmt->fmt);
 160     if (cur_fmt == COL_CUSTOM) {
 161       fmt = g_strdup_printf("%s (%s)", col_format_desc(cur_fmt), cfmt->custom_field);
 162     } else {
 163       fmt = g_strdup_printf("%s", col_format_desc(cur_fmt));
 164     }
 165     gtk_list_store_append(store, &iter);
 166     gtk_list_store_set(store, &iter, 0, cfmt->title, 1, fmt, 2, clp, -1);
 167     if (first_row) {
 168         first_iter = iter;
 169         first_row = FALSE;
 170     }
 171     clp = clp->next;
 172     g_free (fmt);
 173   }
 174   g_object_unref(G_OBJECT(store));
 175
 176
 177   /* order frame */
 178   order_fr = gtk_frame_new("Order");
 179   gtk_box_pack_start (GTK_BOX (top_hb), order_fr, FALSE, FALSE, 0);
 180   gtk_widget_show(order_fr);
 181
 182   order_vb = gtk_vbox_new (TRUE, 0);
 183   gtk_container_add(GTK_CONTAINER(order_fr), order_vb);
 184   gtk_container_set_border_width  (GTK_CONTAINER (order_vb), 5);
 185   gtk_widget_show(order_vb);
 186
 187   up_bt = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
 188   gtk_widget_set_sensitive(up_bt, FALSE);
 189   g_signal_connect(up_bt, "clicked", G_CALLBACK(column_arrow_cb), NULL);
 190   gtk_box_pack_start(GTK_BOX(order_vb), up_bt, FALSE, FALSE, 0);
 191   gtk_widget_show(up_bt);
 192
 193   order_lb = gtk_label_new (("Move\nselected\ncolumn\nup or down"));
 194   gtk_widget_show (order_lb);
 195   gtk_box_pack_start (GTK_BOX (order_vb), order_lb, FALSE, FALSE, 0);
 196
 197   dn_bt = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
 198   gtk_widget_set_sensitive(dn_bt, FALSE);
 199   g_signal_connect(dn_bt, "clicked", G_CALLBACK(column_arrow_cb), NULL);
 200   gtk_box_pack_start(GTK_BOX(order_vb), dn_bt, FALSE, FALSE, 0);
 201   gtk_widget_show(dn_bt);
 202
 203
 204   /* properties frame */
 205   props_fr = gtk_frame_new("Properties");
 206   gtk_box_pack_start (GTK_BOX (main_vb), props_fr, FALSE, FALSE, 0);
 207   gtk_widget_show(props_fr);
 208
 209   /* Colunm name entry and format selection */
 210   tb = gtk_table_new(2, 3, FALSE);
 211   gtk_container_border_width(GTK_CONTAINER(tb), 5);
 212   gtk_container_add(GTK_CONTAINER(props_fr), tb);
 213   gtk_table_set_row_spacings(GTK_TABLE(tb), 10);
 214   gtk_table_set_col_spacings(GTK_TABLE(tb), 15);
 215   gtk_widget_show(tb);
 216
 217   lb = gtk_label_new("Title:");
 218   gtk_misc_set_alignment(GTK_MISC(lb), 1.0, 0.5);
 219   gtk_table_attach_defaults(GTK_TABLE(tb), lb, 0, 1, 0, 1);
 220   gtk_widget_show(lb);
 221
 222   title_te = gtk_entry_new();
 223   gtk_table_attach_defaults(GTK_TABLE(tb), title_te, 1, 3, 0, 1);
 224   gtk_widget_set_sensitive(title_te, FALSE);
 225   gtk_widget_show(title_te);
 226
 227   lb = gtk_label_new("Format:");
 228   gtk_misc_set_alignment(GTK_MISC(lb), 1.0, 0.5);
 229   gtk_table_attach_defaults(GTK_TABLE(tb), lb, 0, 1, 1, 2);
 230   gtk_widget_show(lb);
 231
 232   props_hb = gtk_hbox_new(FALSE, 5);
 233   gtk_table_attach(GTK_TABLE(tb), props_hb, 1, 2, 1, 2, GTK_FILL,
 234                    GTK_SHRINK, 0, 0);
 235   gtk_widget_show(props_hb);
 236
 237   field_te = gtk_entry_new();
 238   g_signal_connect(field_te, "changed", G_CALLBACK(filter_te_syntax_check_cb), NULL);
 239   gtk_table_attach_defaults(GTK_TABLE(tb), field_te, 2, 3, 1, 2);
 240   gtk_widget_set_sensitive(field_te, FALSE);
 241   gtk_widget_hide(field_te);
 242
 243   fmt_m = gtk_option_menu_new();
 244   menu  = gtk_menu_new();
 245   for (i = 0; i < NUM_COL_FMTS; i++) {
 246     mitem = gtk_menu_item_new_with_label(col_format_desc(i));
 247     gtk_menu_append(GTK_MENU(menu), mitem);
 248     g_signal_connect(mitem, "activate", G_CALLBACK(column_menu_changed_cb), GINT_TO_POINTER(i));
 249     gtk_widget_show(mitem);
 250   }
 251   gtk_option_menu_set_menu(GTK_OPTION_MENU(fmt_m), menu);
 252   cur_fmt = 0;
 253   gtk_option_menu_set_history(GTK_OPTION_MENU(fmt_m), cur_fmt);
 254   gtk_widget_set_sensitive(fmt_m, FALSE);
 255   gtk_box_pack_start(GTK_BOX(props_hb), fmt_m, FALSE, FALSE, 0);
 256   gtk_widget_show(fmt_m);
 257
 258   /* select the first row */
 259   gtk_tree_selection_select_iter(sel, &first_iter);
 260
 261   return(main_vb);
 262 }
 263
 264 /* For each selection, set the entry and option menu widgets to match
 265    the currently selected item.  Set the up/down button sensitivity.
 266    Draw focus to the entry widget. */
 267 static void
 268 column_list_select_cb(GtkTreeSelection *sel, gpointer  user_data _U_)
 269 {
 270     fmt_data     *cfmt;
 271     GList        *clp;
 272     GtkTreeModel *model;
 273     GtkTreeIter   iter;
 274     GtkTreePath  *path;
 275     gchar        *str_path;
 276
 277     /* if something was selected */
 278     if (gtk_tree_selection_get_selected(sel, &model, &iter))
 279     {
 280         gtk_tree_model_get(model, &iter, 2, &clp, -1);
 281         g_assert(clp != NULL);
 282         cfmt   = (fmt_data *) clp->data;
 283         cur_fmt = get_column_format_from_str(cfmt->fmt);
 284         g_assert(cur_fmt != -1);     /* It should always be valid */
 285
 286         path = gtk_tree_model_get_path(model, &iter);
 287         str_path = gtk_tree_path_to_string(path);
 288         cur_row = atoi(str_path);
 289         g_free(str_path);
 290         gtk_tree_path_free(path);
 291
 292         gtk_entry_set_text(GTK_ENTRY(title_te), cfmt->title);
 293         g_signal_connect(title_te, "changed", G_CALLBACK(column_entry_changed_cb), column_l);
 294
 295         if (cur_fmt == COL_CUSTOM) {
 296             gtk_entry_set_text(GTK_ENTRY(field_te), cfmt->custom_field);
 297             gtk_widget_show(field_te);
 298         } else {
 299             gtk_widget_hide(field_te);
 300         }
 301         g_signal_connect(field_te, "changed", G_CALLBACK(column_field_changed_cb), column_l);
 302
 303         gtk_editable_select_region(GTK_EDITABLE(title_te), 0, -1);
 304         gtk_widget_grab_focus(title_te);
 305
 306         gtk_option_menu_set_history(GTK_OPTION_MENU(fmt_m), cur_fmt);
 307
 308         gtk_widget_set_sensitive(del_bt, TRUE);
 309         gtk_widget_set_sensitive(title_te, TRUE);
 310         gtk_widget_set_sensitive(field_te, TRUE);
 311         gtk_widget_set_sensitive(fmt_m, TRUE);
 312         column_set_arrow_button_sensitivity(clp);
 313     }
 314     else
 315     {
 316         cur_row = -1;
 317         gtk_editable_delete_text(GTK_EDITABLE(title_te), 0, -1);
 318         gtk_editable_delete_text(GTK_EDITABLE(field_te), 0, -1);
 319
 320         gtk_widget_set_sensitive(del_bt, FALSE);
 321         gtk_widget_set_sensitive(title_te, FALSE);
 322         gtk_widget_set_sensitive(field_te, FALSE);
 323         gtk_widget_set_sensitive(fmt_m, FALSE);
 324         gtk_widget_set_sensitive(up_bt, FALSE);
 325         gtk_widget_set_sensitive(dn_bt, FALSE);
 326     }
 327 }
 328
 329 /* To do: add input checking to each of these callbacks */
 330
 331 static void
 332 column_list_new_cb(GtkWidget *w _U_, gpointer data _U_) {
 333     fmt_data     *cfmt;
 334     const gchar  *title = "New Column";
 335     GtkTreeModel *model;
 336     GtkTreeIter   iter;
 337     GtkTreePath  *path;
 338     gchar        *str_path;
 339
 340     cur_fmt        = COL_NUMBER;
 341     cfmt           = (fmt_data *) g_malloc(sizeof(fmt_data));
 342     cfmt->title    = g_strdup(title);
 343     cfmt->fmt      = g_strdup(col_format_to_string(cur_fmt));
 344     cfmt->custom_field = NULL;
 345     prefs.col_list = g_list_append(prefs.col_list, cfmt);
 346
 347     model = gtk_tree_view_get_model(GTK_TREE_VIEW(column_l));
 348     gtk_list_store_append(GTK_LIST_STORE(model), &iter);
 349     gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, title, 1,
 350                        col_format_desc(cur_fmt), 2, g_list_last(prefs.col_list),
 351                        -1);
 352
 353     path = gtk_tree_model_get_path(model, &iter);
 354     str_path = gtk_tree_path_to_string(path);
 355     cur_row = atoi(str_path);
 356     g_free(str_path);
 357     gtk_tree_path_free(path);
 358
 359     gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(column_l)),
 360                                    &iter);
 361     cfile.cinfo.columns_changed = TRUE;
 362 }
 363
 364 static void
 365 column_list_delete_cb(GtkWidget *w _U_, gpointer data _U_) {
 366     GList            *clp;
 367     fmt_data         *cfmt;
 368     GtkTreeSelection *sel;
 369     GtkTreeModel     *model;
 370     GtkTreeIter       iter;
 371
 372     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(column_l));
 373     if (gtk_tree_selection_get_selected(sel, &model, &iter))
 374     {
 375         gtk_tree_model_get(model, &iter, 2, &clp, -1);
 376
 377         cfmt = (fmt_data *) clp->data;
 378         g_free(cfmt->title);
 379         g_free(cfmt->fmt);
 380         if (cfmt->custom_field) {
 381           g_free (cfmt->custom_field);
 382         }
 383         g_free(cfmt);
 384         prefs.col_list = g_list_remove_link(prefs.col_list, clp);
 385
 386         gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
 387     }
 388     cfile.cinfo.columns_changed = TRUE;
 389 }
 390
 391 /* The user changed the column title entry box. */
 392 static void
 393 column_entry_changed_cb(GtkEditable *te, gpointer data) {
 394     fmt_data         *cfmt;
 395     GList            *clp;
 396     gchar            *title;
 397     GtkTreeView      *tree = (GtkTreeView *)data;
 398     GtkTreeSelection *sel;
 399     GtkTreeModel     *model;
 400     GtkTreeIter       iter;
 401
 402     sel = gtk_tree_view_get_selection(tree);
 403     if (gtk_tree_selection_get_selected(sel, &model, &iter))
 404     {
 405         title = gtk_editable_get_chars(te, 0, -1);
 406         gtk_tree_model_get(model, &iter, 2, &clp, -1);
 407         cfmt  = (fmt_data *) clp->data;
 408
 409         gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, title, -1);
 410         g_free(cfmt->title);
 411         cfmt->title = title;
 412     }
 413     cfile.cinfo.columns_changed = TRUE;
 414 }
 415
 416 /* The user changed the custom field entry box. */
 417 static void
 418 column_field_changed_cb(GtkEditable *te, gpointer data) {
 419     fmt_data         *cfmt;
 420     GList            *clp;
 421     gchar            *field, *fmt;
 422     GtkTreeView      *tree = (GtkTreeView *)data;
 423     GtkTreeSelection *sel;
 424     GtkTreeModel     *model;
 425     GtkTreeIter       iter;
 426
 427     sel = gtk_tree_view_get_selection(tree);
 428     if (gtk_tree_selection_get_selected(sel, &model, &iter))
 429     {
 430         field = gtk_editable_get_chars(te, 0, -1);
 431         gtk_tree_model_get(model, &iter, 2, &clp, -1);
 432         cfmt  = (fmt_data *) clp->data;
 433         fmt = g_strdup_printf("%s (%s)", col_format_desc(cur_fmt), field);
 434         gtk_list_store_set(GTK_LIST_STORE(model), &iter, 1, fmt, -1);
 435         g_free(fmt);
 436         if (cfmt->custom_field) {
 437           g_free(cfmt->custom_field);
 438         }
 439         cfmt->custom_field = field;
 440     }
 441     cfile.cinfo.columns_changed = TRUE;
 442 }
 443
 444 /* The user changed the format menu. */
 445 static void
 446 column_menu_changed_cb(GtkWidget *w _U_, gpointer data) {
 447     fmt_data         *cfmt;
 448     GList            *clp;
 449     const gchar      *fmt;
 450     GtkTreeSelection *sel;
 451     GtkTreeModel     *model;
 452     GtkTreeIter       iter;
 453
 454     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(column_l));
 455     if (gtk_tree_selection_get_selected(sel, &model, &iter))
 456     {
 457         cur_fmt = (gint)(long) data;
 458         gtk_tree_model_get(model, &iter, 2, &clp, -1);
 459         cfmt    = (fmt_data *) clp->data;
 460
 461         if (cur_fmt == COL_CUSTOM) {
 462           if (cfmt->custom_field == NULL) {
 463             cfmt->custom_field = g_strdup("");
 464           }
 465           gtk_entry_set_text(GTK_ENTRY(field_te), cfmt->custom_field);
 466           fmt = g_strdup_printf("%s (%s)", col_format_desc(cur_fmt), cfmt->custom_field);
 467           gtk_widget_show(field_te);
 468         } else {
 469           fmt = g_strdup_printf("%s", col_format_desc(cur_fmt));
 470           gtk_widget_hide(field_te);
 471         }
 472
 473         gtk_list_store_set(GTK_LIST_STORE(model), &iter, 1, fmt, -1);
 474         g_free(cfmt->fmt);
 475         cfmt->fmt = g_strdup(col_format_to_string(cur_fmt));
 476     }
 477     cfile.cinfo.columns_changed = TRUE;
 478 }
 479
 480 static void
 481 column_arrow_cb(GtkWidget *w, gpointer data _U_) {
 482     fmt_data         *cfmt;
 483     GList            *clp1, *clp2;
 484     GtkTreeSelection *sel;
 485     GtkTreeModel     *model;
 486     GtkTreeIter       iter1, iter2;
 487     GtkTreePath      *path;
 488     gchar            *title1, *format1, *title2, *format2;
 489
 490     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(column_l));
 491     if (gtk_tree_selection_get_selected(sel, &model, &iter1))
 492     {
 493         gtk_tree_model_get(model, &iter1, 0, &title1,
 494                            1, &format1, 2, &clp1, -1);
 495         cfmt = (fmt_data *)clp1->data;
 496         prefs.col_list = g_list_remove(prefs.col_list, cfmt);
 497
 498         if (w == up_bt)
 499         {
 500             cur_row--;
 501             prefs.col_list = g_list_insert(prefs.col_list, cfmt, cur_row);
 502             path = gtk_tree_model_get_path(model, &iter1);
 503             gtk_tree_path_prev(path);
 504             if (!gtk_tree_model_get_iter(model, &iter2, path))
 505             {
 506                 gtk_tree_path_free(path);
 507                 return;
 508             }
 509             gtk_tree_path_free(path);
 510         }
 511         else
 512         {
 513             cur_row++;
 514             prefs.col_list = g_list_insert(prefs.col_list, cfmt, cur_row);
 515             iter2 = iter1;
 516             if (!gtk_tree_model_iter_next(model, &iter2))
 517             {
 518                 return;
 519             }
 520         }
 521         clp1 = g_list_find(prefs.col_list, cfmt);
 522         gtk_tree_model_get(model, &iter2, 0, &title2, 1, &format2, 2,
 523                            &clp2, -1);
 524         gtk_list_store_set(GTK_LIST_STORE(model), &iter2, 0, title1, 1,
 525                            format1, 2, clp1, -1);
 526         gtk_list_store_set(GTK_LIST_STORE(model), &iter1, 0, title2, 1,
 527                            format2, 2, clp2, -1);
 528         gtk_tree_selection_select_iter(sel, &iter2);
 529
 530         column_set_arrow_button_sensitivity(clp1);
 531
 532         /* free strings read from the TreeModel */
 533         g_free(title1);
 534         g_free(format1);
 535         g_free(title2);
 536         g_free(format2);
 537     }
 538     cfile.cinfo.columns_changed = TRUE;
 539 }
 540
 541 void
 542 column_set_arrow_button_sensitivity(GList *clp) {
 543     gint up_sens = FALSE, dn_sens = FALSE;
 544
 545     if (clp != g_list_first(prefs.col_list))
 546         up_sens = TRUE;
 547     if (clp != g_list_last(prefs.col_list))
 548         dn_sens = TRUE;
 549
 550     gtk_widget_set_sensitive(up_bt, up_sens);
 551     gtk_widget_set_sensitive(dn_bt, dn_sens);
 552 }
 553
 554 void
 555 column_prefs_fetch(GtkWidget *w _U_) {
 556 }
 557
 558 void
 559 column_prefs_apply(GtkWidget *w _U_)
 560 {
 561     /* Redraw the packet list if the columns were changed */
 562     if(cfile.cinfo.columns_changed) {
 563         packet_list_recreate();
 564         cfile.cinfo.columns_changed = FALSE; /* Reset value */
 565     }
 566 }
 567
 568 void
 569 column_prefs_destroy(GtkWidget *w) {
 570     /* Let the list cb know we're about to destroy the widget tree, so it */
 571     /* doesn't operate on widgets that don't exist. */
 572     g_object_set_data(G_OBJECT(w), E_COL_CM_KEY, (gpointer)TRUE);
 573 }