← Back to branch summary

~ubuntu-branches/ubuntu/feisty/elinks/feisty-updates

« back to all changes in this revision

Viewing changes to src/dialogs/menu.c

  • Committer: Bazaar Package Importer
  • Author(s): Peter Gervai
  • Date: 2004-01-21 22:13:45 UTC
  • Revision ID: james.westby@ubuntu.com-20040121221345-ju33hai1yhhqt6kn
Tags: upstream-0.9.1
Import upstream version 0.9.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dialogs/menu.c
 
1
/* Menu system */
 
2
/* $Id: menu.c,v 1.281 2004/01/08 18:37:46 jonas Exp $ */
 
3
 
 
4
#ifdef HAVE_CONFIG_H
 
5
#include "config.h"
 
6
#endif
 
7
 
 
8
#include <stdlib.h>
 
9
#include <string.h>
 
10
 
 
11
#include "elinks.h"
 
12
 
 
13
#include "bfu/inpfield.h"
 
14
#include "bfu/inphist.h"
 
15
#include "bfu/menu.h"
 
16
#include "bfu/msgbox.h"
 
17
#include "config/options.h"
 
18
#include "config/urlhist.h"
 
19
#include "document/document.h"
 
20
#include "document/view.h"
 
21
#include "dialogs/info.h"
 
22
#include "dialogs/menu.h"
 
23
#include "dialogs/options.h"
 
24
#include "intl/gettext/libintl.h"
 
25
#include "lowlevel/select.h"
 
26
#include "mime/dialogs.h"
 
27
#include "osdep/osdep.h"
 
28
#include "osdep/newwin.h"
 
29
#include "protocol/uri.h"
 
30
#include "sched/connection.h"
 
31
#include "sched/download.h"
 
32
#include "sched/event.h"
 
33
#include "sched/history.h"
 
34
#include "sched/location.h"
 
35
#include "sched/session.h"
 
36
#include "sched/task.h"
 
37
#include "terminal/kbd.h"
 
38
#include "terminal/tab.h"
 
39
#include "terminal/terminal.h"
 
40
#include "util/memlist.h"
 
41
#include "util/memory.h"
 
42
#include "util/string.h"
 
43
#include "viewer/text/link.h"
 
44
#include "viewer/text/view.h"
 
45
 
 
46
 
 
47
/* Helper for url items in help menu. */
 
48
static void
 
49
menu_url_shortcut(struct terminal *term, void *d, struct session *ses)
 
50
{
 
51
        unsigned char *u = stracpy((unsigned char *) d);
 
52
 
 
53
        if (!u) return;
 
54
        goto_url(ses, u);
 
55
        mem_free(u);
 
56
}
 
57
 
 
58
void
 
59
save_url_as(struct session *ses)
 
60
{
 
61
        input_field(ses->tab->term, NULL, 1,
 
62
                    N_("Save URL"), N_("Enter URL"),
 
63
                    N_("OK"), N_("Cancel"), ses, &goto_url_history,
 
64
                    MAX_STR_LEN, "", 0, 0, NULL,
 
65
                    (void (*)(void *, unsigned char *)) save_url,
 
66
                    NULL);
 
67
}
 
68
 
 
69
void
 
70
really_exit_prog(struct session *ses)
 
71
{
 
72
        register_bottom_half((void (*)(void *))destroy_terminal, ses->tab->term);
 
73
}
 
74
 
 
75
static inline void
 
76
dont_exit_prog(struct session *ses)
 
77
{
 
78
        ses->exit_query = 0;
 
79
}
 
80
 
 
81
void
 
82
query_exit(struct session *ses)
 
83
{
 
84
        ses->exit_query = 1;
 
85
        msg_box(ses->tab->term, NULL, 0,
 
86
                N_("Exit ELinks"), AL_CENTER,
 
87
                (ses->tab->term->next == ses->tab->term->prev && are_there_downloads())
 
88
                ? N_("Do you really want to exit ELinks "
 
89
                     "(and terminate all downloads)?")
 
90
                : N_("Do you really want to exit ELinks?"),
 
91
                ses, 2,
 
92
                N_("Yes"), (void (*)(void *)) really_exit_prog, B_ENTER,
 
93
                N_("No"), (void (*)(void *)) dont_exit_prog, B_ESC);
 
94
}
 
95
 
 
96
void
 
97
exit_prog(struct session *ses, int query)
 
