Statistics
| Revision:

root / src / prefs_customheader.c @ 1

History | View | Annotate | Download (16.6 KB)

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.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_policy (GTK_WINDOW (window), FALSE, TRUE, FALSE);
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 setting"));
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), NULL);
239

    
240
        del_btn = gtk_button_new_with_label (_(" Delete "));
241
        gtk_widget_show (del_btn);
242
        gtk_box_pack_start (GTK_BOX (btn_hbox), del_btn, FALSE, TRUE, 0);
243
        g_signal_connect (G_OBJECT (del_btn), "clicked",
244
                          G_CALLBACK (prefs_custom_header_delete_cb), NULL);
245

    
246

    
247
        ch_hbox = gtk_hbox_new (FALSE, 8);
248
        gtk_widget_show (ch_hbox);
249
        gtk_box_pack_start (GTK_BOX (vbox1), ch_hbox, TRUE, TRUE, 0);
250

    
251
        ch_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
252
        gtk_widget_set_size_request (ch_scrolledwin, -1, 200);
253
        gtk_widget_show (ch_scrolledwin);
254
        gtk_box_pack_start (GTK_BOX (ch_hbox), ch_scrolledwin, TRUE, TRUE, 0);
255
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (ch_scrolledwin),
256
                                        GTK_POLICY_AUTOMATIC,
257
                                        GTK_POLICY_AUTOMATIC);
258

    
259
        title[0] = _("Custom headers");
260
        customhdr_clist = gtk_clist_new_with_titles(1, title);
261
        gtk_widget_show (customhdr_clist);
262
        gtk_container_add (GTK_CONTAINER (ch_scrolledwin), customhdr_clist);
263
        gtk_clist_set_column_width (GTK_CLIST (customhdr_clist), 0, 80);
264
        gtk_clist_set_selection_mode (GTK_CLIST (customhdr_clist),
265
                                      GTK_SELECTION_BROWSE);
266
        gtk_clist_set_reorderable (GTK_CLIST (customhdr_clist), TRUE);
267
        gtk_clist_set_use_drag_icons (GTK_CLIST (customhdr_clist), FALSE);
268
        GTK_WIDGET_UNSET_FLAGS (GTK_CLIST (customhdr_clist)->column[0].button,
269
                                GTK_CAN_FOCUS);
270
        g_signal_connect (G_OBJECT (customhdr_clist), "select_row",
271
                          G_CALLBACK (prefs_custom_header_select), NULL);
272
        g_signal_connect_after
273
                (G_OBJECT (customhdr_clist), "row_move",
274
                 G_CALLBACK (prefs_custom_header_row_moved), NULL);
275

    
276
        btn_vbox = gtk_vbox_new (FALSE, 8);
277
        gtk_widget_show (btn_vbox);
278
        gtk_box_pack_start (GTK_BOX (ch_hbox), btn_vbox, FALSE, FALSE, 0);
279

    
280
        up_btn = gtk_button_new_with_label (_("Up"));
281
        gtk_widget_show (up_btn);
282
        gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0);
283
        g_signal_connect (G_OBJECT (up_btn), "clicked",
284
                          G_CALLBACK (prefs_custom_header_up), NULL);
285

    
286
        down_btn = gtk_button_new_with_label (_("Down"));
287
        gtk_widget_show (down_btn);
288
        gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0);
289
        g_signal_connect (G_OBJECT (down_btn), "clicked",
290
                          G_CALLBACK (prefs_custom_header_down), NULL);
291

    
292
        gtk_widget_show_all(window);
293

    
294
        customhdr.window     = window;
295
        customhdr.ok_btn     = ok_btn;
296
        customhdr.cancel_btn = cancel_btn;
297

    
298
        customhdr.hdr_combo  = hdr_combo;
299
        customhdr.hdr_entry  = GTK_COMBO (hdr_combo)->entry;
300
        customhdr.val_entry  = val_entry;
301

    
302
        customhdr.customhdr_clist   = customhdr_clist;
