src/prefs_display_header.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2001 Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include "defs.h"
  25
  26 #include <glib.h>
  27 #include <gtk/gtk.h>
  28 #include <gdk/gdkkeysyms.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <errno.h>
  33
  34 #include "intl.h"
  35 #include "prefs.h"
  36 #include "prefs_display_header.h"
  37 #include "prefs_common.h"
  38 #include "manage_window.h"
  39 #include "alertpanel.h"
  40 #include "displayheader.h"
  41 #include "utils.h"
  42 #include "gtkutils.h"
  43
  44 static struct DisplayHeader {
  45         GtkWidget *window;
  46
  47         GtkWidget *ok_btn;
  48         GtkWidget *cancel_btn;
  49
  50         GtkWidget *hdr_combo;
  51         GtkWidget *hdr_entry;
  52         GtkWidget *key_check;
  53         GtkWidget *headers_clist;
  54         GtkWidget *hidden_headers_clist;
  55
  56         GtkWidget *other_headers;
  57 } dispheader;
  58
  59 /* widget creating functions */
  60 static void prefs_display_header_create (void);
  61
  62 static void prefs_display_header_set_dialog     (void);
  63 static void prefs_display_header_set_list       (void);
  64 static gint prefs_display_header_clist_set_row  (gboolean hidden);
  65
  66 /* callback functions */
  67 static void prefs_display_header_register_cb    (GtkButton      *btn,
  68                                                  gpointer        hidden_data);
  69 static void prefs_display_header_delete_cb      (GtkButton      *btn,
  70                                                  gpointer        clist_data);
  71 static void prefs_display_header_up             (void);
  72 static void prefs_display_header_down           (void);
  73
  74 static void prefs_display_header_row_moved      (GtkCList       *clist,
  75                                                  gint            source_row,
  76                                                  gint            dest_row,
  77                                                  gpointer        data);
  78
  79 static void prefs_display_header_key_pressed    (GtkWidget      *widget,
  80                                                  GdkEventKey    *event,
  81                                                  gpointer        data);
  82 static void prefs_display_header_ok             (void);
  83 static void prefs_display_header_cancel         (void);
  84 static gint prefs_display_header_deleted        (GtkWidget      *widget,
  85                                                  GdkEventAny    *event,
  86                                                  gpointer        data);
  87
  88 static gchar *defaults[] =
  89 {
  90         "From",
  91         "To",
  92         "Cc",
  93         "Reply-To",
  94         "Newsgroups",
  95         "Followup-To",
  96         "Subject",
  97         "Date",
  98         "Sender",
  99         "Organization",
 100         "X-Mailer",
 101         "X-Newsreader",
 102         "User-Agent",
 103         "-Received",
 104         "-Message-Id",
 105         "-In-Reply-To",
 106         "-References",
 107         "-Mime-Version",
 108         "-Content-Type",
 109         "-Content-Transfer-Encoding",
 110         "-X-UIDL",
 111         "-Precedence",
 112         "-Status",
 113         "-Priority",
 114         "-X-Face"
 115 };
 116
 117 static void prefs_display_header_set_default(void)
 118 {
 119         gint i;
 120         DisplayHeaderProp *dp;
 121
 122         for(i = 0; i < sizeof(defaults) / sizeof(defaults[0]); i++) {
 123                 dp = display_header_prop_read_str(defaults[i]);
 124                 prefs_common.disphdr_list =
 125                         g_slist_append(prefs_common.disphdr_list, dp);
 126         }
 127 }
 128
 129 void prefs_display_header_open(void)
 130 {
 131         if (prefs_rc_is_readonly(DISPLAY_HEADER_RC))
 132                 return;
 133
 134         if (!dispheader.window) {
 135                 prefs_display_header_create();
 136         }
 137
 138         manage_window_set_transient(GTK_WINDOW(dispheader.window));
 139         gtk_widget_grab_focus(dispheader.ok_btn);
 140
 141         prefs_display_header_set_dialog();
 142
 143         gtk_widget_show(dispheader.window);
 144 }
 145
 146 static void prefs_display_header_create(void)
 147 {
 148         GtkWidget *window;
 149         GtkWidget *vbox;
 150         GtkWidget *btn_hbox;
 151         GtkWidget *ok_btn;
 152         GtkWidget *cancel_btn;
 153         GtkWidget *confirm_area;
 154
 155         GtkWidget *vbox1;
 156
 157         GtkWidget *hbox1;
 158         GtkWidget *hdr_label;
 159         GtkWidget *hdr_combo;
 160
 161         GtkWidget *btn_vbox;
 162         GtkWidget *reg_btn;
 163         GtkWidget *del_btn;
 164         GtkWidget *up_btn;
 165         GtkWidget *down_btn;
 166
 167         GtkWidget *clist_hbox;
 168         GtkWidget *clist_hbox1;
 169         GtkWidget *clist_hbox2;
 170         GtkWidget *clist_scrolledwin;
 171         GtkWidget *headers_clist;
 172         GtkWidget *hidden_headers_clist;
 173
 174         GtkWidget *checkbtn_other_headers;
 175
 176         gchar *title[1];
 177
 178         debug_print(_("Creating display header setting window...\n"));
 179
 180         window = gtk_window_new (GTK_WINDOW_DIALOG);
 181         gtk_container_set_border_width (GTK_CONTAINER (window), 8);
 182         gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
 183         gtk_window_set_modal (GTK_WINDOW (window), TRUE);
 184         gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, FALSE);
 185
 186         vbox = gtk_vbox_new (FALSE, 6);
 187         gtk_widget_show (vbox);
 188         gtk_container_add (GTK_CONTAINER (window), vbox);
 189
 190         btn_hbox = gtk_hbox_new (FALSE, 8);
 191         gtk_widget_show (btn_hbox);
 192         gtk_box_pack_end (GTK_BOX (vbox), btn_hbox, FALSE, FALSE, 0);
 193
 194         gtkut_button_set_create(&confirm_area, &ok_btn, _("OK"),
 195                                 &cancel_btn, _("Cancel"), NULL, NULL);
 196         gtk_widget_show (confirm_area);
 197         gtk_box_pack_end (GTK_BOX(btn_hbox), confirm_area, FALSE, FALSE, 0);
 198         gtk_widget_grab_default (ok_btn);
 199
 200         gtk_window_set_title (GTK_WINDOW(window),
 201                               _("Display header setting"));
 202         gtk_signal_connect (GTK_OBJECT(window), "focus_in_event",
 203                             GTK_SIGNAL_FUNC(manage_window_focus_in), NULL);
 204         gtk_signal_connect (GTK_OBJECT(window), "focus_out_event",
 205                             GTK_SIGNAL_FUNC(manage_window_focus_out), NULL);
 206         gtk_signal_connect (GTK_OBJECT(window), "delete_event",
 207                             GTK_SIGNAL_FUNC(prefs_display_header_deleted),
 208                             NULL);
 209         gtk_signal_connect (GTK_OBJECT(window), "key_press_event",
 210                             GTK_SIGNAL_FUNC(prefs_display_header_key_pressed),
 211                             NULL);
 212         gtk_signal_connect (GTK_OBJECT(ok_btn), "clicked",
 213                             GTK_SIGNAL_FUNC(prefs_display_header_ok),
 214                             NULL);
 215         gtk_signal_connect (GTK_OBJECT(cancel_btn), "clicked",
 216                             GTK_SIGNAL_FUNC(prefs_display_header_cancel),
 217                             NULL);
 218
 219         vbox1 = gtk_vbox_new (FALSE, VSPACING);
 220         gtk_widget_show (vbox1);
 221         gtk_box_pack_start (GTK_BOX (vbox), vbox1, TRUE, TRUE, 0);
 222         gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);
 223
 224         hbox1 = gtk_hbox_new (FALSE, 8);
 225         gtk_widget_show (hbox1);
 226         gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, TRUE, 0);
 227
 228         hdr_label = gtk_label_new (_("Header name"));
 229         gtk_widget_show (hdr_label);
 230         gtk_box_pack_start (GTK_BOX (hbox1), hdr_label, FALSE, FALSE, 0);
 231
 232         hdr_combo = gtk_combo_new ();
 233         gtk_widget_show (hdr_combo);
 234         gtk_box_pack_start (GTK_BOX (hbox1), hdr_combo, TRUE, TRUE, 0);
 235         gtk_widget_set_usize (hdr_combo, 150, -1);
 236         gtkut_combo_set_items (GTK_COMBO (hdr_combo),
 237                                "From", "To", "Cc", "Subject", "Date",
 238                                "Reply-To", "Sender", "User-Agent", "X-Mailer",
 239                                NULL);
 240
 241         clist_hbox = gtk_hbox_new (FALSE, 10);
 242         gtk_widget_show (clist_hbox);
 243         gtk_box_pack_start (GTK_BOX (vbox1), clist_hbox, TRUE, TRUE, 0);
 244
 245         /* display headers list */
 246
 247         clist_hbox1 = gtk_hbox_new (FALSE, 8);
 248         gtk_widget_show (clist_hbox1);
 249         gtk_box_pack_start (GTK_BOX (clist_hbox), clist_hbox1, TRUE, TRUE, 0);
 250
 251         clist_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
 252         gtk_widget_set_usize (clist_scrolledwin, 200, 210);
 253         gtk_widget_show (clist_scrolledwin);
 254         gtk_box_pack_start (GTK_BOX (clist_hbox1), clist_scrolledwin,
 255                             TRUE, TRUE, 0);
 256         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (clist_scrolledwin),
 257                                         GTK_POLICY_AUTOMATIC,
 258                                         GTK_POLICY_AUTOMATIC);
 259
 260         title[0] = _("Displayed Headers");
 261         headers_clist = gtk_clist_new_with_titles(1, title);
 262         gtk_widget_show (headers_clist);
 263         gtk_container_add (GTK_CONTAINER (clist_scrolledwin), headers_clist);
 264         gtk_clist_set_selection_mode (GTK_CLIST (headers_clist),
 265                                       GTK_SELECTION_BROWSE);
 266         gtk_clist_set_reorderable (GTK_CLIST (headers_clist), TRUE);
 267         gtk_clist_set_use_drag_icons (GTK_CLIST (headers_clist), FALSE);
 268         GTK_WIDGET_UNSET_FLAGS (GTK_CLIST (headers_clist)->column[0].button,
 269                                 GTK_CAN_FOCUS);
 270         gtk_signal_connect_after
 271                 (GTK_OBJECT (headers_clist), "row_move",
 272                  GTK_SIGNAL_FUNC (prefs_display_header_row_moved), NULL);
 273
 274         btn_vbox = gtk_vbox_new (FALSE, 8);
 275         gtk_widget_show (btn_vbox);
 276         gtk_box_pack_start (GTK_BOX (clist_hbox1), btn_vbox, FALSE, FALSE, 0);
 277
 278         reg_btn = gtk_button_new_with_label (_("Add"));
 279         gtk_widget_show (reg_btn);
 280         gtk_box_pack_start (GTK_BOX (btn_vbox), reg_btn, FALSE, TRUE, 0);
 281         gtk_signal_connect (GTK_OBJECT (reg_btn), "clicked",
 282                             GTK_SIGNAL_FUNC (prefs_display_header_register_cb),
 283                             FALSE);
 284         del_btn = gtk_button_new_with_label (_("Delete"));
 285         gtk_widget_show (del_btn);
 286         gtk_box_pack_start (GTK_BOX (btn_vbox), del_btn, FALSE, TRUE, 0);
 287         gtk_signal_connect (GTK_OBJECT (del_btn), "clicked",
 288                             GTK_SIGNAL_FUNC (prefs_display_header_delete_cb),
 289                             headers_clist);
 290
 291         up_btn = gtk_button_new_with_label (_("Up"));
 292         gtk_widget_show (up_btn);
 293         gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0);
 294         gtk_signal_connect (GTK_OBJECT (up_btn), "clicked",
 295                             GTK_SIGNAL_FUNC (prefs_display_header_up), NULL);
 296
 297         down_btn = gtk_button_new_with_label (_("Down"));
 298         gtk_widget_show (down_btn);
 299         gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0);
 300         gtk_signal_connect (GTK_OBJECT (down_btn), "clicked",
 301                             GTK_SIGNAL_FUNC (prefs_display_header_down), NULL);
 302
 303         /* hidden headers list */
 304
 305         clist_hbox2 = gtk_hbox_new (FALSE, 8);
 306         gtk_widget_show (clist_hbox2);
 307         gtk_box_pack_start (GTK_BOX (clist_hbox), clist_hbox2, TRUE, TRUE, 0);
 308
 309         clist_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
 310         gtk_widget_set_usize (clist_scrolledwin, 200, 210);
 311         gtk_widget_show (clist_scrolledwin);
 312         gtk_box_pack_start (GTK_BOX (clist_hbox2), clist_scrolledwin,
 313                             TRUE, TRUE, 0);
 314         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (clist_scrolledwin),
 315                                         GTK_POLICY_AUTOMATIC,
 316                                         GTK_POLICY_AUTOMATIC);
 317
 318         title[0] = _("Hidden headers");
 319         hidden_headers_clist = gtk_clist_new_with_titles(1, title);
 320         gtk_widget_show (hidden_headers_clist);
 321         gtk_container_add (GTK_CONTAINER (clist_scrolledwin),
 322                            hidden_headers_clist);
 323         gtk_clist_set_selection_mode (GTK_CLIST (hidden_headers_clist),
 324                                       GTK_SELECTION_BROWSE);
 325         gtk_clist_set_auto_sort(GTK_CLIST (hidden_headers_clist), TRUE);
 326         GTK_WIDGET_UNSET_FLAGS (GTK_CLIST (hidden_headers_clist)->
 327                                 column[0].button, GTK_CAN_FOCUS);
 328
 329         btn_vbox = gtk_vbox_new (FALSE, 8);
 330         gtk_widget_show (btn_vbox);
 331         gtk_box_pack_start (GTK_BOX (clist_hbox2), btn_vbox, FALSE, FALSE, 0);
 332
 333         reg_btn = gtk_button_new_with_label (_("Add"));
 334         gtk_widget_show (reg_btn);
 335         gtk_box_pack_start (GTK_BOX (btn_vbox), reg_btn, FALSE, TRUE, 0);
 336         gtk_signal_connect (GTK_OBJECT (reg_btn), "clicked",
 337                             GTK_SIGNAL_FUNC
 338                             (prefs_display_header_register_cb),
 339                             (void *) TRUE);
 340         del_btn = gtk_button_new_with_label (_("Delete"));
 341         gtk_widget_show (del_btn);
 342         gtk_box_pack_start (GTK_BOX (btn_vbox), del_btn, FALSE, TRUE, 0);
 343         gtk_signal_connect (GTK_OBJECT (del_btn), "clicked",
 344                             GTK_SIGNAL_FUNC (prefs_display_header_delete_cb),
 345                             (void *) hidden_headers_clist);
 346
 347         PACK_CHECK_BUTTON (btn_hbox, checkbtn_other_headers,
 348                            _("Show all unspecified headers"));
 349         SET_TOGGLE_SENSITIVITY (checkbtn_other_headers, clist_hbox2);
 350
 351         gtk_widget_show_all(window);
 352
 353         dispheader.window        = window;
 354         dispheader.ok_btn        = ok_btn;
 355         dispheader.cancel_btn    = cancel_btn;
 356
 357         dispheader.hdr_combo     = hdr_combo;
 358         dispheader.hdr_entry     = GTK_COMBO (hdr_combo)->entry;
 359
 360         dispheader.headers_clist        = headers_clist;
 361         dispheader.hidden_headers_clist = hidden_headers_clist;
 362
 363         dispheader.other_headers = checkbtn_other_headers;
 364 }
 365
 366 void prefs_display_header_read_config(void)
 367 {
 368         gchar *rcpath;
 369         FILE *fp;
 370         gchar buf[PREFSBUFSIZE];
 371         DisplayHeaderProp *dp;
 372
 373         debug_print(_("Reading configuration for displaying headers...\n"));
 374
 375         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
 376                              DISPLAY_HEADER_RC, NULL);
 377         if ((fp = fopen(rcpath, "r")) == NULL) {
 378                 if (ENOENT != errno) FILE_OP_ERROR(rcpath, "fopen");
 379                 g_free(rcpath);
 380                 prefs_common.disphdr_list = NULL;
 381                 prefs_display_header_set_default();
 382                 return;
 383         }
 384         g_free(rcpath);
 385
 386         /* remove all previous headers list */
 387         while (prefs_common.disphdr_list != NULL) {
 388                 dp = (DisplayHeaderProp *)prefs_common.disphdr_list->data;
 389                 display_header_prop_free(dp);
 390                 prefs_common.disphdr_list =
 391                         g_slist_remove(prefs_common.disphdr_list, dp);
 392         }
 393
 394         while (fgets(buf, sizeof(buf), fp) != NULL) {
 395                 g_strdelimit(buf, "\r\n", '\0');
 396                 dp = display_header_prop_read_str(buf);
 397                 if (dp)
 398                         prefs_common.disphdr_list =
 399                                 g_slist_append(prefs_common.disphdr_list, dp);
 400         }
 401
 402         fclose(fp);
 403 }
 404
 405 void prefs_display_header_write_config(void)
 406 {
 407         gchar *rcpath;
 408         PrefFile *pfile;
 409         GSList *cur;
 410
 411         debug_print(_("Writing configuration for displaying headers...\n"));
 412
 413         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
 414                              DISPLAY_HEADER_RC, NULL);
 415
 416         if ((pfile = prefs_write_open(rcpath)) == NULL) {
 417                 g_warning(_("failed to write configuration to file\n"));
 418                 g_free(rcpath);
 419                 return;
 420         }
 421
 422         for (cur = prefs_common.disphdr_list; cur != NULL;
 423              cur = cur->next) {
 424                 DisplayHeaderProp *dp = (DisplayHeaderProp *)cur->data;
 425                 gchar *dpstr;
 426
 427                 dpstr = display_header_prop_get_str(dp);
 428                 if (fputs(dpstr, pfile->fp) == EOF ||
 429                     fputc('\n', pfile->fp) == EOF) {
 430                         FILE_OP_ERROR(rcpath, "fputs || fputc");
 431                         prefs_write_close_revert(pfile);
 432                         g_free(rcpath);
 433                         g_free(dpstr);
 434                         return;
 435                 }
 436                 g_free(dpstr);
 437         }
 438
 439         g_free(rcpath);
 440
 441         if (prefs_write_close(pfile) < 0) {
 442                 g_warning(_("failed to write configuration to file\n"));
 443                 return;
 444         }
 445 }
 446
 447 static void prefs_display_header_set_dialog(void)
 448 {
 449         GtkCList *clist = GTK_CLIST(dispheader.headers_clist);
 450         GtkCList *hidden_clist = GTK_CLIST(dispheader.hidden_headers_clist);
 451         GSList *cur;
 452         gchar *dp_str[1];
 453         gint row;
 454
 455         gtk_clist_freeze(clist);
 456         gtk_clist_freeze(hidden_clist);
 457
 458         gtk_clist_clear(clist);
 459         gtk_clist_clear(hidden_clist);
 460
 461         for (cur = prefs_common.disphdr_list; cur != NULL;
 462              cur = cur->next) {
 463                 DisplayHeaderProp *dp = (DisplayHeaderProp *)cur->data;
 464
 465                 dp_str[0] = dp->name;
 466
 467                 if (dp->hidden) {
 468                         row = gtk_clist_append(hidden_clist, dp_str);
 469                         gtk_clist_set_row_data(hidden_clist, row, dp);
 470                 } else {
 471                         row = gtk_clist_append(clist, dp_str);
 472                         gtk_clist_set_row_data(clist, row, dp);
 473                 }
 474         }
 475
 476         gtk_clist_thaw(hidden_clist);
 477         gtk_clist_thaw(clist);
 478
 479         gtk_toggle_button_set_active
 480                 (GTK_TOGGLE_BUTTON(dispheader.other_headers),
 481                  prefs_common.show_other_header);
 482 }
 483
 484 static void prefs_display_header_set_list()
 485 {
 486         gint row = 0;
 487         DisplayHeaderProp *dp;
 488
 489         g_slist_free(prefs_common.disphdr_list);
 490         prefs_common.disphdr_list = NULL;
 491
 492         while ((dp = gtk_clist_get_row_data
 493                 (GTK_CLIST(dispheader.headers_clist), row)) != NULL) {
 494                 prefs_common.disphdr_list =
 495                         g_slist_append(prefs_common.disphdr_list, dp);
 496                 row++;
 497         }
 498
 499         row = 0;
 500         while ((dp = gtk_clist_get_row_data
 501                 (GTK_CLIST(dispheader.hidden_headers_clist), row)) != NULL) {
 502                 prefs_common.disphdr_list =
 503                         g_slist_append(prefs_common.disphdr_list, dp);
 504                 row++;
 505         }
 506 }
 507
 508 static gint prefs_display_header_find_header(GtkCList *clist,
 509                                              const gchar *header)
 510 {
 511         gint row = 0;
 512         DisplayHeaderProp *dp;
 513
 514         while ((dp = gtk_clist_get_row_data(clist, row)) != NULL) {
 515                 if (g_strcasecmp(dp->name, header) == 0)
 516                         return row;
 517                 row++;
 518         }
 519
 520         return -1;
 521 }
 522
 523 static gint prefs_display_header_clist_set_row(gboolean hidden)
 524 {
 525         GtkCList *clist;
 526         DisplayHeaderProp *dp;
 527         gchar *entry_text;
 528         gchar *dp_str[1];
 529         gint row;
 530
 531         entry_text = gtk_entry_get_text(GTK_ENTRY(dispheader.hdr_entry));
 532         if (entry_text[0] == '\0') {
 533                 alertpanel_error(_("Header name is not set."));
 534                 return -1;
 535         }
 536
 537         if (hidden)
 538                 clist = GTK_CLIST(dispheader.hidden_headers_clist);
 539         else
 540                 clist = GTK_CLIST(dispheader.headers_clist);
 541
 542         if (prefs_display_header_find_header(clist, entry_text) != -1) {
 543                 alertpanel_error(_("This header is already in the list."));
 544                 return -1;
 545         }
 546
 547         dp = g_new0(DisplayHeaderProp, 1);
 548
 549         dp->name = g_strdup(entry_text);
 550         dp->hidden = hidden;
 551
 552         dp_str[0] = dp->name;
 553         row = gtk_clist_append(clist, dp_str);
 554         gtk_clist_set_row_data(clist, row, dp);
 555
 556         prefs_display_header_set_list();
 557
 558         return row;
 559 }
 560
 561 static void prefs_display_header_register_cb(GtkButton *btn,
 562                                              gpointer hidden_data)
 563 {
 564         gboolean hidden = (gboolean)hidden_data;
 565
 566         prefs_display_header_clist_set_row(hidden);
 567 }
 568
 569 static void prefs_display_header_delete_cb(GtkButton *btn, gpointer clist_data)
 570 {
 571         GtkCList *clist = GTK_CLIST(clist_data);
 572         DisplayHeaderProp *dp;
 573         gint row;
 574
 575         if (!clist->selection) return;
 576         row = GPOINTER_TO_INT(clist->selection->data);
 577
 578         dp = gtk_clist_get_row_data(clist, row);
 579         display_header_prop_free(dp);
 580         gtk_clist_remove(clist, row);
 581         prefs_common.disphdr_list =
 582                 g_slist_remove(prefs_common.disphdr_list, dp);
 583 }
 584
 585 static void prefs_display_header_up(void)
 586 {
 587         GtkCList *clist = GTK_CLIST(dispheader.headers_clist);
 588         gint row;
 589
 590         if (!clist->selection) return;
 591
 592         row = GPOINTER_TO_INT(clist->selection->data);
 593         if (row > 0)
 594                 gtk_clist_row_move(clist, row, row - 1);
 595 }
 596
 597 static void prefs_display_header_down(void)
 598 {
 599         GtkCList *clist = GTK_CLIST(dispheader.headers_clist);
 600         gint row;
 601
 602         if (!clist->selection) return;
 603
 604         row = GPOINTER_TO_INT(clist->selection->data);
 605         if (row >= 0 && row < clist->rows - 1)
 606                 gtk_clist_row_move(clist, row, row + 1);
 607 }
 608
 609 static void prefs_display_header_row_moved(GtkCList *clist, gint source_row,
 610                                            gint dest_row, gpointer data)
 611 {
 612         prefs_display_header_set_list();
 613 }
 614
 615 static void prefs_display_header_key_pressed(GtkWidget *widget,
 616                                              GdkEventKey *event,
 617                                              gpointer data)
 618 {
 619         if (event && event->keyval == GDK_Escape)
 620                 prefs_display_header_cancel();
 621 }
 622
 623 static void prefs_display_header_ok(void)
 624 {
 625         prefs_common.show_other_header =
 626                 gtk_toggle_button_get_active
 627                         (GTK_TOGGLE_BUTTON(dispheader.other_headers));
 628         prefs_display_header_write_config();
 629         gtk_widget_hide(dispheader.window);
 630 }
 631
 632 static void prefs_display_header_cancel(void)
 633 {
 634         prefs_display_header_read_config();
 635         gtk_widget_hide(dispheader.window);
 636 }
 637
 638 static gint prefs_display_header_deleted(GtkWidget *widget, GdkEventAny *event,
 639                                          gpointer data)
 640 {
 641         prefs_display_header_cancel();
 642         return TRUE;
 643 }