98
{
 
99
        assert(ses);
 
100
 
 
101
        if (!ses->exit_query
 
102
            && (query || (ses->tab->term->next == ses->tab->term->prev
 
103
                          && are_there_downloads()))) {
 
104
                query_exit(ses);
 
105
                return;
 
106
        }
 
107
 
 
108
        really_exit_prog(ses);
 
109
}
 
110
 
 
111
 
 
112
static void
 
113
go_historywards(struct terminal *term, struct location *target,
 
114
                struct session *ses)
 
115
{
 
116
        go_history(ses, target);
 
117
}
 
118
 
 
119
static struct menu_item no_hist_menu[] = {
 
120
        INIT_MENU_ITEM(N_("No history"), NULL, ACT_NONE, NULL, NULL, NO_SELECT),
 
121
        NULL_MENU_ITEM
 
122
};
 
123
 
 
124
#define history_menu_model(name__, dir__)                               \
 
125
static void                                                             \
 
126
name__(struct terminal *term, void *ddd, struct session *ses)           \
 
127
{                                                                       \
 
128
        struct location *loc;                                           \
 
129
        struct menu_item *mi = NULL;                                    \
 
130
                                                                        \
 
131
        if (!have_location(ses)) goto loop_done;                        \
 
132
                                                                        \
 
133
        for (loc = cur_loc(ses)->dir__;                                 \
 
134
             loc != (struct location *) &ses->history.history;          \
 
135
             loc = loc->dir__) {                                        \
 
136
                unsigned char *url;                                     \
 
137
                                                                        \
 
138
                if (!mi) {                                              \
 
139
                        mi = new_menu(FREE_LIST | FREE_TEXT);           \
 
140
                        if (!mi) return;                                \
 
141
                }                                                       \
 
142
                                                                        \
 
143
                url = get_no_post_url(loc->vs.url, NULL);               \
 
144
                if (url) {                                              \
 
145
                        add_to_menu(&mi, url, NULL, ACT_NONE,           \
 
146
                                    (menu_func) go_historywards,        \
 
147
                                    (void *) loc, NO_INTL);             \
 
148
                }                                                       \
 
149
        }                                                               \
 
150
loop_done:                                                              \
 
151
                                                                        \
 
152
        if (!mi)                                                        \
 
153
                do_menu(term, no_hist_menu, ses, 0);                    \
 
154
        else                                                            \
 
155
                do_menu(term, mi, ses, 0);                              \
 
156
}
 
157
 
 
158
history_menu_model(history_menu, prev);
 
159
history_menu_model(unhistory_menu, next);
 
160
 
 
161
#undef history_menu_model
 
162
 
 
163
 
 
164
void
 
165
tab_menu(struct terminal *term, void *d, struct session *ses)
 
166
{
 
167
        struct menu_item *menu;
 
168
        struct window *tab = d;
 
169
        int tabs = number_of_tabs(term);
 
170
        int i = 0;
 
171
#ifdef CONFIG_BOOKMARKS
 
172
        int anonymous = get_opt_bool_tree(cmdline_options, "anonymous");
 
173
#endif
 
174
 
 
175
        assert(term && ses && tab);
 
176
        if_assert_failed return;
 
177
 
 
178
        menu = new_menu(FREE_LIST);
 
179
        if (!menu) return;
 
180
 
 
181
        add_menu_action(&menu, N_("Go ~back"), ACT_BACK);
 
182
        add_menu_action(&menu, N_("Go for~ward"), ACT_UNBACK);
 
183
 
 
184
        add_separator_to_menu(&menu);
 
185
 
 
186
#ifdef CONFIG_BOOKMARKS
 
187
        if (!anonymous) {
 
188
                add_menu_action(&menu, N_("Bookm~ark document"), ACT_ADD_BOOKMARK);
 
189
        }
 
190
#endif
 
191
 
 
192
        add_menu_action(&menu, N_("~Reload"), ACT_RELOAD);
 
193
 
 
194
        if (ses->doc_view && document_has_frames(ses->doc_view->document))
 
195
                add_menu_action(&menu, N_("Frame at ~full-screen"), ACT_ZOOM_FRAME);
 
196
 
 
197
        /* Keep tab related operations below this separator */
 
198
        add_separator_to_menu(&menu);
 
199
 
 
200
        if (tabs > 1) {
 
201
                add_menu_action(&menu, N_("Nex~t tab"), ACT_TAB_NEXT);
 
202
                add_menu_action(&menu, N_("Pre~v tab"), ACT_TAB_PREV);
 
203
        }
 
204
 
 
205
        add_menu_action(&menu, N_("~Close tab"), ACT_TAB_CLOSE);
 
206
 
 
207
        if (tabs > 1) {
 
208
                add_menu_action(&menu, N_("C~lose all tabs but the current"),
 
209
                                ACT_TAB_CLOSE_ALL_BUT_CURRENT);
 
210
#ifdef CONFIG_BOOKMARKS
 
211
                if (!anonymous) {
 
212
                        add_menu_action(&menu, N_("B~ookmark all tabs"),
 
213
                                        ACT_ADD_BOOKMARK_TABS);
 
214
                }
 
215
#endif
 
216
        }
 
217
 
 
218
        /* Adjust the menu position taking the menu frame into account */
 
219
        while (menu[i].text) i++;
 
220
        set_window_ptr(tab, tab->x, int_max(tab->y - i - 1, 0));
 
221
 
 
222
        do_menu(term, menu, ses, 1);
 
223
}
 