303
}
304

    
305
void prefs_custom_header_read_config(PrefsAccount *ac)
306
{
307
        gchar *rcpath;
308
        FILE *fp;
309
        gchar buf[PREFSBUFSIZE];
310
        CustomHeader *ch;
311

    
312
        debug_print("Reading custom header configuration...\n");
313

    
314
        rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
315
                             CUSTOM_HEADER_RC, NULL);
316
        if ((fp = fopen(rcpath, "rb")) == NULL) {
317
                if (ENOENT != errno) FILE_OP_ERROR(rcpath, "fopen");
318
                g_free(rcpath);
319
                ac->customhdr_list = NULL;
320
                return;
321
        }
322
        g_free(rcpath);
323

    
324
        /* remove all previous headers list */
325
        while (ac->customhdr_list != NULL) {
326
                ch = (CustomHeader *)ac->customhdr_list->data;
327
                custom_header_free(ch);
328
                ac->customhdr_list = g_slist_remove(ac->customhdr_list, ch);
329
        }
330

    
331
        while (fgets(buf, sizeof(buf), fp) != NULL) {
332
                ch = custom_header_read_str(buf);
333
                if (ch) {
334
                        if (ch->account_id == ac->account_id) {
335
                                ac->customhdr_list =
336
                                        g_slist_append(ac->customhdr_list, ch);
337
                        } else
338
                                custom_header_free(ch);
339
                }
340
        }
341

    
342
        fclose(fp);
343
}
344

    
345
void prefs_custom_header_write_config(PrefsAccount *ac)
346
{
347
        gchar *rcpath;
348
        PrefFile *pfile;
349
        GSList *cur;
350
        gchar buf[PREFSBUFSIZE];
351
        FILE * fp;
352
        CustomHeader *ch;
353

    
354
        GSList *all_hdrs = NULL;
355

    
356
        debug_print("Writing custom header configuration...\n");
357

    
358
        rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
359
                             CUSTOM_HEADER_RC, NULL);
360

    
361
        if ((fp = fopen(rcpath, "rb")) == NULL) {
362
                if (ENOENT != errno) FILE_OP_ERROR(rcpath, "fopen");
363
        } else {
364
                all_hdrs = NULL;
365

    
366
                while (fgets(buf, sizeof(buf), fp) != NULL) {
367
                        ch = custom_header_read_str(buf);
368
                        if (ch) {
369
                                if (ch->account_id != ac->account_id)
370
                                        all_hdrs =
371
                                                g_slist_append(all_hdrs, ch);
372
                                else
373
                                        custom_header_free(ch);
374
                        }
375
                }
376

    
377
                fclose(fp);
378
        }
379

    
380
        if ((pfile = prefs_file_open(rcpath)) == NULL) {
381
                g_warning(_("failed to write configuration to file\n"));
382
                g_free(rcpath);
383
                return;
384
        }
385

    
386
        for (cur = all_hdrs; cur != NULL; cur = cur->next) {
387
                 CustomHeader *hdr = (CustomHeader *)cur->data;
388
                gchar *chstr;
389

    
390
                chstr = custom_header_get_str(hdr);
391
                if (fputs(chstr, pfile->fp) == EOF ||
392
                    fputc('\n', pfile->fp) == EOF) {
393
                        FILE_OP_ERROR(rcpath, "fputs || fputc");
394
                        prefs_file_close_revert(pfile);
395
                        g_free(rcpath);
396
                        g_free(chstr);
397
                        return;
398
                }
399
                g_free(chstr);
400
        }
401

    
402
        for (cur = ac->customhdr_list; cur != NULL; cur = cur->next) {
403
                 CustomHeader *hdr = (CustomHeader *)cur->data;
404
                gchar *chstr;
405

    
406
                chstr = custom_header_get_str(hdr);
407
                if (fputs(chstr, pfile->fp) == EOF ||
408
                    fputc('\n', pfile->fp) == EOF) {
409
                        FILE_OP_ERROR(rcpath, "fputs || fputc");
410
                        prefs_file_close_revert(pfile);
411
                        g_free(rcpath);
412
                        g_free(chstr);
413
                        return;
414
                }
415
                g_free(chstr);
416
        }
