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