224
 
 
225
static void
 
226
do_submenu(struct terminal *term, void *menu, struct session *ses)
 
227
{
 
228
        do_menu(term, menu, ses, 1);
 
229
}
 
230
 
 
231
 
 
232
static struct menu_item file_menu11[] = {
 
233
        INIT_MENU_ACTION(N_("Open new ~tab"), ACT_OPEN_NEW_TAB),
 
234
        INIT_MENU_ACTION(N_("Open new tab in backgroun~d"), ACT_OPEN_NEW_TAB_IN_BACKGROUND),
 
235
        INIT_MENU_ACTION(N_("~Go to URL"), ACT_GOTO_URL),
 
236
        INIT_MENU_ACTION(N_("Go ~back"), ACT_BACK),
 
237
        INIT_MENU_ACTION(N_("Go ~forward"), ACT_UNBACK),
 
238
        INIT_MENU_ACTION(N_("~Reload"), ACT_RELOAD),
 
239
        INIT_MENU_ITEM(N_("~History"), NULL, ACT_NONE, history_menu, NULL, SUBMENU),
 
240
        INIT_MENU_ITEM(N_("~Unhistory"), NULL, ACT_NONE, unhistory_menu, NULL, SUBMENU),
 
241
};
 
242
 
 
243
static struct menu_item file_menu21[] = {
 
244
        BAR_MENU_ITEM,
 
245
        INIT_MENU_ACTION(N_("~Save as"), ACT_SAVE_AS),
 
246
        INIT_MENU_ACTION(N_("Save UR~L as"), ACT_SAVE_URL_AS),
 
247
        INIT_MENU_ACTION(N_("Sa~ve formatted document"), ACT_SAVE_FORMATTED),
 
248
#ifdef CONFIG_BOOKMARKS
 
249
        INIT_MENU_ACTION(N_("Bookm~ark document"), ACT_ADD_BOOKMARK),
 
250
#endif
 
251
};
 
252
 
 
253
static struct menu_item file_menu22[] = {
 
254
        BAR_MENU_ITEM,
 
255
        INIT_MENU_ACTION(N_("~Kill background connections"), ACT_KILL_BACKGROUNDED_CONNECTIONS),
 
256
        INIT_MENU_ACTION(N_("Flush all ~caches"), ACT_CACHE_MINIMIZE),
 
257
        INIT_MENU_ACTION(N_("Resource ~info"), ACT_RESOURCE_INFO),
 
258
#ifdef LEAK_DEBUG
 
259
        INIT_MENU_ITEM(N_("~Memory info"), NULL, ACT_NONE, memory_inf, NULL, 0),
 
260
#endif
 
261
        BAR_MENU_ITEM,
 
262
};
 
263
 
 
264
static struct menu_item file_menu3[] = {
 
265
        BAR_MENU_ITEM,
 
266
        INIT_MENU_ACTION(N_("E~xit"), ACT_QUIT),
 
267
        NULL_MENU_ITEM,
 
268
};
 
269
 
 
270
static void
 
271
do_file_menu(struct terminal *term, void *xxx, struct session *ses)
 