417

    
418
        g_free(rcpath);
419

    
420
         while (all_hdrs != NULL) {
421
                 ch = (CustomHeader *)all_hdrs->data;
422
                 custom_header_free(ch);
423
                 all_hdrs = g_slist_remove(all_hdrs, ch);
424
         }
425

    
426
        if (prefs_file_close(pfile) < 0) {
427
                g_warning(_("failed to write configuration to file\n"));
428
                return;
429
        }
430
}
431

    
432
static void prefs_custom_header_set_dialog(PrefsAccount *ac)
433
{
434
        GtkCList *clist = GTK_CLIST(customhdr.customhdr_clist);
435
        GSList *cur;
436
        gchar *ch_str[1];
437
        gint row;
438

    
439
        gtk_clist_freeze(clist);
440
        gtk_clist_clear(clist);
441

    
442
        for (cur = ac->customhdr_list; cur != NULL; cur = cur->next) {
443
                 CustomHeader *ch = (CustomHeader *)cur->data;
444

    
445
                ch_str[0] = g_strdup_printf("%s: %s", ch->name,
446
                                            ch->value ? ch->value : "");
447
                row = gtk_clist_append(clist, ch_str);
448
                gtk_clist_set_row_data(clist, row, ch);
449

    
450
                g_free(ch_str[0]);
451
        }
452

    
453
        gtk_clist_thaw(clist);
454
}
455

    
456
static void prefs_custom_header_set_list(PrefsAccount *ac)
457
{
458
        gint row = 0;
459
        CustomHeader *ch;
460

    
461
        g_slist_free(ac->customhdr_list);
462
        ac->customhdr_list = NULL;
463

    
464
        while ((ch = gtk_clist_get_row_data
465
                (GTK_CLIST(customhdr.customhdr_clist), row)) != NULL) {
466
                ac->customhdr_list = g_slist_append(ac->customhdr_list, ch);
467
                row++;
468
        }
469
}
470

    
471
static gint prefs_custom_header_clist_set_row(PrefsAccount *ac, gint row)
472
{
473
        GtkCList *clist = GTK_CLIST(customhdr.customhdr_clist);
474
        CustomHeader *ch;
475
        const gchar *entry_text;
476
        gchar *ch_str[1];
477

    
478
        entry_text = gtk_entry_get_text(GTK_ENTRY(customhdr.hdr_entry));
479
        if (entry_text[0] == '\0') {
480
                alertpanel_error(_("Header name is not set."));
481
                return -1;
482
        }
483

    
484
        ch = g_new0(CustomHeader, 1);
485

    
486
        ch->account_id = ac->account_id;
487

    
488
        ch->name = g_strdup(entry_text);
489
        unfold_line(ch->name);
490
        g_strstrip(ch->name);
491
        gtk_entry_set_text(GTK_ENTRY(customhdr.hdr_entry), ch->name);
492

    
493
        entry_text = gtk_entry_get_text(GTK_ENTRY(customhdr.val_entry));
494
        if (entry_text[0] != '\0') {
495
                ch->value = g_strdup(entry_text);
496
                unfold_line(ch->value);
497
                g_strstrip(ch->value);
498
                gtk_entry_set_text(GTK_ENTRY(customhdr.val_entry), ch->value);
499
        }
500

    
501
        ch_str[0] = g_strdup_printf("%s: %s", ch->name,
502
                                    ch->value ? ch->value : "");
503

    
504
        if (row < 0)
505
                row = gtk_clist_append(clist, ch_str);
506
        else {
507
                CustomHeader *tmp_ch;
508

    
509
                gtk_clist_set_text(clist, row, 0, ch_str[0]);
510
                tmp_ch = gtk_clist_get_row_data(clist, row);
511
                if (tmp_ch)
512
                        custom_header_free(tmp_ch);
513
        }
514

    
515
        gtk_clist_set_row_data(clist, row, ch);
516

    
517
        g_free(ch_str[0]);
518

    
519
        prefs_custom_header_set_list(cur_ac);
520

    
521
        return row;
522
}
523

    
524
static void prefs_custom_header_add_cb(void)
525
{
526
        prefs_custom_header_clist_set_row(cur_ac, -1);
527
}
528

    
529
static void prefs_custom_header_delete_cb(void)
530
{
531
        GtkCList *clist = GTK_CLIST(customhdr.customhdr_clist);
532
        CustomHeader *ch;
533
        gint row;
534

    
535
        if (!clist->selection) return;
536
        row = GPOINTER_TO_INT(clist->selection->data);
537

    
538
        if (alertpanel(_("Delete header"),
539
                       _("Do you really want to delete this header?"),
540
                       _("Yes"), _("No"), NULL) != G_ALERTDEFAULT)
541
                return;
542

    
543
        ch = gtk_clist_get_row_data(clist, row);
544
        custom_header_free(ch);
545
        gtk_clist_remove(clist, row);
546
        cur_ac->customhdr_list = g_slist_remove(cur_ac->customhdr_list, ch);
547
}
548

    
549
static void prefs_custom_header_up(void)
550
{
551
        GtkCList *clist = GTK_CLIST(customhdr.customhdr_clist);
552
        gint row;
553

    
554
        if (!clist->selection) return;
555

    
556
        row = GPOINTER_TO_INT(clist->selection->data);
557
        if (row > 0)
558
                gtk_clist_row_move(clist, row, row - 1);
559
}
560

    
561
static void prefs_custom_header_down(void)
562
{
563
        GtkCList *clist = GTK_CLIST(customhdr.customhdr_clist);
564
        gint row;
565

    
566
        if (!clist->selection) return;
567

    
568
        row = GPOINTER_TO_INT(clist->selection->data);
569
        if (row >= 0 && row < clist->rows - 1)
570
                gtk_clist_row_move(clist, row, row + 1);
571
}
572

    
573
#define ENTRY_SET_TEXT(entry, str) \
574
        gtk_entry_set_text(GTK_ENTRY(entry), str ? str : "")
