2004-12-04 [paul] 0.9.12cvs182.3
[claws.git] / src / prefs_customheader.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2003 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 "main.h"
36 #include "prefs_gtk.h"
37 #include "prefs_customheader.h"
38 #include "prefs_common.h"
39 #include "prefs_account.h"
40 #include "mainwindow.h"
41 #include "foldersel.h"
42 #include "manage_window.h"
43 #include "customheader.h"
44 #include "folder.h"
45 #include "utils.h"
46 #include "gtkutils.h"
47 #include "alertpanel.h"
48
49 static struct CustomHdr {
50         GtkWidget *window;
51
52         GtkWidget *ok_btn;
53         GtkWidget *cancel_btn;
54
55         GtkWidget *hdr_combo;
56         GtkWidget *hdr_entry;
57         GtkWidget *val_entry;
58         GtkWidget *customhdr_clist;
59 } customhdr;
60
61 /* widget creating functions */
62 static void prefs_custom_header_create  (void);
63
64 static void prefs_custom_header_set_dialog      (PrefsAccount *ac);
65 static void prefs_custom_header_set_list        (PrefsAccount *ac);
66 static gint prefs_custom_header_clist_set_row   (PrefsAccount *ac,
67                                                  gint          row);
68
69 /* callback functions */
70 static void prefs_custom_header_add_cb          (void);
71 static void prefs_custom_header_delete_cb       (void);
72 static void prefs_custom_header_up              (void);
73 static void prefs_custom_header_down            (void);
74 static void prefs_custom_header_select          (GtkCList       *clist,
75                                                  gint            row,
76                                                  gint            column,
77                                                  GdkEvent       *event);
78
79 static void prefs_custom_header_row_moved       (GtkCList       *clist,
80                                                  gint            source_row,
81                                                  gint            dest_row,
82                                                  gpointer        data);
83
84 static gboolean prefs_custom_header_key_pressed (GtkWidget      *widget,
85                                                  GdkEventKey    *event,
86                                                  gpointer        data);
87 static void prefs_custom_header_ok              (void);
88 static void prefs_custom_header_cancel          (void);
89 static gint prefs_custom_header_deleted         (GtkWidget      *widget,
90                                                  GdkEventAny    *event,
91                                                  gpointer        data);
92
93 static PrefsAccount *cur_ac = NULL;
94
95 void prefs_custom_header_open(PrefsAccount *ac)
96 {
97         if (!customhdr.window) {
98                 prefs_custom_header_create();
99         }
100
101         manage_window_set_transient(GTK_WINDOW(customhdr.window));
102         gtk_widget_grab_focus(customhdr.ok_btn);
103
104         prefs_custom_header_set_dialog(ac);
105
106         cur_ac = ac;
107
108         gtk_widget_show(customhdr.window);
109 }
110
111 static void prefs_custom_header_create(void)
112 {
113         GtkWidget *window;
114         GtkWidget *vbox;
115
116         GtkWidget *ok_btn;
117         GtkWidget *cancel_btn;
118
119         GtkWidget *confirm_area;
120
121         GtkWidget *vbox1;
122
123         GtkWidget *table1;
124         GtkWidget *hdr_label;
125         GtkWidget *hdr_combo;
126         GtkWidget *val_label;
127         GtkWidget *val_entry;
128
129         GtkWidget *reg_hbox;
130         GtkWidget *btn_hbox;
131         GtkWidget *arrow;
132         GtkWidget *add_btn;
133         GtkWidget *del_btn;
134
135         GtkWidget *ch_hbox;
136         GtkWidget *ch_scrolledwin;
137         GtkWidget *customhdr_clist;
138
139         GtkWidget *btn_vbox;
140         GtkWidget *up_btn;
141         GtkWidget *down_btn;
142
143         gchar *title[1];
144
145         debug_print("Creating custom header setting window...\n");
146
147         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
148         gtk_container_set_border_width (GTK_CONTAINER (window), 8);
149         gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
150         gtk_window_set_modal (GTK_WINDOW (window), TRUE);
151         gtk_window_set_resizable(GTK_WINDOW (window), TRUE);
152
153         vbox = gtk_vbox_new (FALSE, 6);
154         gtk_widget_show (vbox);
155         gtk_container_add (GTK_CONTAINER (window), vbox);
156
157         gtkut_button_set_create(&confirm_area, &ok_btn, _("OK"),
158                                 &cancel_btn, _("Cancel"), NULL, NULL);
159         gtk_widget_show (confirm_area);
160         gtk_box_pack_end (GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
161         gtk_widget_grab_default (ok_btn);
162
163         gtk_window_set_title (GTK_WINDOW(window), _("Custom header configuration"));
164         MANAGE_WINDOW_SIGNALS_CONNECT (window);
165         g_signal_connect (G_OBJECT(window), "delete_event",
166                           G_CALLBACK(prefs_custom_header_deleted),
167                           NULL);
168         g_signal_connect (G_OBJECT(window), "key_press_event",
169                           G_CALLBACK(prefs_custom_header_key_pressed),
170                           NULL);
171         g_signal_connect (G_OBJECT(ok_btn), "clicked",
172                           G_CALLBACK(prefs_custom_header_ok), NULL);
173         g_signal_connect (G_OBJECT(cancel_btn), "clicked",
174                           G_CALLBACK(prefs_custom_header_cancel), NULL);
175
176         vbox1 = gtk_vbox_new (FALSE, VSPACING);
177         gtk_widget_show (vbox1);
178         gtk_box_pack_start (GTK_BOX (vbox), vbox1, TRUE, TRUE, 0);
179         gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);
180
181         table1 = gtk_table_new (2, 2, FALSE);
182         gtk_widget_show (table1);
183         gtk_box_pack_start (GTK_BOX (vbox1), table1,
184                             FALSE, FALSE, 0);
185         gtk_table_set_row_spacings (GTK_TABLE (table1), 8);
186         gtk_table_set_col_spacings (GTK_TABLE (table1), 8);
187
188         hdr_label = gtk_label_new (_("Header"));
189         gtk_widget_show (hdr_label);
190         gtk_table_attach (GTK_TABLE (table1), hdr_label, 0, 1, 0, 1,
191                           GTK_EXPAND | GTK_SHRINK | GTK_FILL,
192                           0, 0, 0);
193         gtk_misc_set_alignment (GTK_MISC (hdr_label), 0, 0.5);
194         
195         hdr_combo = gtk_combo_new ();
196         gtk_widget_show (hdr_combo);
197         gtk_table_attach (GTK_TABLE (table1), hdr_combo, 0, 1, 1, 2,
198                           GTK_EXPAND | GTK_SHRINK | GTK_FILL,
199                           0, 0, 0);
200         gtk_widget_set_size_request (hdr_combo, 150, -1);
201         gtkut_combo_set_items (GTK_COMBO (hdr_combo),
202                                "User-Agent", "X-Face", "X-Operating-System",
203                                NULL);
204
205         val_label = gtk_label_new (_("Value"));
206         gtk_widget_show (val_label);
207         gtk_table_attach (GTK_TABLE (table1), val_label, 1, 2, 0, 1,
208                           GTK_EXPAND | GTK_SHRINK | GTK_FILL,
209                           0, 0, 0);
210         gtk_misc_set_alignment (GTK_MISC (val_label), 0, 0.5);
211         
212         val_entry = gtk_entry_new ();
213         gtk_widget_show (val_entry);
214         gtk_table_attach (GTK_TABLE (table1), val_entry, 1, 2, 1, 2,
215                           GTK_EXPAND | GTK_SHRINK | GTK_FILL,
216                           0, 0, 0);
217         gtk_widget_set_size_request (val_entry, 200, -1);
218
219         /* add / delete */
220
221         reg_hbox = gtk_hbox_new (FALSE, 4);
222         gtk_widget_show (reg_hbox);
223         gtk_box_pack_start (GTK_BOX (vbox1), reg_hbox, FALSE, FALSE, 0);
224
225         arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
226         gtk_widget_show (arrow);
227         gtk_box_pack_start (GTK_BOX (reg_hbox), arrow, FALSE, FALSE, 0);
228         gtk_widget_set_size_request (arrow, -1, 16);
229
230         btn_hbox = gtk_hbox_new (TRUE, 4);
231         gtk_widget_show (btn_hbox);
232         gtk_box_pack_start (GTK_BOX (reg_hbox), btn_hbox, FALSE, FALSE, 0);
233
234         add_btn = gtk_button_new_with_label (_("Add"));
235         gtk_widget_show (add_btn);
236         gtk_box_pack_start (GTK_BOX (btn_hbox), add_btn, FALSE, TRUE, 0);
237         g_signal_connect (G_OBJECT (add_btn), "clicked",
238                           G_CALLBACK (prefs_custom_header_add_cb),
239                           NULL);
240
241         del_btn = gtk_button_new_with_label (_(" Delete "));
242         gtk_widget_show (del_btn);
243         gtk_box_pack_start (GTK_BOX (btn_hbox), del_btn, FALSE, TRUE, 0);
244         g_signal_connect (G_OBJECT (del_btn), "clicked",
245                           G_CALLBACK (prefs_custom_header_delete_cb),
246                           NULL);
247
248
249         ch_hbox = gtk_hbox_new (FALSE, 8);
250         gtk_widget_show (ch_hbox);
251         gtk_box_pack_start (GTK_BOX (vbox1), ch_hbox, TRUE, TRUE, 0);
252
253         ch_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
254         gtk_widget_set_size_request (ch_scrolledwin, -1, 200);
255         gtk_widget_show (ch_scrolledwin);
256         gtk_box_pack_start (GTK_BOX (ch_hbox), ch_scrolledwin, TRUE, TRUE, 0);
257         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (ch_scrolledwin),
258                                         GTK_POLICY_AUTOMATIC,
259                                         GTK_POLICY_AUTOMATIC);
260
261         title[0] = _("Current custom headers");
262         customhdr_clist = gtk_clist_new_with_titles(1, title);
263         gtk_widget_show (customhdr_clist);
264         gtk_container_add (GTK_CONTAINER (ch_scrolledwin), customhdr_clist);
265         gtk_clist_set_column_width (GTK_CLIST (customhdr_clist), 0, 80);
266         gtk_clist_set_selection_mode (GTK_CLIST (customhdr_clist),
267                                       GTK_SELECTION_BROWSE);
268         gtk_clist_set_reorderable (GTK_CLIST (customhdr_clist), TRUE);
269         gtk_clist_set_use_drag_icons (GTK_CLIST (customhdr_clist), FALSE);
270         GTK_WIDGET_UNSET_FLAGS (GTK_CLIST (customhdr_clist)->column[0].button,
271                                 GTK_CAN_FOCUS);
272         g_signal_connect (G_OBJECT (customhdr_clist), "select_row",
273                           G_CALLBACK (prefs_custom_header_select),
274                           NULL);
275         g_signal_connect_after
276                 (G_OBJECT (customhdr_clist), "row_move",
277                  G_CALLBACK (prefs_custom_header_row_moved), NULL);
278
279         btn_vbox = gtk_vbox_new (FALSE, 8);
280         gtk_widget_show (btn_vbox);
281         gtk_box_pack_start (GTK_BOX (ch_hbox), btn_vbox, FALSE, FALSE, 0);
282
283         up_btn = gtk_button_new_with_label (_("Up"));
284         gtk_widget_show (up_btn);
285         gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0);
286         g_signal_connect (G_OBJECT (up_btn), "clicked",
287                           G_CALLBACK (prefs_custom_header_up), NULL);
288
289         down_btn = gtk_button_new_with_label (_("Down"));
290         gtk_widget_show (down_btn);
291         gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0);
292         g_signal_connect (G_OBJECT (down_btn), "clicked",
293                           G_CALLBACK (prefs_custom_header_down), NULL);
294
295         gtk_widget_show_all(window);
296
297         customhdr.window     = window;
298         customhdr.ok_btn     = ok_btn;
299         customhdr.cancel_btn = cancel_btn;
300
301         customhdr.hdr_combo  = hdr_combo;
302         customhdr.hdr_entry  = GTK_COMBO (hdr_combo)->entry;
303         customhdr.val_entry  = val_entry;
304
305         customhdr.customhdr_clist   = customhdr_clist;
306 }
307
308 void prefs_custom_header_read_config(PrefsAccount *ac)
309 {
310         gchar *rcpath;
311         FILE *fp;
312         gchar buf[PREFSBUFSIZE];
313         CustomHeader *ch;
314
315         debug_print("Reading custom header configuration...\n");
316
317         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
318                              CUSTOM_HEADER_RC, NULL);
319         if ((fp = fopen(rcpath, "rb")) == NULL) {
320                 if (ENOENT != errno) FILE_OP_ERROR(rcpath, "fopen");
321                 g_free(rcpath);
322                 ac->customhdr_list = NULL;
323                 return;
324         }
325         g_free(rcpath);
326
327         /* remove all previous headers list */
328         while (ac->customhdr_list != NULL) {
329                 ch = (CustomHeader *)ac->customhdr_list->data;
330                 custom_header_free(ch);
331                 ac->customhdr_list = g_slist_remove(ac->customhdr_list, ch);
332         }
333
334         while (fgets(buf, sizeof(buf), fp) != NULL) {
335                 ch = custom_header_read_str(buf);
336                 if (ch) {
337                         if (ch->account_id == ac->account_id) {
338                                 ac->customhdr_list =
339                                         g_slist_append(ac->customhdr_list, ch);
340                         } else
341                                 custom_header_free(ch);
342                 }
343         }
344
345         fclose(fp);
346 }
347
348 void prefs_custom_header_write_config(PrefsAccount *ac)
349 {
350         gchar *rcpath;
351         PrefFile *pfile;
352         GSList *cur;
353         gchar buf[PREFSBUFSIZE];
354         FILE * fp;
355         CustomHeader *ch;
356
357         GSList *all_hdrs = NULL;
358
359         debug_print("Writing custom header configuration...\n");
360
361         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
362                              CUSTOM_HEADER_RC, NULL);
363
364         if ((fp = fopen(rcpath, "rb")) == NULL) {
365                 if (ENOENT != errno) FILE_OP_ERROR(rcpath, "fopen");
366         } else {
367                 all_hdrs = NULL;
368
369                 while (fgets(buf, sizeof(buf), fp) != NULL) {
370                         ch = custom_header_read_str(buf);
371                         if (ch) {
372                                 if (ch->account_id != ac->account_id)
373                                         all_hdrs =
374                                                 g_slist_append(all_hdrs, ch);
375                                 else
376                                         custom_header_free(ch);
377                         }
378                 }
379
380                 fclose(fp);
381         }
382
383         if ((pfile = prefs_write_open(rcpath)) == NULL) {
384                 g_warning("failed to write configuration to file\n");
385                 g_free(rcpath);
386                 return;
387         }
388
389         for (cur = all_hdrs; cur != NULL; cur = cur->next) {
390                 CustomHeader *hdr = (CustomHeader *)cur->data;
391                 gchar *chstr;
392
393                 chstr = custom_header_get_str(hdr);
394                 if (fputs(chstr, pfile->fp) == EOF ||
395                     fputc('\n', pfile->fp) == EOF) {
396                         FILE_OP_ERROR(rcpath, "fputs || fputc");
397                         prefs_file_close_revert(pfile);
398                         g_free(rcpath);
399                         g_free(chstr);
400                         return;
401                 }
402                 g_free(chstr);
403         }
404
405         for (cur = ac->customhdr_list; cur != NULL; cur = cur->next) {
406                 CustomHeader *hdr = (CustomHeader *)cur->data;
407                 gchar *chstr;
408
409                 chstr = custom_header_get_str(hdr);
410                 if (fputs(chstr, pfile->fp) == EOF ||
411                     fputc('\n', pfile->fp) == EOF) {
412                         FILE_OP_ERROR(rcpath, "fputs || fputc");
413                         prefs_file_close_revert(pfile);
414                         g_free(rcpath);
415                         g_free(chstr);
416                         return;
417                 }
418                 g_free(chstr);
419         }
420
421         g_free(rcpath);
422
423         while (all_hdrs != NULL) {
424                 ch = (CustomHeader *)all_hdrs->data;
425                 custom_header_free(ch);
426                 all_hdrs = g_slist_remove(all_hdrs, ch);
427         }
428
429         if (prefs_file_close(pfile) < 0) {
430                 g_warning("failed to write configuration to file\n");
431                 return;
432         }
433 }
434
435 static void prefs_custom_header_set_dialog(PrefsAccount *ac)
436 {
437         GtkCList *clist = GTK_CLIST(customhdr.customhdr_clist);
438         GSList *cur;
439         gchar *ch_str[1];
440         gint row;
441
442         gtk_clist_freeze(clist);
443         gtk_clist_clear(clist);
444
445         for (cur = ac->customhdr_list; cur != NULL; cur = cur->next) {
446                 CustomHeader *ch = (CustomHeader *)cur->data;
447
448                 ch_str[0] = g_strdup_printf("%s: %s", ch->name,
449                                             ch->value ? ch->value : "");
450                 row = gtk_clist_append(clist, ch_str);
451                 gtk_clist_set_row_data(clist, row, ch);
452
453                 g_free(ch_str[0]);
454         }
455
456         gtk_clist_thaw(clist);
457 }
458
459 static void prefs_custom_header_set_list(PrefsAccount *ac)
460 {
461         gint row = 0;
462         CustomHeader *ch;
463
464         g_slist_free(ac->customhdr_list);
465         ac->customhdr_list = NULL;
466
467         while ((ch = gtk_clist_get_row_data
468                 (GTK_CLIST(customhdr.customhdr_clist), row)) != NULL) {
469                 ac->customhdr_list = g_slist_append(ac->customhdr_list, ch);
470                 row++;
471         }
472 }
473
474 static gint prefs_custom_header_clist_set_row(PrefsAccount *ac, gint row)
475 {
476         GtkCList *clist = GTK_CLIST(customhdr.customhdr_clist);
477         CustomHeader *ch;
478         const gchar *entry_text;
479         gchar *ch_str[1];
480
481         entry_text = gtk_entry_get_text(GTK_ENTRY(customhdr.hdr_entry));
482         if (entry_text[0] == '\0') {
483                 alertpanel_error(_("Header name is not set."));
484                 return -1;
485         }
486         if (!custom_header_is_allowed(entry_text)) {
487                 alertpanel_error(_("This Header name is not allowed as a custom header."));
488                 return -1;
489         }
490
491         ch = g_new0(CustomHeader, 1);
492
493         ch->account_id = ac->account_id;
494
495         ch->name = g_strdup(entry_text);
496         unfold_line(ch->name);
497         g_strstrip(ch->name);
498         gtk_entry_set_text(GTK_ENTRY(customhdr.hdr_entry), ch->name);
499
500         entry_text = gtk_entry_get_text(GTK_ENTRY(customhdr.val_entry));
501         if (entry_text[0] != '\0') {
502                 ch->value = g_strdup(entry_text);
503                 unfold_line(ch->value);
504                 g_strstrip(ch->value);
505                 gtk_entry_set_text(GTK_ENTRY(customhdr.val_entry), ch->value);
506         }
507
508         ch_str[0] = g_strdup_printf("%s: %s", ch->name,
509                                     ch->value ? ch->value : "");
510
511         if (row < 0)
512                 row = gtk_clist_append(clist, ch_str);
513         else {
514                 CustomHeader *tmp_ch;
515
516                 gtk_clist_set_text(clist, row, 0, ch_str[0]);
517                 tmp_ch = gtk_clist_get_row_data(clist, row);
518                 if (tmp_ch)
519                         custom_header_free(tmp_ch);
520         }
521
522         gtk_clist_set_row_data(clist, row, ch);
523
524         g_free(ch_str[0]);
525
526         prefs_custom_header_set_list(cur_ac);
527
528         return row;
529 }
530
531 static void prefs_custom_header_add_cb(void)
532 {
533         prefs_custom_header_clist_set_row(cur_ac, -1);
534 }
535
536 static void prefs_custom_header_delete_cb(void)
537 {
538         GtkCList *clist = GTK_CLIST(customhdr.customhdr_clist);
539         CustomHeader *ch;
540         gint row;
541
542         if (!clist->selection) return;
543         row = GPOINTER_TO_INT(clist->selection->data);
544
545         if (alertpanel(_("Delete header"),
546                        _("Do you really want to delete this header?"),
547                        _("Yes"), _("No"), NULL) != G_ALERTDEFAULT)
548                 return;
549
550         ch = gtk_clist_get_row_data(clist, row);
551         custom_header_free(ch);
552         gtk_clist_remove(clist, row);
553         cur_ac->customhdr_list = g_slist_remove(cur_ac->customhdr_list, ch);
554 }
555
556 static void prefs_custom_header_up(void)
557 {
558         GtkCList *clist = GTK_CLIST(customhdr.customhdr_clist);
559         gint row;
560
561         if (!clist->selection) return;
562
563         row = GPOINTER_TO_INT(clist->selection->data);
564         if (row > 0)
565                 gtk_clist_row_move(clist, row, row - 1);
566 }
567
568 static void prefs_custom_header_down(void)
569 {
570         GtkCList *clist = GTK_CLIST(customhdr.customhdr_clist);
571         gint row;
572
573         if (!clist->selection) return;
574
575         row = GPOINTER_TO_INT(clist->selection->data);
576         if (row >= 0 && row < clist->rows - 1)
577                 gtk_clist_row_move(clist, row, row + 1);
578 }
579
580 #define ENTRY_SET_TEXT(entry, str) \
581         gtk_entry_set_text(GTK_ENTRY(entry), str ? str : "")
582
583 static void prefs_custom_header_select(GtkCList *clist, gint row, gint column,
584                                        GdkEvent *event)
585 {
586         CustomHeader *ch;
587         CustomHeader default_ch = { 0, "", NULL };
588
589         ch = gtk_clist_get_row_data(clist, row);
590         if (!ch) ch = &default_ch;
591
592         ENTRY_SET_TEXT(customhdr.hdr_entry, ch->name);
593         ENTRY_SET_TEXT(customhdr.val_entry, ch->value);
594 }
595
596 #undef ENTRY_SET_TEXT
597
598 static void prefs_custom_header_row_moved(GtkCList *clist, gint source_row,
599                                           gint dest_row, gpointer data)
600 {
601         prefs_custom_header_set_list(cur_ac);
602 }
603
604 static gboolean prefs_custom_header_key_pressed(GtkWidget *widget,
605                                                 GdkEventKey *event,
606                                                 gpointer data)
607 {
608         if (event && event->keyval == GDK_Escape)
609                 prefs_custom_header_cancel();
610         return FALSE;
611 }
612
613 static void prefs_custom_header_ok(void)
614 {
615         prefs_custom_header_write_config(cur_ac);
616         gtk_widget_hide(customhdr.window);
617 }
618
619 static void prefs_custom_header_cancel(void)
620 {
621         prefs_custom_header_read_config(cur_ac); 
622         gtk_widget_hide(customhdr.window);
623 }
624
625 static gint prefs_custom_header_deleted(GtkWidget *widget, GdkEventAny *event,
626                                         gpointer data)
627 {
628         prefs_custom_header_cancel();
629         return TRUE;
630 }