272
{
 
273
        struct menu_item *file_menu, *e, *f;
 
274
        int anonymous = get_opt_int_tree(cmdline_options, "anonymous");
 
275
        int x, o;
 
276
 
 
277
        file_menu = mem_alloc(sizeof(file_menu11) + sizeof(file_menu21)
 
278
                              + sizeof(file_menu22) + sizeof(file_menu3)
 
279
                              + 3 * sizeof(struct menu_item));
 
280
        if (!file_menu) return;
 
281
 
 
282
        e = file_menu;
 
283
        o = can_open_in_new(term);
 
284
        if (o) {
 
285
                SET_MENU_ITEM(e, N_("~New window"), NULL, ACT_OPEN_NEW_WINDOW,
 
286
                              (menu_func) open_in_new_window, send_open_new_window,
 
287
                              (o - 1) ? SUBMENU : 0, 0, HKS_SHOW);
 
288
                e++;
 
289
        }
 
290
 
 
291
        memcpy(e, file_menu11, sizeof(file_menu11));
 
292
        e += sizeof(file_menu11) / sizeof(struct menu_item);
 
293
 
 
294
        if (!anonymous) {
 
295
                memcpy(e, file_menu21, sizeof(file_menu21));
 
296
                e += sizeof(file_menu21) / sizeof(struct menu_item);
 
297
        }
 
298
 
 
299
        memcpy(e, file_menu22, sizeof(file_menu22));
 
300
        e += sizeof(file_menu22) / sizeof(struct menu_item);
 
301
 
 
302
        x = 1;
 
303
        if (!anonymous && can_open_os_shell(term->environment)) {
 
304
                SET_MENU_ITEM(e, N_("~OS shell"), NULL, ACT_OPEN_OS_SHELL,
 
305
                              NULL, NULL, 0, 0, HKS_SHOW);
 
306
                e++;
 
307
                x = 0;
 
308
        }
 
309
 
 
310
        if (can_resize_window(term->environment)) {
 
311
                SET_MENU_ITEM(e, N_("Resize t~erminal"), NULL, ACT_NONE,
 
312
                              dlg_resize_terminal, NULL,
 
313
                              0, 0, HKS_SHOW);
 
314
                e++;
 
315
                x = 0;
 
316
        }
 
317
 
 
318
        memcpy(e, file_menu3 + x, sizeof(file_menu3) - x * sizeof(struct menu_item));
 
319
        e += sizeof(file_menu3) / sizeof(struct menu_item);
 
320
 
 
321
        for (f = file_menu; f < e; f++)
 
322
                f->flags |= FREE_LIST;
 
323
 
 
324
        do_menu(term, file_menu, ses, 1);
 
325
}
 
326
 
 
327
static struct menu_item view_menu[] = {
 
328
        INIT_MENU_ACTION(N_("~Search"), ACT_SEARCH),
 
329
        INIT_MENU_ACTION(N_("Search ~backward"), ACT_SEARCH_BACK),
 
330
        INIT_MENU_ACTION(N_("Find ~next"), ACT_FIND_NEXT),
 
331
        INIT_MENU_ACTION(N_("Find ~previous"), ACT_FIND_NEXT_BACK),
 
332
        INIT_MENU_ACTION(N_("T~ypeahead search"), ACT_SEARCH_TYPEAHEAD),
 
333
        BAR_MENU_ITEM,
 
334
        INIT_MENU_ACTION(N_("Toggle ~html/plain"), ACT_TOGGLE_HTML_PLAIN),
 
335
        INIT_MENU_ACTION(N_("Toggle i~mages"), ACT_TOGGLE_DISPLAY_IMAGES),
 
336
        INIT_MENU_ACTION(N_("Toggle ~link numbering"), ACT_TOGGLE_NUMBERED_LINKS),
 
337
        INIT_MENU_ACTION(N_("Toggle ~document colors"), ACT_TOGGLE_DOCUMENT_COLORS),
 
338
        INIT_MENU_ACTION(N_("Document ~info"), ACT_DOCUMENT_INFO),
 
339
        INIT_MENU_ACTION(N_("H~eader info"), ACT_HEADER_INFO),
 
340
        INIT_MENU_ACTION(N_("Frame at ~full-screen"), ACT_ZOOM_FRAME),
 
341
        BAR_MENU_ITEM,
 
342
        INIT_MENU_ACTION(N_("Nex~t tab"), ACT_TAB_NEXT),
 
343
        INIT_MENU_ACTION(N_("Pre~v tab"), ACT_TAB_PREV),
 
344
        INIT_MENU_ACTION(N_("~Close tab"), ACT_TAB_CLOSE),
 
345
        NULL_MENU_ITEM
 
346
};
 