575

    
576
static void prefs_custom_header_select(GtkCList *clist, gint row, gint column,
577
                                       GdkEvent *event)
578
{
579
        CustomHeader *ch;
580
        CustomHeader default_ch = { 0, "", NULL };
581

    
582
        ch = gtk_clist_get_row_data(clist, row);
583
        if (!ch) ch = &default_ch;
584

    
585
        ENTRY_SET_TEXT(customhdr.hdr_entry, ch->name);
586
        ENTRY_SET_TEXT(customhdr.val_entry, ch->value);
587
}
588

    
589
#undef ENTRY_SET_TEXT
590

    
591
static void prefs_custom_header_row_moved(GtkCList *clist, gint source_row,
592
                                          gint dest_row, gpointer data)
593
{
594
        prefs_custom_header_set_list(cur_ac);
595
}
596

    
597
static gboolean prefs_custom_header_key_pressed(GtkWidget *widget,
598
                                                GdkEventKey *event,
599
                                                gpointer data)
600
{
601
        if (event && event->keyval == GDK_Escape)
602
                prefs_custom_header_cancel();
603
        return FALSE;
604
}
605

    
606
static void prefs_custom_header_ok(void)
607
{
608
        prefs_custom_header_write_config(cur_ac);
609
        gtk_widget_hide(customhdr.window);
610
}
611

    
612
static void prefs_custom_header_cancel(void)
613
{
614
        prefs_custom_header_read_config(cur_ac); 
615
        gtk_widget_hide(customhdr.window);
616
}
617

    
618
static gint prefs_custom_header_deleted(GtkWidget *widget, GdkEventAny *event,
619
                                        gpointer data)
620
{
621
        prefs_custom_header_cancel();
622
        return TRUE;
623
}