347
 
 
348
 
 
349
static struct menu_item help_menu[] = {
 
350
        INIT_MENU_ITEM(N_("~ELinks homepage"), NULL, ACT_NONE, menu_url_shortcut, ELINKS_HOMEPAGE, 0),
 
351
        INIT_MENU_ITEM(N_("~Documentation"), NULL, ACT_NONE, menu_url_shortcut, ELINKS_DOC_URL, 0),
 
352
        INIT_MENU_ITEM(N_("~Keys"), NULL, ACT_NONE, menu_keys, NULL, 0),
 
353
        BAR_MENU_ITEM,
 
354
#ifdef DEBUG
 
355
        INIT_MENU_ITEM(N_("~Bugs information"), NULL, ACT_NONE, menu_url_shortcut, ELINKS_BUGS_URL, 0),
 
356
        INIT_MENU_ITEM(N_("ELinks C~vsWeb"), NULL, ACT_NONE, menu_url_shortcut, ELINKS_CVSWEB_URL, 0),
 
357
        BAR_MENU_ITEM,
 
358
#endif
 
359
        INIT_MENU_ITEM(N_("~Copying"), NULL, ACT_NONE, menu_copying, NULL, 0),
 
360
        INIT_MENU_ITEM(N_("~About"), NULL, ACT_NONE, menu_about, NULL, 0),
 
361
        NULL_MENU_ITEM
 
362
};
 
363
 
 
364
 
 
365
static struct menu_item ext_menu[] = {
 
366
        INIT_MENU_ITEM(N_("~Add"), NULL, ACT_NONE, menu_add_ext, NULL, 0),
 
367
        INIT_MENU_ITEM(N_("~Modify"), NULL, ACT_NONE, menu_list_ext, menu_add_ext, SUBMENU),
 
368
        INIT_MENU_ITEM(N_("~Delete"), NULL, ACT_NONE, menu_list_ext, menu_del_ext, SUBMENU),
 
369
        NULL_MENU_ITEM
 
370
};
 
371
 
 
372
static struct menu_item setup_menu[] = {
 
373
#ifdef ENABLE_NLS
 
374
        INIT_MENU_ITEM(N_("~Language"), NULL, ACT_NONE, menu_language_list, NULL, SUBMENU),
 
375
#endif
 
376
        INIT_MENU_ITEM(N_("C~haracter set"), NULL, ACT_NONE, charset_list, NULL, SUBMENU),
 
377
        INIT_MENU_ACTION(N_("~Terminal options"), ACT_SHOW_TERM_OPTIONS),
 
378
        INIT_MENU_ITEM(N_("File ~extensions"), NULL, ACT_NONE, do_submenu, ext_menu, SUBMENU),
 
379
        BAR_MENU_ITEM,
 
380
        INIT_MENU_ACTION(N_("~Options manager"), ACT_OPTIONS_MANAGER),
 
381
        INIT_MENU_ACTION(N_("~Keybinding manager"), ACT_KEYBINDING_MANAGER),
 
382
        INIT_MENU_ACTION(N_("~Save options"), ACT_SAVE_OPTIONS),
 
383
        NULL_MENU_ITEM
 
384
};
 
385
 
 
386
static struct menu_item setup_menu_anon[] = {
 
387
        INIT_MENU_ITEM(N_("~Language"), NULL, ACT_NONE, menu_language_list, NULL, SUBMENU),
 
388
        INIT_MENU_ITEM(N_("C~haracter set"), NULL, ACT_NONE, charset_list, NULL, SUBMENU),
 
389
        INIT_MENU_ACTION(N_("~Terminal options"), ACT_SHOW_TERM_OPTIONS),
 
390
        NULL_MENU_ITEM
 
391
};
 
392
 
 
393
static struct menu_item tools_menu[] = {
 
394
#ifdef CONFIG_GLOBHIST
 
395
        INIT_MENU_ACTION(N_("Global ~history"), ACT_HISTORY_MANAGER),
 
396
#endif
 
397
#ifdef CONFIG_BOOKMARKS
 
398
        INIT_MENU_ACTION(N_("~Bookmarks"), ACT_BOOKMARK_MANAGER),
 
399
#endif
 
400
        INIT_MENU_ACTION(N_("~Cache"), ACT_CACHE_MANAGER),
 
401
        INIT_MENU_ACTION(N_("~Downloads"), ACT_DOWNLOAD_MANAGER),
 
402
#ifdef CONFIG_COOKIES
 
403
        INIT_MENU_ACTION(N_("Coo~kies"), ACT_COOKIE_MANAGER),
 
404
#endif
 
405
#ifdef CONFIG_FORMHIST
 
406
        INIT_MENU_ACTION(N_("~Form history"), ACT_FORMHIST_MANAGER),
 
407
#endif
 
408
        NULL_MENU_ITEM
 
409
};
 
410
 
 
411
static void
 
412
do_setup_menu(struct terminal *term, void *xxx, struct session *ses)
 
413
{
 
414
        if (!get_opt_int_tree(cmdline_options, "anonymous"))
 
415
                do_menu(term, setup_menu, ses, 1);
 
416
        else
 
417
                do_menu(term, setup_menu_anon, ses, 1);
 
418
}
 
419
 
 
420
static struct menu_item main_menu[] = {
 
421
        INIT_MENU_ITEM(N_("~File"), NULL, ACT_NONE, do_file_menu, NULL, FREE_LIST | SUBMENU),
 
422
        INIT_MENU_ITEM(N_("~View"), NULL, ACT_NONE, do_submenu, view_menu, FREE_LIST | SUBMENU),
 
423
        INIT_MENU_ITEM(N_("~Link"), NULL, ACT_NONE, link_menu, NULL, FREE_LIST | SUBMENU),
 
424
        INIT_MENU_ITEM(N_("~Tools"), NULL, ACT_NONE, do_submenu, tools_menu, FREE_LIST | SUBMENU),
 
425
        INIT_MENU_ITEM(N_("~Setup"), NULL, ACT_NONE, do_setup_menu, NULL, FREE_LIST | SUBMENU),
 
426
        INIT_MENU_ITEM(N_("~Help"), NULL, ACT_NONE, do_submenu, help_menu, FREE_LIST | SUBMENU),
 
427
        NULL_MENU_ITEM
 
428
};
 
429
 
 
430
void
 
431
activate_bfu_technology(struct session *ses, int item)
 
432
{
 
433
        do_mainmenu(ses->tab->term, main_menu, ses, item);
 
434
}
 
435
 
 
436
 
 
437
void
 
438
dialog_goto_url(struct session *ses, char *url)
 
439
{
 
440
        input_field(ses->tab->term, NULL, 1,
 
441
                    N_("Go to URL"), N_("Enter URL"),
 
442
                    N_("OK"), N_("Cancel"), ses, &goto_url_history,
 
443
                    MAX_STR_LEN, url, 0, 0, NULL,
 
444
                    (void (*)(void *, unsigned char *)) goto_url_with_hook,
 
445
                    NULL);
 
446
}
 
447
 
 
448
static struct input_history file_history = {
 
449
        /* items: */    { D_LIST_HEAD(file_history.entries) },
 
450
        /* size: */     0,
 
451
        /* dirty: */    0,
 
452
        /* nosave: */   0,
 
453
};
 
454
 
 
455
void
 
456
query_file(struct session *ses, unsigned char *url, void *data,
 
457
           void (*std)(void *, unsigned char *),
 
458
           void (*cancel)(void *), int interactive)
 
459
{
 
460
        struct string def;
 
461
 
 
462
        if (!init_string(&def)) return;
 
463
 
 
464
        add_to_string(&def, get_opt_str("document.download.directory"));
 
465
        if (def.length && !dir_sep(def.source[def.length - 1]))
 
466
                add_char_to_string(&def, '/');
 
467
 
 
468
        add_string_uri_filename_to_string(&def, url);
 
469
 
 
470
        if (interactive) {
 
471
                input_field(ses->tab->term, NULL, 1,
 
472
                            N_("Download"), N_("Save to file"),
 
473
                            N_("OK"),  N_("Cancel"), data, &file_history,
 
474
                            MAX_STR_LEN, def.source, 0, 0, NULL,
 
475
                            (void (*)(void *, unsigned char *)) std,
 
476
                            (void (*)(void *)) cancel);
 
477
        } else {
 
478
                std(data, def.source);
 
479
        }
 
480
 
 
481
        done_string(&def);
 
482
}
 
483
 
 
484
void
 
485
free_history_lists(void)
 
486
{
 
487
        free_list(goto_url_history.entries);
 
488
        free_list(file_history.entries);
 
489
#ifdef HAVE_SCRIPTING
 
490
        trigger_event_name("free-history");
 
491
#endif
 
492
}