?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add link coloring after visiting it.
[xxxterm.git] / xxxterm.c
blobfddf2691346259ecb62fd42046c3733cf672bb98
1 /*
2 * Copyright (c) 2010, 2011 Marco Peereboom <marco@peereboom.us>
3 * Copyright (c) 2011 Stevan Andjelkovic <stevan@student.chalmers.se>
4 * Copyright (c) 2010, 2011 Edd Barrett <vext01@gmail.com>
5 * Copyright (c) 2011 Todd T. Fries <todd@fries.net>
6 * Copyright (c) 2011 Raphael Graf <r@undefined.ch>
7 * Copyright (c) 2011 Michal Mazurek <akfaew@jasminek.net>
8 *
9 * Permission to use, copy, modify, and distribute this software for any
10 * purpose with or without fee is hereby granted, provided that the above
11 * copyright notice and this permission notice appear in all copies.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 */
21
22 #include "xxxterm.h"
23
24 char *version = XXXTERM_VERSION;
25
26 /*#ifdef XT_DEBUG*/
27 u_int32_t swm_debug = 0
28 /*
29 | XT_D_MOVE
30 | XT_D_KEY
31 | XT_D_TAB
32 | XT_D_URL
33 | XT_D_CMD
34 | XT_D_NAV
35 | XT_D_DOWNLOAD
36 | XT_D_CONFIG
37 | XT_D_JS
38 | XT_D_FAVORITE
39 | XT_D_PRINTING
40 | XT_D_COOKIE
41 | XT_D_KEYBINDING
42 | XT_D_CLIP
43 | XT_D_BUFFERCMD
44 | XT_D_INSPECTOR
45 */
46 | XT_D_VISITED
47 | XT_D_HISTORY
48 ;
49 #endif
50
51 #ifdef USE_THREADS
52 GCRY_THREAD_OPTION_PTHREAD_IMPL;
53 #endif
54
55 char *icons[] = {
56 "xxxtermicon16.png",
57 "xxxtermicon32.png",
58 "xxxtermicon48.png",
59 "xxxtermicon64.png",
60 "xxxtermicon128.png"
61 };
62
63 struct session {
64 TAILQ_ENTRY(session) entry;
65 const gchar *name;
66 };
67 TAILQ_HEAD(session_list, session);
68
69 struct undo {
70 TAILQ_ENTRY(undo) entry;
71 gchar *uri;
72 GList *history;
73 int back; /* Keeps track of how many back
74 * history items there are. */
75 };
76 TAILQ_HEAD(undo_tailq, undo);
77
78 struct command_entry {
79 char *line;
80 TAILQ_ENTRY(command_entry) entry;
81 };
82 TAILQ_HEAD(command_list, command_entry);
83
84 /* defines */
85 #define XT_DIR (".xxxterm")
86 #define XT_CACHE_DIR ("cache")
87 #define XT_CERT_DIR ("certs/")
88 #define XT_JS_DIR ("js/")
89 #define XT_SESSIONS_DIR ("sessions/")
90 #define XT_CONF_FILE ("xxxterm.conf")
91 #define XT_QMARKS_FILE ("quickmarks")
92 #define XT_SAVED_TABS_FILE ("main_session")
93 #define XT_RESTART_TABS_FILE ("restart_tabs")
94 #define XT_SOCKET_FILE ("socket")
95 #define XT_HISTORY_FILE ("history")
96 #define XT_SAVE_SESSION_ID ("SESSION_NAME=")
97 #define XT_SEARCH_FILE ("search_history")
98 #define XT_COMMAND_FILE ("command_history")
99 #define XT_DLMAN_REFRESH "10"
100 #define XT_MAX_URL_LENGTH (4096) /* 1 page is atomic, don't make bigger */
101 #define XT_MAX_UNDO_CLOSE_TAB (32)
102 #define XT_MAX_HL_PURGE_COUNT (1000) /* Purge the history for every
103 * MAX_HL_PURGE_COUNT items inserted into
104 * history and delete all items older
105 * than MAX_HISTORY_AGE. */
106 #define XT_MAX_HISTORY_AGE (60.0 * 60.0 * 24 * 14) /* 14 days */
107 #define XT_RESERVED_CHARS "$&+,/:;=?@ \"<>#%%{}|^~[]`"
108 #define XT_PRINT_EXTRA_MARGIN 10
109 #define XT_URL_REGEX ("^[[:blank:]]*[^[:blank:]]*([[:alnum:]-]+\\.)+[[:alnum:]-][^[:blank:]]*[[:blank:]]*$")
110 #define XT_INVALID_MARK (-1) /* XXX this is a double, maybe use something else, like a nan */
111
112 /* colors */
113 #define XT_COLOR_RED "#cc0000"
114 #define XT_COLOR_YELLOW "#ffff66"
115 #define XT_COLOR_BLUE "lightblue"
116 #define XT_COLOR_GREEN "#99ff66"
117 #define XT_COLOR_WHITE "white"
118 #define XT_COLOR_BLACK "black"
119
120 #define XT_COLOR_CT_BACKGROUND "#000000"
121 #define XT_COLOR_CT_INACTIVE "#dddddd"
122 #define XT_COLOR_CT_ACTIVE "#bbbb00"
123 #define XT_COLOR_CT_SEPARATOR "#555555"
124
125 #define XT_COLOR_SB_SEPARATOR "#555555"
126
127 #define XT_PROTO_DELIM "://"
128
129 /* actions */
130 #define XT_MOVE_INVALID (0)
131 #define XT_MOVE_DOWN (1)
132 #define XT_MOVE_UP (2)
133 #define XT_MOVE_BOTTOM (3)
134 #define XT_MOVE_TOP (4)
135 #define XT_MOVE_PAGEDOWN (5)
136 #define XT_MOVE_PAGEUP (6)
137 #define XT_MOVE_HALFDOWN (7)
138 #define XT_MOVE_HALFUP (8)
139 #define XT_MOVE_LEFT (9)
140 #define XT_MOVE_FARLEFT (10)
141 #define XT_MOVE_RIGHT (11)
142 #define XT_MOVE_FARRIGHT (12)
143 #define XT_MOVE_PERCENT (13)
144 #define XT_MOVE_CENTER (14)
145
146 #define XT_QMARK_SET (0)
147 #define XT_QMARK_OPEN (1)
148 #define XT_QMARK_TAB (2)
149
150 #define XT_MARK_SET (0)
151 #define XT_MARK_GOTO (1)
152
153 #define XT_TAB_LAST (-4)
154 #define XT_TAB_FIRST (-3)
155 #define XT_TAB_PREV (-2)
156 #define XT_TAB_NEXT (-1)
157 #define XT_TAB_INVALID (0)
158 #define XT_TAB_NEW (1)
159 #define XT_TAB_DELETE (2)
160 #define XT_TAB_DELQUIT (3)
161 #define XT_TAB_OPEN (4)
162 #define XT_TAB_UNDO_CLOSE (5)
163 #define XT_TAB_SHOW (6)
164 #define XT_TAB_HIDE (7)
165 #define XT_TAB_NEXTSTYLE (8)
166
167 #define XT_NAV_INVALID (0)
168 #define XT_NAV_BACK (1)
169 #define XT_NAV_FORWARD (2)
170 #define XT_NAV_RELOAD (3)
171 #define XT_NAV_STOP (4)
172
173 #define XT_FOCUS_INVALID (0)
174 #define XT_FOCUS_URI (1)
175 #define XT_FOCUS_SEARCH (2)
176
177 #define XT_SEARCH_INVALID (0)
178 #define XT_SEARCH_NEXT (1)
179 #define XT_SEARCH_PREV (2)
180
181 #define XT_PASTE_CURRENT_TAB (0)
182 #define XT_PASTE_NEW_TAB (1)
183
184 #define XT_ZOOM_IN (-1)
185 #define XT_ZOOM_OUT (-2)
186 #define XT_ZOOM_NORMAL (100)
187
188 #define XT_URL_SHOW (1)
189 #define XT_URL_HIDE (2)
190
191 #define XT_CMD_OPEN (0)
192 #define XT_CMD_OPEN_CURRENT (1)
193 #define XT_CMD_TABNEW (2)
194 #define XT_CMD_TABNEW_CURRENT (3)
195
196 #define XT_STATUS_NOTHING (0)
197 #define XT_STATUS_LINK (1)
198 #define XT_STATUS_URI (2)
199 #define XT_STATUS_LOADING (3)
200
201 #define XT_SES_DONOTHING (0)
202 #define XT_SES_CLOSETABS (1)
203
204 #define XT_PREFIX (1<<0)
205 #define XT_USERARG (1<<1)
206 #define XT_URLARG (1<<2)
207 #define XT_INTARG (1<<3)
208 #define XT_SESSARG (1<<4)
209 #define XT_SETARG (1<<5)
210
211 #define XT_HINT_NEWTAB (1<<0)
212
213 #define XT_BUFCMD_SZ (8)
214
215 #define XT_EJS_SHOW (1<<0)
216
217 GtkWidget * create_button(char *, char *, int);
218
219 void recalc_tabs(void);
220 void recolor_compact_tabs(void);
221 void set_current_tab(int page_num);
222 gboolean update_statusbar_position(GtkAdjustment*, gpointer);
223 void marks_clear(struct tab *t);
224
225 /* globals */
226 extern char *__progname;
227 char **start_argv;
228 struct passwd *pwd;
229 GtkWidget *main_window;
230 GtkNotebook *notebook;
231 GtkWidget *tab_bar;
232 GtkWidget *arrow, *abtn;
233 struct tab_list tabs;
234 struct history_list hl;
235 int hl_purge_count = 0;
236 struct session_list sessions;
237 struct domain_list c_wl;
238 struct domain_list js_wl;
239 struct domain_list pl_wl;
240 struct undo_tailq undos;
241 struct keybinding_list kbl;
242 struct sp_list spl;
243 struct command_list chl;
244 struct command_list shl;
245 struct command_entry *history_at;
246 struct command_entry *search_at;
247 int undo_count;
248 int cmd_history_count = 0;
249 int search_history_count = 0;
250 char *global_search;
251 long long unsigned int blocked_cookies = 0;
252 char named_session[PATH_MAX];
253 GtkListStore *completion_model;
254 GtkListStore *buffers_store;
255
256 char *qmarks[XT_NOMARKS];
257 int btn_down; /* M1 down in any wv */
258 regex_t url_re; /* guess_search regex */
259
260 /* starts from 1 to catch atoi() failures when calling xtp_handle_dl() */
261 int next_download_id = 1;
262
263 void xxx_dir(char *);
264 int icon_size_map(int);
265 void completion_add(struct tab *);
266 void completion_add_uri(const gchar *);
267
268 void
269 history_delete(struct command_list *l, int *counter)
270 {
271 struct command_entry *c;
272
273 if (l == NULL || counter == NULL)
274 return;
275
276 c = TAILQ_LAST(l, command_list);
277 if (c == NULL)
278 return;
279
280 TAILQ_REMOVE(l, c, entry);
281 *counter -= 1;
282 g_free(c->line);
283 g_free(c);
284 }
285
286 void
287 history_add(struct command_list *list, char *file, char *l, int *counter)
288 {
289 struct command_entry *c;
290 FILE *f;
291
292 if (list == NULL || l == NULL || counter == NULL)
293 return;
294
295 /* don't add the same line */
296 c = TAILQ_FIRST(list);
297 if (c)
298 if (!strcmp(c->line + 1 /* skip space */, l))
299 return;
300
301 c = g_malloc0(sizeof *c);
302 c->line = g_strdup_printf(" %s", l);
303
304 *counter += 1;
305 TAILQ_INSERT_HEAD(list, c, entry);
306
307 if (*counter > 1000)
308 history_delete(list, counter);
309
310 if (history_autosave && file) {
311 f = fopen(file, "w");
312 if (f == NULL) {
313 show_oops(NULL, "couldn't write history %s", file);
314 return;
315 }
316
317 TAILQ_FOREACH_REVERSE(c, list, command_list, entry) {
318 c->line[0] = ' ';
319 fprintf(f, "%s\n", c->line);
320 }
321
322 fclose(f);
323 }
324 }
325
326 int
327 history_read(struct command_list *list, char *file, int *counter)
328 {
329 FILE *f;
330 char *s, line[65536];
331
332 if (list == NULL || file == NULL)
333 return (1);
334
335 f = fopen(file, "r");
336 if (f == NULL) {
337 startpage_add("couldn't open history file %s", file);
338 return (1);
339 }
340
341 for (;;) {
342 s = fgets(line, sizeof line, f);
343 if (s == NULL || feof(f) || ferror(f))
344 break;
345 if ((s = strchr(line, '\n')) == NULL) {
346 startpage_add("invalid history file %s", file);
347 fclose(f);
348 return (1);
349 }
350 *s = '\0';
351
352 history_add(list, NULL, line + 1, counter);
353 }
354
355 fclose(f);
356
357 return (0);
358 }
359
360 /* marks and quickmarks array storage.
361 * first a-z, then A-Z, then 0-9 */
362 char
363 indextomark(int i)
364 {
365 if (i < 0)
366 return (0);
367
368 if (i >= 0 && i <= 'z' - 'a')
369 return 'a' + i;
370
371 i -= 'z' - 'a' + 1;
372 if (i >= 0 && i <= 'Z' - 'A')
373 return 'A' + i;
374
375 i -= 'Z' - 'A' + 1;
376 if (i >= 10)
377 return (0);
378
379 return i + '0';
380 }
381
382 int
383 marktoindex(char m)
384 {
385 int ret = 0;
386
387 if (m >= 'a' && m <= 'z')
388 return ret + m - 'a';
389
390 ret += 'z' - 'a' + 1;
391 if (m >= 'A' && m <= 'Z')
392 return ret + m - 'A';
393
394 ret += 'Z' - 'A' + 1;
395 if (m >= '0' && m <= '9')
396 return ret + m - '0';
397
398 return (-1);
399 }
400
401
402 void
403 sigchild(int sig)
404 {
405 int saved_errno, status;
406 pid_t pid;
407
408 saved_errno = errno;
409
410 while ((pid = waitpid(WAIT_ANY, &status, WNOHANG)) != 0) {
411 if (pid == -1) {
412 if (errno == EINTR)
413 continue;
414 if (errno != ECHILD) {
415 /*
416 clog_warn("sigchild: waitpid:");
417 */
418 }
419 break;
420 }
421
422 if (WIFEXITED(status)) {
423 if (WEXITSTATUS(status) != 0) {
424 /*
425 clog_warnx("sigchild: child exit status: %d",
426 WEXITSTATUS(status));
427 */
428 }
429 } else {
430 /*
431 clog_warnx("sigchild: child is terminated abnormally");
432 */
433 }
434 }
435
436 errno = saved_errno;
437 }
438
439 int
440 is_g_object_setting(GObject *o, char *str)
441 {
442 guint n_props = 0, i;
443 GParamSpec **proplist;
444
445 if (! G_IS_OBJECT(o))
446 return (0);
447
448 proplist = g_object_class_list_properties(G_OBJECT_GET_CLASS(o),
449 &n_props);
450
451 for (i=0; i < n_props; i++) {
452 if (! strcmp(proplist[i]->name, str))
453 return (1);
454 }
455 return (0);
456 }
457
458 struct tab *
459 get_current_tab(void)
460 {
461 struct tab *t;
462
463 TAILQ_FOREACH(t, &tabs, entry) {
464 if (t->tab_id == gtk_notebook_get_current_page(notebook))
465 return (t);
466 }
467
468 warnx("%s: no current tab", __func__);
469
470 return (NULL);
471 }
472
473 void
474 set_status(struct tab *t, gchar *s, int status)
475 {
476 gchar *type = NULL;
477
478 if (s == NULL)
479 return;
480
481 switch (status) {
482 case XT_STATUS_LOADING:
483 type = g_strdup_printf("Loading: %s", s);
484 s = type;
485 break;
486 case XT_STATUS_LINK:
487 type = g_strdup_printf("Link: %s", s);
488 if (!t->status)
489 t->status = g_strdup(gtk_entry_get_text(
490 GTK_ENTRY(t->sbe.statusbar)));
491 s = type;
492 break;
493 case XT_STATUS_URI:
494 type = g_strdup_printf("%s", s);
495 if (!t->status) {
496 t->status = g_strdup(type);
497 }
498 s = type;
499 if (!t->status)
500 t->status = g_strdup(s);
501 break;
502 case XT_STATUS_NOTHING:
503 /* FALL THROUGH */
504 default:
505 break;
506 }
507 gtk_entry_set_text(GTK_ENTRY(t->sbe.statusbar), s);
508 if (type)
509 g_free(type);
510 }
511
512 void
513 hide_cmd(struct tab *t)
514 {
515 DNPRINTF(XT_D_CMD, "%s: tab %d\n", __func__, t->tab_id);
516
517 history_at = NULL; /* just in case */
518 search_at = NULL; /* just in case */
519 gtk_widget_hide(t->cmd);
520 }
521
522 void
523 show_cmd(struct tab *t)
524 {
525 DNPRINTF(XT_D_CMD, "%s: tab %d\n", __func__, t->tab_id);
526
527 history_at = NULL;
528 search_at = NULL;
529 gtk_widget_hide(t->oops);
530 gtk_widget_show(t->cmd);
531 }
532
533 void
534 hide_buffers(struct tab *t)
535 {
536 gtk_widget_hide(t->buffers);
537 gtk_list_store_clear(buffers_store);
538 }
539
540 enum {
541 COL_ID = 0,
542 COL_TITLE,
543 NUM_COLS
544 };
545
546 int
547 sort_tabs_by_page_num(struct tab ***stabs)
548 {
549 int num_tabs = 0;
550 struct tab *t;
551
552 num_tabs = gtk_notebook_get_n_pages(notebook);
553
554 *stabs = g_malloc0(num_tabs * sizeof(struct tab *));
555
556 TAILQ_FOREACH(t, &tabs, entry)
557 (*stabs)[gtk_notebook_page_num(notebook, t->vbox)] = t;
558
559 return (num_tabs);
560 }
561
562 void
563 buffers_make_list(void)
564 {
565 int i, num_tabs;
566 const gchar *title = NULL;
567 GtkTreeIter iter;
568 struct tab **stabs = NULL;
569
570 num_tabs = sort_tabs_by_page_num(&stabs);
571
572 for (i = 0; i < num_tabs; i++)
573 if (stabs[i]) {
574 gtk_list_store_append(buffers_store, &iter);
575 title = get_title(stabs[i], FALSE);
576 gtk_list_store_set(buffers_store, &iter,
577 COL_ID, i + 1, /* Enumerate the tabs starting from 1
578 * rather than 0. */
579 COL_TITLE, title,
580 -1);
581 }
582
583 g_free(stabs);
584 }
585
586 void
587 show_buffers(struct tab *t)
588 {
589 buffers_make_list();
590 gtk_widget_show(t->buffers);
591 gtk_widget_grab_focus(GTK_WIDGET(t->buffers));
592 }
593
594 void
595 toggle_buffers(struct tab *t)
596 {
597 if (gtk_widget_get_visible(t->buffers))
598 hide_buffers(t);
599 else
600 show_buffers(t);
601 }
602
603 int
604 buffers(struct tab *t, struct karg *args)
605 {
606 show_buffers(t);
607
608 return (0);
609 }
610
611 void
612 hide_oops(struct tab *t)
613 {
614 gtk_widget_hide(t->oops);
615 }
616
617 void
618 show_oops(struct tab *at, const char *fmt, ...)
619 {
620 va_list ap;
621 char *msg = NULL;
622 struct tab *t = NULL;
623
624 if (fmt == NULL)
625 return;
626
627 if (at == NULL) {
628 if ((t = get_current_tab()) == NULL)
629 return;
630 } else
631 t = at;
632
633 va_start(ap, fmt);
634 if (vasprintf(&msg, fmt, ap) == -1)
635 errx(1, "show_oops failed");
636 va_end(ap);
637
638 gtk_entry_set_text(GTK_ENTRY(t->oops), msg);
639 gtk_widget_hide(t->cmd);
640 gtk_widget_show(t->oops);
641
642 if (msg)
643 free(msg);
644 }
645
646 char work_dir[PATH_MAX];
647 char certs_dir[PATH_MAX];
648 char js_dir[PATH_MAX];
649 char cache_dir[PATH_MAX];
650 char sessions_dir[PATH_MAX];
651 char cookie_file[PATH_MAX];
652 SoupSession *session;
653 SoupCookieJar *s_cookiejar;
654 SoupCookieJar *p_cookiejar;
655 char rc_fname[PATH_MAX];
656
657 struct mime_type_list mtl;
658 struct alias_list aliases;
659
660 /* protos */
661 struct tab *create_new_tab(char *, struct undo *, int, int);
662 void delete_tab(struct tab *);
663 void setzoom_webkit(struct tab *, int);
664 int download_rb_cmp(struct download *, struct download *);
665 gboolean cmd_execute(struct tab *t, char *str);
666
667 int
668 history_rb_cmp(struct history *h1, struct history *h2)
669 {
670 return (strcmp(h1->uri, h2->uri));
671 }
672 RB_GENERATE(history_list, history, entry, history_rb_cmp);
673
674 int
675 domain_rb_cmp(struct domain *d1, struct domain *d2)
676 {
677 return (strcmp(d1->d, d2->d));
678 }
679 RB_GENERATE(domain_list, domain, entry, domain_rb_cmp);
680
681 int
682 download_rb_cmp(struct download *e1, struct download *e2)
683 {
684 return (e1->id < e2->id ? -1 : e1->id > e2->id);
685 }
686 RB_GENERATE(download_list, download, entry, download_rb_cmp);
687
688 struct valid_url_types {
689 char *type;
690 } vut[] = {
691 { "http://" },
692 { "https://" },
693 { "ftp://" },
694 { "file://" },
695 { XT_XTP_STR },
696 };
697
698 int
699 valid_url_type(char *url)
700 {
701 int i;
702
703 for (i = 0; i < LENGTH(vut); i++)
704 if (!strncasecmp(vut[i].type, url, strlen(vut[i].type)))
705 return (0);
706
707 return (1);
708 }
709
710 char *
711 match_alias(char *url_in)
712 {
713 struct alias *a;
714 char *arg;
715 char *url_out = NULL, *search, *enc_arg;
716
717 search = g_strdup(url_in);
718 arg = search;
719 if (strsep(&arg, " \t") == NULL) {
720 show_oops(NULL, "match_alias: NULL URL");
721 goto done;
722 }
723
724 TAILQ_FOREACH(a, &aliases, entry) {
725 if (!strcmp(search, a->a_name))
726 break;
727 }
728
729 if (a != NULL) {
730 DNPRINTF(XT_D_URL, "match_alias: matched alias %s\n",
731 a->a_name);
732 if (arg != NULL) {
733 enc_arg = soup_uri_encode(arg, XT_RESERVED_CHARS);
734 url_out = g_strdup_printf(a->a_uri, enc_arg);
735 g_free(enc_arg);
736 } else
737 url_out = g_strdup_printf(a->a_uri, "");
738 }
739 done:
740 g_free(search);
741 return (url_out);
742 }
743
744 char *
745 guess_url_type(char *url_in)
746 {
747 struct stat sb;
748 char *url_out = NULL, *enc_search = NULL;
749 int i;
750
751 /* substitute aliases */
752 url_out = match_alias(url_in);
753 if (url_out != NULL)
754 return (url_out);
755
756 /* see if we are an about page */
757 if (!strncmp(url_in, XT_URI_ABOUT, XT_URI_ABOUT_LEN))
758 for (i = 0; i < about_list_size(); i++)
759 if (!strcmp(&url_in[XT_URI_ABOUT_LEN],
760 about_list[i].name)) {
761 url_out = g_strdup(url_in);
762 goto done;
763 }
764
765 if (guess_search && url_regex &&
766 !(g_str_has_prefix(url_in, "http://") ||
767 g_str_has_prefix(url_in, "https://"))) {
768 if (regexec(&url_re, url_in, 0, NULL, 0)) {
769 /* invalid URI so search instead */
770 enc_search = soup_uri_encode(url_in, XT_RESERVED_CHARS);
771 url_out = g_strdup_printf(search_string, enc_search);
772 g_free(enc_search);
773 goto done;
774 }
775 }
776
777 /* XXX not sure about this heuristic */
778 if (stat(url_in, &sb) == 0)
779 url_out = g_strdup_printf("file://%s", url_in);
780 else
781 url_out = g_strdup_printf("http://%s", url_in); /* guess http */
782 done:
783 DNPRINTF(XT_D_URL, "guess_url_type: guessed %s\n", url_out);
784
785 return (url_out);
786 }
787
788 void
789 load_uri(struct tab *t, gchar *uri)
790 {
791 struct karg args;
792 gchar *newuri = NULL;
793 int i;
794
795 if (uri == NULL)
796 return;
797
798 /* Strip leading spaces. */
799 while (*uri && isspace(*uri))
800 uri++;
801
802 if (strlen(uri) == 0) {
803 blank(t, NULL);
804 return;
805 }
806
807 t->xtp_meaning = XT_XTP_TAB_MEANING_NORMAL;
808
809 if (valid_url_type(uri)) {
810 newuri = guess_url_type(uri);
811 uri = newuri;
812 }
813
814 if (!strncmp(uri, XT_URI_ABOUT, XT_URI_ABOUT_LEN)) {
815 for (i = 0; i < about_list_size(); i++)
816 if (!strcmp(&uri[XT_URI_ABOUT_LEN], about_list[i].name)) {
817 bzero(&args, sizeof args);
818 about_list[i].func(t, &args);
819 gtk_widget_set_sensitive(GTK_WIDGET(t->stop),
820 FALSE);
821 goto done;
822 }
823 show_oops(t, "invalid about page");
824 goto done;
825 }
826
827 set_status(t, (char *)uri, XT_STATUS_LOADING);
828 marks_clear(t);
829 webkit_web_view_load_uri(t->wv, uri);
830 done:
831 if (newuri)
832 g_free(newuri);
833 }
834
835 const gchar *
836 get_uri(struct tab *t)
837 {
838 const gchar *uri = NULL;
839
840 if (webkit_web_view_get_load_status(t->wv) == WEBKIT_LOAD_FAILED)
841 return (NULL);
842 if (t->xtp_meaning == XT_XTP_TAB_MEANING_NORMAL) {
843 uri = webkit_web_view_get_uri(t->wv);
844 } else {
845 /* use tmp_uri to make sure it is g_freed */
846 if (t->tmp_uri)
847 g_free(t->tmp_uri);
848 t->tmp_uri =g_strdup_printf("%s%s", XT_URI_ABOUT,
849 about_list[t->xtp_meaning].name);
850 uri = t->tmp_uri;
851 }
852 return uri;
853 }
854
855 const gchar *
856 get_title(struct tab *t, bool window)
857 {
858 const gchar *set = NULL, *title = NULL;
859 WebKitLoadStatus status = webkit_web_view_get_load_status(t->wv);
860
861 if (status == WEBKIT_LOAD_PROVISIONAL || status == WEBKIT_LOAD_FAILED ||
862 t->xtp_meaning == XT_XTP_TAB_MEANING_BL)
863 goto notitle;
864
865 title = webkit_web_view_get_title(t->wv);
866 if ((set = title ? title : get_uri(t)))
867 return set;
868
869 notitle:
870 set = window ? XT_NAME : "(untitled)";
871
872 return set;
873 }
874
875 struct mime_type *
876 find_mime_type(char *mime_type)
877 {
878 struct mime_type *m, *def = NULL, *rv = NULL;
879
880 TAILQ_FOREACH(m, &mtl, entry) {
881 if (m->mt_default &&
882 !strncmp(mime_type, m->mt_type, strlen(m->mt_type)))
883 def = m;
884
885 if (m->mt_default == 0 && !strcmp(mime_type, m->mt_type)) {
886 rv = m;
887 break;
888 }
889 }
890
891 if (rv == NULL)
892 rv = def;
893
894 return (rv);
895 }
896
897 struct domain *
898 wl_find_uri(const gchar *s, struct domain_list *wl)
899 {
900 int i;
901 char *ss;
902 struct domain *r;
903
904 if (s == NULL || wl == NULL)
905 return (NULL);
906
907 if (!strncmp(s, "http://", strlen("http://")))
908 s = &s[strlen("http://")];
909 else if (!strncmp(s, "https://", strlen("https://")))
910 s = &s[strlen("https://")];
911
912 if (strlen(s) < 2)
913 return (NULL);
914
915 for (i = 0; i < strlen(s) + 1 /* yes er need this */; i++)
916 /* chop string at first slash */
917 if (s[i] == '/' || s[i] == ':' || s[i] == '\0') {
918 ss = g_strdup(s);
919 ss[i] = '\0';
920 r = wl_find(ss, wl);
921 g_free(ss);
922 return (r);
923 }
924
925 return (NULL);
926 }
927
928 char *
929 js_ref_to_string(JSContextRef context, JSValueRef ref)
930 {
931 char *s = NULL;
932 size_t l;
933 JSStringRef jsref;
934
935 jsref = JSValueToStringCopy(context, ref, NULL);
936 if (jsref == NULL)
937 return (NULL);
938
939 l = JSStringGetMaximumUTF8CStringSize(jsref);
940 s = g_malloc(l);
941 if (s)
942 JSStringGetUTF8CString(jsref, s, l);
943 JSStringRelease(jsref);
944
945 return (s);
946 }
947
948 void
949 disable_hints(struct tab *t)
950 {
951 DNPRINTF(XT_D_JS, "%s: tab %d\n", __func__, t->tab_id);
952
953 run_script(t, "hints.clearHints();");
954 t->mode = XT_MODE_COMMAND;
955 t->new_tab = 0;
956 }
957
958 void
959 enable_hints(struct tab *t)
960 {
961 DNPRINTF(XT_D_JS, "%s: tab %d\n", __func__, t->tab_id);
962
963 if (t->new_tab)
964 run_script(t, "hints.createHints('', 'F');");
965 else
966 run_script(t, "hints.createHints('', 'f');");
967 t->mode = XT_MODE_HINT;
968 }
969
970 #define XT_JS_DONE ("done;")
971 #define XT_JS_DONE_LEN (strlen(XT_JS_DONE))
972 #define XT_JS_INSERT ("insert;")
973 #define XT_JS_INSERT_LEN (strlen(XT_JS_INSERT))
974
975 int
976 run_script(struct tab *t, char *s)
977 {
978 JSGlobalContextRef ctx;
979 WebKitWebFrame *frame;
980 JSStringRef str;
981 JSValueRef val, exception;
982 char *es;
983
984 DNPRINTF(XT_D_JS, "run_script: tab %d %s\n",
985 t->tab_id, s == (char *)JS_HINTING ? "JS_HINTING" : s);
986
987 frame = webkit_web_view_get_main_frame(t->wv);
988 ctx = webkit_web_frame_get_global_context(frame);
989
990 str = JSStringCreateWithUTF8CString(s);
991 val = JSEvaluateScript(ctx, str, JSContextGetGlobalObject(ctx),
992 NULL, 0, &exception);
993 JSStringRelease(str);
994
995 DNPRINTF(XT_D_JS, "run_script: val %p\n", val);
996 if (val == NULL) {
997 es = js_ref_to_string(ctx, exception);
998 if (es) {
999 /* show_oops(t, "script exception: %s", es); */
1000 DNPRINTF(XT_D_JS, "run_script: exception %s\n", es);
1001 g_free(es);
1002 }
1003 return (1);
1004 } else {
1005 es = js_ref_to_string(ctx, val);
1006 #if 0
1007 /* return values */
1008 if (!strncmp(es, XT_JS_DONE, XT_JS_DONE_LEN))
1009 ; /* do nothing */
1010 if (!strncmp(es, XT_JS_INSERT, XT_JS_INSERT_LEN))
1011 ; /* do nothing */
1012 #endif
1013 if (es) {
1014 DNPRINTF(XT_D_JS, "run_script: val %s\n", es);
1015 g_free(es);
1016 }
1017 }
1018
1019 return (0);
1020 }
1021
1022 int
1023 hint(struct tab *t, struct karg *args)
1024 {
1025
1026 DNPRINTF(XT_D_JS, "hint: tab %d args %d\n", t->tab_id, args->i);
1027
1028 if (t->mode == XT_MODE_HINT) {
1029 if (args->i == XT_HINT_NEWTAB)
1030 t->new_tab = 1;
1031 enable_hints(t);
1032 } else
1033 disable_hints(t);
1034
1035 return (0);
1036 }
1037
1038 void
1039 apply_style(struct tab *t)
1040 {
1041 g_object_set(G_OBJECT(t->settings),
1042 "user-stylesheet-uri", t->stylesheet, (char *)NULL);
1043 }
1044
1045 int
1046 userstyle(struct tab *t, struct karg *args)
1047 {
1048 DNPRINTF(XT_D_JS, "userstyle: tab %d\n", t->tab_id);
1049
1050 if (t->styled) {
1051 t->styled = 0;
1052 g_object_set(G_OBJECT(t->settings),
1053 "user-stylesheet-uri", NULL, (char *)NULL);
1054 } else {
1055 t->styled = 1;
1056 apply_style(t);
1057 }
1058 return (0);
1059 }
1060
1061 int
1062 purge_history(void)
1063 {
1064 struct history *h, *next;
1065 double age = 0.0;
1066
1067 DNPRINTF(XT_D_HISTORY, "%s: hl_purge_count = %d (%d is max)\n",
1068 __func__, hl_purge_count, XT_MAX_HL_PURGE_COUNT);
1069
1070 if (hl_purge_count == XT_MAX_HL_PURGE_COUNT) {
1071 hl_purge_count = 0;
1072
1073 for (h = RB_MIN(history_list, &hl); h != NULL; h = next) {
1074
1075 next = RB_NEXT(history_list, &hl, h);
1076
1077 age = difftime(time(NULL), h->time);
1078
1079 if (age > XT_MAX_HISTORY_AGE) {
1080 DNPRINTF(XT_D_HISTORY, "%s: removing %s (age %.1f)\n",
1081 __func__, h->uri, age);
1082
1083 RB_REMOVE(history_list, &hl, h);
1084 g_free(h->uri);
1085 g_free(h->title);
1086 g_free(h);
1087 } else {
1088 DNPRINTF(XT_D_HISTORY, "%s: keeping %s (age %.1f)\n",
1089 __func__, h->uri, age);
1090 }
1091 }
1092 }
1093
1094 return (0);
1095 }
1096
1097 int
1098 insert_history_item(const gchar *uri, const gchar *title, time_t time)
1099 {
1100 struct history *h;
1101
1102 if (!(uri && strlen(uri) && title && strlen(title)))
1103 return (1);
1104
1105 h = g_malloc(sizeof(struct history));
1106 h->uri = g_strdup(uri);
1107 h->title = g_strdup(title);
1108 h->time = time;
1109
1110 DNPRINTF(XT_D_HISTORY, "%s: adding %s\n", __func__, h->uri);
1111
1112 RB_INSERT(history_list, &hl, h);
1113 completion_add_uri(h->uri);
1114 hl_purge_count++;
1115
1116 purge_history();
1117 update_history_tabs(NULL);
1118
1119 return (0);
1120 }
1121
1122 int
1123 restore_global_history(void)
1124 {
1125 char file[PATH_MAX];
1126 FILE *f;
1127 gchar *uri, *title, *stime, *err = NULL;
1128 time_t time;
1129 struct tm tm;
1130 const char delim[3] = {'\\', '\\', '\0'};
1131
1132 snprintf(file, sizeof file, "%s/%s", work_dir, XT_HISTORY_FILE);
1133
1134 if ((f = fopen(file, "r")) == NULL) {
1135 warnx("%s: fopen", __func__);
1136 return (1);
1137 }
1138
1139 for (;;) {
1140 if ((uri = fparseln(f, NULL, NULL, delim, 0)) == NULL)
1141 if (feof(f) || ferror(f))
1142 break;
1143
1144 if ((title = fparseln(f, NULL, NULL, delim, 0)) == NULL)
1145 if (feof(f) || ferror(f)) {
1146 err = "broken history file (title)";
1147 goto done;
1148 }
1149
1150 if ((stime = fparseln(f, NULL, NULL, delim, 0)) == NULL)
1151 if (feof(f) || ferror(f)) {
1152 err = "broken history file (time)";
1153 goto done;
1154 }
1155
1156 if (strptime(stime, "%a %b %d %H:%M:%S %Y", &tm) == NULL) {
1157 err = "strptime failed to parse time";
1158 goto done;
1159 }
1160
1161 time = mktime(&tm);
1162
1163 if (insert_history_item(uri, title, time)) {
1164 err = "failed to insert item";
1165 goto done;
1166 }
1167
1168 free(uri);
1169 free(title);
1170 free(stime);
1171 uri = NULL;
1172 title = NULL;
1173 stime = NULL;
1174 }
1175
1176 done:
1177 if (err && strlen(err)) {
1178 warnx("%s: %s\n", __func__, err);
1179 free(uri);
1180 free(title);
1181 free(stime);
1182
1183 return (1);
1184 }
1185
1186 return (0);
1187 }
1188
1189 int
1190 save_global_history_to_disk(struct tab *t)
1191 {
1192 char file[PATH_MAX];
1193 FILE *f;
1194 struct history *h;
1195
1196 snprintf(file, sizeof file, "%s/%s", work_dir, XT_HISTORY_FILE);
1197
1198 if ((f = fopen(file, "w")) == NULL) {
1199 show_oops(t, "%s: global history file: %s",
1200 __func__, strerror(errno));
1201 return (1);
1202 }
1203
1204 RB_FOREACH_REVERSE(h, history_list, &hl) {
1205 if (h->uri && h->title && h->time)
1206 fprintf(f, "%s\n%s\n%s", h->uri, h->title,
1207 ctime(&h->time));
1208 }
1209
1210 fclose(f);
1211
1212 return (0);
1213 }
1214
1215 int
1216 quit(struct tab *t, struct karg *args)
1217 {
1218 if (save_global_history)
1219 save_global_history_to_disk(t);
1220
1221 gtk_main_quit();
1222
1223 return (1);
1224 }
1225
1226 void
1227 restore_sessions_list(void)
1228 {
1229 DIR *sdir = NULL;
1230 struct dirent *dp = NULL;
1231 struct session *s;
1232
1233 sdir = opendir(sessions_dir);
1234 if (sdir) {
1235 while ((dp = readdir(sdir)) != NULL)
1236 if (dp->d_type == DT_REG) {
1237 s = g_malloc(sizeof(struct session));
1238 s->name = g_strdup(dp->d_name);
1239 TAILQ_INSERT_TAIL(&sessions, s, entry);
1240 }
1241 closedir(sdir);
1242 }
1243 }
1244
1245 int
1246 open_tabs(struct tab *t, struct karg *a)
1247 {
1248 char file[PATH_MAX];
1249 FILE *f = NULL;
1250 char *uri = NULL;
1251 int rv = 1;
1252 struct tab *ti, *tt;
1253
1254 if (a == NULL)
1255 goto done;
1256
1257 ti = TAILQ_LAST(&tabs, tab_list);
1258
1259 snprintf(file, sizeof file, "%s/%s", sessions_dir, a->s);
1260 if ((f = fopen(file, "r")) == NULL)
1261 goto done;
1262
1263 for (;;) {
1264 if ((uri = fparseln(f, NULL, NULL, "\0\0\0", 0)) == NULL)
1265 if (feof(f) || ferror(f))
1266 break;
1267
1268 /* retrieve session name */
1269 if (uri && g_str_has_prefix(uri, XT_SAVE_SESSION_ID)) {
1270 strlcpy(named_session,
1271 &uri[strlen(XT_SAVE_SESSION_ID)],
1272 sizeof named_session);
1273 continue;
1274 }
1275
1276 if (uri && strlen(uri))
1277 create_new_tab(uri, NULL, 1, -1);
1278
1279 free(uri);
1280 uri = NULL;
1281 }
1282
1283 /* close open tabs */
1284 if (a->i == XT_SES_CLOSETABS && ti != NULL) {
1285 for (;;) {
1286 tt = TAILQ_FIRST(&tabs);
1287 if (tt == NULL)
1288 break;
1289 if (tt != ti) {
1290 delete_tab(tt);
1291 continue;
1292 }
1293 delete_tab(tt);
1294 break;
1295 }
1296 }
1297
1298 rv = 0;
1299 done:
1300 if (f)
1301 fclose(f);
1302
1303 return (rv);
1304 }
1305
1306 int
1307 restore_saved_tabs(void)
1308 {
1309 char file[PATH_MAX];
1310 int unlink_file = 0;
1311 struct stat sb;
1312 struct karg a;
1313 int rv = 0;
1314
1315 snprintf(file, sizeof file, "%s/%s",
1316 sessions_dir, XT_RESTART_TABS_FILE);
1317 if (stat(file, &sb) == -1)
1318 a.s = XT_SAVED_TABS_FILE;
1319 else {
1320 unlink_file = 1;
1321 a.s = XT_RESTART_TABS_FILE;
1322 }
1323
1324 a.i = XT_SES_DONOTHING;
1325 rv = open_tabs(NULL, &a);
1326
1327 if (unlink_file)
1328 unlink(file);
1329
1330 return (rv);
1331 }
1332
1333 int
1334 save_tabs(struct tab *t, struct karg *a)
1335 {
1336 char file[PATH_MAX];
1337 FILE *f;
1338 int num_tabs = 0, i;
1339 struct tab **stabs = NULL;
1340
1341 /* tab may be null here */
1342
1343 if (a == NULL)
1344 return (1);
1345 if (a->s == NULL)
1346 snprintf(file, sizeof file, "%s/%s",
1347 sessions_dir, named_session);
1348 else
1349 snprintf(file, sizeof file, "%s/%s", sessions_dir, a->s);
1350
1351 if ((f = fopen(file, "w")) == NULL) {
1352 show_oops(t, "Can't open save_tabs file: %s", strerror(errno));
1353 return (1);
1354 }
1355
1356 /* save session name */
1357 fprintf(f, "%s%s\n", XT_SAVE_SESSION_ID, named_session);
1358
1359 /* Save tabs, in the order they are arranged in the notebook. */
1360 num_tabs = sort_tabs_by_page_num(&stabs);
1361
1362 for (i = 0; i < num_tabs; i++)
1363 if (stabs[i]) {
1364 if (get_uri(stabs[i]) != NULL)
1365 fprintf(f, "%s\n", get_uri(stabs[i]));
1366 else if (gtk_entry_get_text(GTK_ENTRY(
1367 stabs[i]->uri_entry)))
1368 fprintf(f, "%s\n", gtk_entry_get_text(GTK_ENTRY(
1369 stabs[i]->uri_entry)));
1370 }
1371
1372 g_free(stabs);
1373
1374 /* try and make sure this gets to disk NOW. XXX Backup first? */
1375 if (fflush(f) != 0 || fsync(fileno(f)) != 0) {
1376 show_oops(t, "May not have managed to save session: %s",
1377 strerror(errno));
1378 }
1379
1380 fclose(f);
1381
1382 return (0);
1383 }
1384
1385 int
1386 save_tabs_and_quit(struct tab *t, struct karg *args)
1387 {
1388 struct karg a;
1389
1390 a.s = NULL;
1391 save_tabs(t, &a);
1392 quit(t, NULL);
1393
1394 return (1);
1395 }
1396
1397 /* Marshall the internal record of visited URIs into a Javascript hash table in
1398 * string form. */
1399 char *
1400 color_visited_helper(void)
1401 {
1402 char *s = NULL;
1403 struct history *h;
1404
1405 RB_FOREACH_REVERSE(h, history_list, &hl) {
1406 if (s == NULL)
1407 s = g_strdup_printf("'%s':'dummy'", h->uri);
1408 else
1409 s = g_strjoin(",", s,
1410 g_strdup_printf("'%s':'dummy'", h->uri), NULL);
1411 }
1412
1413 s = g_strdup_printf("{%s}", s);
1414
1415 DNPRINTF(XT_D_VISITED, "%s: s = %s\n", __func__, s);
1416
1417 return (s);
1418 }
1419
1420 int
1421 color_visited(struct tab *t, char *visited)
1422 {
1423 char *s;
1424
1425 if (t == NULL || visited == NULL) {
1426 show_oops(NULL, "%s: invalid parameters", __func__);
1427 return (1);
1428 }
1429
1430 /* Create a string representing an annonymous Javascript function, which
1431 * takes a hash table of visited URIs as an argument, goes through the
1432 * links at the current web page and colors them if they indeed been
1433 * visited.
1434 */
1435 s = g_strconcat(
1436 "(function(visitedUris) {",
1437 " for (var i = 0; i < document.links.length; i++)",
1438 " if (visitedUris[document.links[i].href])",
1439 " document.links[i].style.color = 'purple';",
1440 "})",
1441 /* Apply the annonymous function to the hash table containing
1442 * visited URIs. */
1443 g_strdup_printf("(%s);", visited),
1444 NULL);
1445
1446 run_script(t, s);
1447 g_free(s);
1448 g_free(visited);
1449
1450 return (0);
1451 }
1452
1453 int
1454 run_page_script(struct tab *t, struct karg *args)
1455 {
1456 const gchar *uri;
1457 char *tmp, script[PATH_MAX];
1458
1459 tmp = args->s != NULL && strlen(args->s) > 0 ? args->s : default_script;
1460 if (tmp[0] == '\0') {
1461 show_oops(t, "no script specified");
1462 return (1);
1463 }
1464
1465 if ((uri = get_uri(t)) == NULL) {
1466 show_oops(t, "tab is empty, not running script");
1467 return (1);
1468 }
1469
1470 if (tmp[0] == '~')
1471 snprintf(script, sizeof script, "%s/%s",
1472 pwd->pw_dir, &tmp[1]);
1473 else
1474 strlcpy(script, tmp, sizeof script);
1475
1476 switch (fork()) {
1477 case -1:
1478 show_oops(t, "can't fork to run script");
1479 return (1);
1480 /* NOTREACHED */
1481 case 0:
1482 break;
1483 default:
1484 return (0);
1485 }
1486
1487 /* child */
1488 execlp(script, script, uri, (void *)NULL);
1489
1490 _exit(0);
1491
1492 /* NOTREACHED */
1493
1494 return (0);
1495 }
1496
1497 int
1498 yank_uri(struct tab *t, struct karg *args)
1499 {
1500 const gchar *uri;
1501 GtkClipboard *clipboard;
1502
1503 if ((uri = get_uri(t)) == NULL)
1504 return (1);
1505
1506 clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
1507 gtk_clipboard_set_text(clipboard, uri, -1);
1508
1509 return (0);
1510 }
1511
1512 int
1513 paste_uri(struct tab *t, struct karg *args)
1514 {
1515 GtkClipboard *clipboard;
1516 GdkAtom atom = gdk_atom_intern("CUT_BUFFER0", FALSE);
1517 gint len;
1518 gchar *p = NULL, *uri;
1519
1520 /* try primary clipboard first */
1521 clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
1522 p = gtk_clipboard_wait_for_text(clipboard);
1523
1524 /* if it failed get whatever text is in cut_buffer0 */
1525 if (p == NULL && xterm_workaround)
1526 if (gdk_property_get(gdk_get_default_root_window(),
1527 atom,
1528 gdk_atom_intern("STRING", FALSE),
1529 0,
1530 1024 * 1024 /* picked out of my butt */,
1531 FALSE,
1532 NULL,
1533 NULL,
1534 &len,
1535 (guchar **)&p)) {
1536 /* yes sir, we need to NUL the string */
1537 p[len] = '\0';
1538 }
1539
1540 if (p) {
1541 uri = p;
1542 while (*uri && isspace(*uri))
1543 uri++;
1544 if (strlen(uri) == 0) {
1545 show_oops(t, "empty paste buffer");
1546 goto done;
1547 }
1548 if (guess_search == 0 && valid_url_type(uri)) {
1549 /* we can be clever and paste this in search box */
1550 show_oops(t, "not a valid URL");
1551 goto done;
1552 }
1553
1554 if (args->i == XT_PASTE_CURRENT_TAB)
1555 load_uri(t, uri);
1556 else if (args->i == XT_PASTE_NEW_TAB)
1557 create_new_tab(uri, NULL, 1, -1);
1558 }
1559
1560 done:
1561 if (p)
1562 g_free(p);
1563
1564 return (0);
1565 }
1566
1567 void
1568 js_toggle_cb(GtkWidget *w, struct tab *t)
1569 {
1570 struct karg a;
1571 int es, set;
1572
1573 g_object_get(G_OBJECT(t->settings),
1574 "enable-scripts", &es, (char *)NULL);
1575 es = !es;
1576 if (es)
1577 set = XT_WL_ENABLE;
1578 else
1579 set = XT_WL_DISABLE;
1580
1581 a.i = set | XT_WL_TOPLEVEL;
1582 toggle_pl(t, &a);
1583
1584 a.i = set | XT_WL_TOPLEVEL;
1585 toggle_cwl(t, &a);
1586
1587 a.i = XT_WL_TOGGLE | XT_WL_TOPLEVEL | XT_WL_RELOAD;
1588 toggle_js(t, &a);
1589 }
1590
1591 int
1592 toggle_src(struct tab *t, struct karg *args)
1593 {
1594 gboolean mode;
1595
1596 if (t == NULL)
1597 return (0);
1598
1599 mode = webkit_web_view_get_view_source_mode(t->wv);
1600 webkit_web_view_set_view_source_mode(t->wv, !mode);
1601 webkit_web_view_reload(t->wv);
1602
1603 return (0);
1604 }
1605
1606 void
1607 focus_webview(struct tab *t)
1608 {
1609 if (t == NULL)
1610 return;
1611
1612 /* only grab focus if we are visible */
1613 if (gtk_notebook_get_current_page(notebook) == t->tab_id)
1614 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
1615 }
1616
1617 int
1618 focus(struct tab *t, struct karg *args)
1619 {
1620 if (t == NULL || args == NULL)
1621 return (1);
1622
1623 if (show_url == 0)
1624 return (0);
1625
1626 if (args->i == XT_FOCUS_URI)
1627 gtk_widget_grab_focus(GTK_WIDGET(t->uri_entry));
1628 else if (args->i == XT_FOCUS_SEARCH)
1629 gtk_widget_grab_focus(GTK_WIDGET(t->search_entry));
1630
1631 return (0);
1632 }
1633
1634 int
1635 connect_socket_from_uri(const gchar *uri, const gchar **error_str, char *domain,
1636 size_t domain_sz)
1637 {
1638 SoupURI *su = NULL;
1639 struct addrinfo hints, *res = NULL, *ai;
1640 int rv = -1, s = -1, on, error;
1641 char port[8];
1642 static gchar myerror[256]; /* this is not thread safe */
1643
1644 myerror[0] = '\0';
1645 *error_str = myerror;
1646 if (uri && !g_str_has_prefix(uri, "https://")) {
1647 *error_str = "invalid URI";
1648 goto done;
1649 }
1650
1651 su = soup_uri_new(uri);
1652 if (su == NULL) {
1653 *error_str = "invalid soup URI";
1654 goto done;
1655 }
1656 if (!SOUP_URI_VALID_FOR_HTTP(su)) {
1657 *error_str = "invalid HTTPS URI";
1658 goto done;
1659 }
1660
1661 snprintf(port, sizeof port, "%d", su->port);
1662 bzero(&hints, sizeof(struct addrinfo));
1663 hints.ai_flags = AI_CANONNAME;
1664 hints.ai_family = AF_UNSPEC;
1665 hints.ai_socktype = SOCK_STREAM;
1666
1667 if ((error = getaddrinfo(su->host, port, &hints, &res))) {
1668 snprintf(myerror, sizeof myerror, "getaddrinfo failed: %s",
1669 gai_strerror(errno));
1670 goto done;
1671 }
1672
1673 for (ai = res; ai; ai = ai->ai_next) {
1674 if (s != -1) {
1675 close(s);
1676 s = -1;
1677 }
1678
1679 if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6)
1680 continue;
1681 s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
1682 if (s == -1)
1683 continue;
1684 if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on,
1685 sizeof(on)) == -1)
1686 continue;
1687 if (connect(s, ai->ai_addr, ai->ai_addrlen) == 0)
1688 break;
1689 }
1690 if (s == -1) {
1691 snprintf(myerror, sizeof myerror,
1692 "could not obtain certificates from: %s",
1693 su->host);
1694 goto done;
1695 }
1696
1697 if (domain)
1698 strlcpy(domain, su->host, domain_sz);
1699 rv = s;
1700 done:
1701 if (su)
1702 soup_uri_free(su);
1703 if (res)
1704 freeaddrinfo(res);
1705 if (rv == -1 && s != -1)
1706 close(s);
1707
1708 return (rv);
1709 }
1710
1711 int
1712 stop_tls(gnutls_session_t gsession, gnutls_certificate_credentials_t xcred)
1713 {
1714 if (gsession)
1715 gnutls_deinit(gsession);
1716 if (xcred)
1717 gnutls_certificate_free_credentials(xcred);
1718
1719 return (0);
1720 }
1721
1722 int
1723 start_tls(const gchar **error_str, int s, gnutls_session_t *gs,
1724 gnutls_certificate_credentials_t *xc)
1725 {
1726 gnutls_certificate_credentials_t xcred;
1727 gnutls_session_t gsession;
1728 int rv = 1;
1729 static gchar myerror[1024]; /* this is not thread safe */
1730
1731 if (gs == NULL || xc == NULL)
1732 goto done;
1733
1734 myerror[0] = '\0';
1735 *gs = NULL;
1736 *xc = NULL;
1737
1738 gnutls_certificate_allocate_credentials(&xcred);
1739 gnutls_certificate_set_x509_trust_file(xcred, ssl_ca_file,
1740 GNUTLS_X509_FMT_PEM);
1741
1742 gnutls_init(&gsession, GNUTLS_CLIENT);
1743 gnutls_priority_set_direct(gsession, "PERFORMANCE", NULL);
1744 gnutls_credentials_set(gsession, GNUTLS_CRD_CERTIFICATE, xcred);
1745 gnutls_transport_set_ptr(gsession, (gnutls_transport_ptr_t)(long)s);
1746 if ((rv = gnutls_handshake(gsession)) < 0) {
1747 snprintf(myerror, sizeof myerror,
1748 "gnutls_handshake failed %d fatal %d %s",
1749 rv,
1750 gnutls_error_is_fatal(rv),
1751 gnutls_strerror_name(rv));
1752 stop_tls(gsession, xcred);
1753 goto done;
1754 }
1755
1756 gnutls_credentials_type_t cred;
1757 cred = gnutls_auth_get_type(gsession);
1758 if (cred != GNUTLS_CRD_CERTIFICATE) {
1759 snprintf(myerror, sizeof myerror,
1760 "gnutls_auth_get_type failed %d",
1761 (int)cred);
1762 stop_tls(gsession, xcred);
1763 goto done;
1764 }
1765
1766 *gs = gsession;
1767 *xc = xcred;
1768 rv = 0;
1769 done:
1770 *error_str = myerror;
1771 return (rv);
1772 }
1773
1774 int
1775 get_connection_certs(gnutls_session_t gsession, gnutls_x509_crt_t **certs,
1776 size_t *cert_count)
1777 {
1778 unsigned int len;
1779 const gnutls_datum_t *cl;
1780 gnutls_x509_crt_t *all_certs;
1781 int i, rv = 1;
1782
1783 if (certs == NULL || cert_count == NULL)
1784 goto done;
1785 if (gnutls_certificate_type_get(gsession) != GNUTLS_CRT_X509)
1786 goto done;
1787 cl = gnutls_certificate_get_peers(gsession, &len);
1788 if (len == 0)
1789 goto done;
1790
1791 all_certs = g_malloc(sizeof(gnutls_x509_crt_t) * len);
1792 for (i = 0; i < len; i++) {
1793 gnutls_x509_crt_init(&all_certs[i]);
1794 if (gnutls_x509_crt_import(all_certs[i], &cl[i],
1795 GNUTLS_X509_FMT_PEM < 0)) {
1796 g_free(all_certs);
1797 goto done;
1798 }
1799 }
1800
1801 *certs = all_certs;
1802 *cert_count = len;
1803 rv = 0;
1804 done:
1805 return (rv);
1806 }
1807
1808 void
1809 free_connection_certs(gnutls_x509_crt_t *certs, size_t cert_count)
1810 {
1811 int i;
1812
1813 for (i = 0; i < cert_count; i++)
1814 gnutls_x509_crt_deinit(certs[i]);
1815 g_free(certs);
1816 }
1817
1818 void
1819 statusbar_modify_attr(struct tab *t, const char *text, const char *base)
1820 {
1821 GdkColor c_text, c_base;
1822
1823 gdk_color_parse(text, &c_text);
1824 gdk_color_parse(base, &c_base);
1825
1826 gtk_widget_modify_text(t->sbe.statusbar, GTK_STATE_NORMAL, &c_text);
1827 gtk_widget_modify_text(t->sbe.buffercmd, GTK_STATE_NORMAL, &c_text);
1828 gtk_widget_modify_text(t->sbe.zoom, GTK_STATE_NORMAL, &c_text);
1829 gtk_widget_modify_text(t->sbe.position, GTK_STATE_NORMAL, &c_text);
1830
1831 gtk_widget_modify_base(t->sbe.statusbar, GTK_STATE_NORMAL, &c_base);
1832 gtk_widget_modify_base(t->sbe.buffercmd, GTK_STATE_NORMAL, &c_base);
1833 gtk_widget_modify_base(t->sbe.zoom, GTK_STATE_NORMAL, &c_base);
1834 gtk_widget_modify_base(t->sbe.position, GTK_STATE_NORMAL, &c_base);
1835 }
1836
1837 void
1838 save_certs(struct tab *t, gnutls_x509_crt_t *certs,
1839 size_t cert_count, char *domain)
1840 {
1841 size_t cert_buf_sz;
1842 char cert_buf[64 * 1024], file[PATH_MAX];
1843 int i;
1844 FILE *f;
1845 GdkColor color;
1846
1847 if (t == NULL || certs == NULL || cert_count <= 0 || domain == NULL)
1848 return;
1849
1850 snprintf(file, sizeof file, "%s/%s", certs_dir, domain);
1851 if ((f = fopen(file, "w")) == NULL) {
1852 show_oops(t, "Can't create cert file %s %s",
1853 file, strerror(errno));
1854 return;
1855 }
1856
1857 for (i = 0; i < cert_count; i++) {
1858 cert_buf_sz = sizeof cert_buf;
1859 if (gnutls_x509_crt_export(certs[i], GNUTLS_X509_FMT_PEM,
1860 cert_buf, &cert_buf_sz)) {
1861 show_oops(t, "gnutls_x509_crt_export failed");
1862 goto done;
1863 }
1864 if (fwrite(cert_buf, cert_buf_sz, 1, f) != 1) {
1865 show_oops(t, "Can't write certs: %s", strerror(errno));
1866 goto done;
1867 }
1868 }
1869
1870 /* not the best spot but oh well */
1871 gdk_color_parse("lightblue", &color);
1872 gtk_widget_modify_base(t->uri_entry, GTK_STATE_NORMAL, &color);
1873 statusbar_modify_attr(t, XT_COLOR_BLACK, "lightblue");
1874 done:
1875 fclose(f);
1876 }
1877
1878 enum cert_trust {
1879 CERT_LOCAL,
1880 CERT_TRUSTED,
1881 CERT_UNTRUSTED,
1882 CERT_BAD
1883 };
1884
1885 enum cert_trust
1886 load_compare_cert(const gchar *uri, const gchar **error_str)
1887 {
1888 char domain[8182], file[PATH_MAX];
1889 char cert_buf[64 * 1024], r_cert_buf[64 * 1024];
1890 int s = -1, i;
1891 unsigned int error = 0;
1892 FILE *f = NULL;
1893 size_t cert_buf_sz, cert_count;
1894 enum cert_trust rv = CERT_UNTRUSTED;
1895 static gchar serr[80]; /* this isn't thread safe */
1896 gnutls_session_t gsession;
1897 gnutls_x509_crt_t *certs;
1898 gnutls_certificate_credentials_t xcred;
1899
1900 DNPRINTF(XT_D_URL, "%s: %s\n", __func__, uri);
1901
1902 serr[0] = '\0';
1903 *error_str = serr;
1904 if ((s = connect_socket_from_uri(uri, error_str, domain,
1905 sizeof domain)) == -1)
1906 return (rv);
1907
1908 DNPRINTF(XT_D_URL, "%s: fd %d\n", __func__, s);
1909
1910 /* go ssl/tls */
1911 if (start_tls(error_str, s, &gsession, &xcred))
1912 goto done;
1913 DNPRINTF(XT_D_URL, "%s: got tls\n", __func__);
1914
1915 /* verify certs in case cert file doesn't exist */
1916 if (gnutls_certificate_verify_peers2(gsession, &error) !=
1917 GNUTLS_E_SUCCESS) {
1918 *error_str = "Invalid certificates";
1919 goto done;
1920 }
1921
1922 /* get certs */
1923 if (get_connection_certs(gsession, &certs, &cert_count)) {
1924 *error_str = "Can't get connection certificates";
1925 goto done;
1926 }
1927
1928 snprintf(file, sizeof file, "%s/%s", certs_dir, domain);
1929 if ((f = fopen(file, "r")) == NULL) {
1930 if (!error)
1931 rv = CERT_TRUSTED;
1932 goto freeit;
1933 }
1934
1935 for (i = 0; i < cert_count; i++) {
1936 cert_buf_sz = sizeof cert_buf;
1937 if (gnutls_x509_crt_export(certs[i], GNUTLS_X509_FMT_PEM,
1938 cert_buf, &cert_buf_sz)) {
1939 goto freeit;
1940 }
1941 if (fread(r_cert_buf, cert_buf_sz, 1, f) != 1) {
1942 rv = CERT_BAD; /* critical */
1943 goto freeit;
1944 }
1945 if (bcmp(r_cert_buf, cert_buf, sizeof cert_buf_sz)) {
1946 rv = CERT_BAD; /* critical */
1947 goto freeit;
1948 }
1949 rv = CERT_LOCAL;
1950 }
1951
1952 freeit:
1953 if (f)
1954 fclose(f);
1955 free_connection_certs(certs, cert_count);
1956 done:
1957 /* we close the socket first for speed */
1958 if (s != -1)
1959 close(s);
1960
1961 /* only complain if we didn't save it locally */
1962 if (error && rv != CERT_LOCAL) {
1963 strlcpy(serr, "Certificate exception(s): ", sizeof serr);
1964 if (error & GNUTLS_CERT_INVALID)
1965 strlcat(serr, "invalid, ", sizeof serr);
1966 if (error & GNUTLS_CERT_REVOKED)
1967 strlcat(serr, "revoked, ", sizeof serr);
1968 if (error & GNUTLS_CERT_SIGNER_NOT_FOUND)
1969 strlcat(serr, "signer not found, ", sizeof serr);
1970 if (error & GNUTLS_CERT_SIGNER_NOT_CA)
1971 strlcat(serr, "not signed by CA, ", sizeof serr);
1972 if (error & GNUTLS_CERT_INSECURE_ALGORITHM)
1973 strlcat(serr, "insecure algorithm, ", sizeof serr);
1974 if (error & GNUTLS_CERT_NOT_ACTIVATED)
1975 strlcat(serr, "not activated, ", sizeof serr);
1976 if (error & GNUTLS_CERT_EXPIRED)
1977 strlcat(serr, "expired, ", sizeof serr);
1978 for (i = strlen(serr) - 1; i > 0; i--)
1979 if (serr[i] == ',') {
1980 serr[i] = '\0';
1981 break;
1982 }
1983 *error_str = serr;
1984 }
1985
1986 stop_tls(gsession, xcred);
1987
1988 return (rv);
1989 }
1990
1991 int
1992 cert_cmd(struct tab *t, struct karg *args)
1993 {
1994 const gchar *uri, *error_str = NULL;
1995 char domain[8182];
1996 int s = -1;
1997 size_t cert_count;
1998 gnutls_session_t gsession;
1999 gnutls_x509_crt_t *certs;
2000 gnutls_certificate_credentials_t xcred;
2001
2002 if (t == NULL)
2003 return (1);
2004
2005 if (ssl_ca_file == NULL) {
2006 show_oops(t, "Can't open CA file: %s", ssl_ca_file);
2007 return (1);
2008 }
2009
2010 if ((uri = get_uri(t)) == NULL) {
2011 show_oops(t, "Invalid URI");
2012 return (1);
2013 }
2014
2015 if ((s = connect_socket_from_uri(uri, &error_str, domain,
2016 sizeof domain)) == -1) {
2017 show_oops(t, "%s", error_str);
2018 return (1);
2019 }
2020
2021 /* go ssl/tls */
2022 if (start_tls(&error_str, s, &gsession, &xcred))
2023 goto done;
2024
2025 /* get certs */
2026 if (get_connection_certs(gsession, &certs, &cert_count)) {
2027 show_oops(t, "get_connection_certs failed");
2028 goto done;
2029 }
2030
2031 if (args->i & XT_SHOW)
2032 show_certs(t, certs, cert_count, "Certificate Chain");
2033 else if (args->i & XT_SAVE)
2034 save_certs(t, certs, cert_count, domain);
2035
2036 free_connection_certs(certs, cert_count);
2037 done:
2038 /* we close the socket first for speed */
2039 if (s != -1)
2040 close(s);
2041 stop_tls(gsession, xcred);
2042 if (error_str && strlen(error_str))
2043 show_oops(t, "%s", error_str);
2044 return (0);
2045 }
2046
2047 int
2048 remove_cookie(int index)
2049 {
2050 int i, rv = 1;
2051 GSList *cf;
2052 SoupCookie *c;
2053
2054 DNPRINTF(XT_D_COOKIE, "remove_cookie: %d\n", index);
2055
2056 cf = soup_cookie_jar_all_cookies(s_cookiejar);
2057
2058 for (i = 1; cf; cf = cf->next, i++) {
2059 if (i != index)
2060 continue;
2061 c = cf->data;
2062 print_cookie("remove cookie", c);
2063 soup_cookie_jar_delete_cookie(s_cookiejar, c);
2064 rv = 0;
2065 break;
2066 }
2067
2068 soup_cookies_free(cf);
2069
2070 return (rv);
2071 }
2072
2073 int
2074 toplevel_cmd(struct tab *t, struct karg *args)
2075 {
2076 js_toggle_cb(t->js_toggle, t);
2077
2078 return (0);
2079 }
2080
2081 int
2082 can_go_back_for_real(struct tab *t)
2083 {
2084 int i;
2085 WebKitWebHistoryItem *item;
2086 const gchar *uri;
2087
2088 if (t == NULL)
2089 return (FALSE);
2090
2091 /* rely on webkit to make sure we can go backward when on an about page */
2092 uri = get_uri(t);
2093 if (uri == NULL || g_str_has_prefix(uri, "about:"))
2094 return (webkit_web_view_can_go_back(t->wv));
2095
2096 /* the back/forwars list is stupid so help determine if we can go back */
2097 for (i = 0, item = webkit_web_back_forward_list_get_current_item(t->bfl);
2098 item != NULL;
2099 i--, item = webkit_web_back_forward_list_get_nth_item(t->bfl, i)) {
2100 if (strcmp(webkit_web_history_item_get_uri(item), uri))
2101 return (TRUE);
2102 }
2103
2104 return (FALSE);
2105 }
2106
2107 int
2108 can_go_forward_for_real(struct tab *t)
2109 {
2110 int i;
2111 WebKitWebHistoryItem *item;
2112 const gchar *uri;
2113
2114 if (t == NULL)
2115 return (FALSE);
2116
2117 /* rely on webkit to make sure we can go forward when on an about page */
2118 uri = get_uri(t);
2119 if (uri == NULL || g_str_has_prefix(uri, "about:"))
2120 return (webkit_web_view_can_go_forward(t->wv));
2121
2122 /* the back/forwars list is stupid so help selecting a different item */
2123 for (i = 0, item = webkit_web_back_forward_list_get_current_item(t->bfl);
2124 item != NULL;
2125 i++, item = webkit_web_back_forward_list_get_nth_item(t->bfl, i)) {
2126 if (strcmp(webkit_web_history_item_get_uri(item), uri))
2127 return (TRUE);
2128 }
2129
2130 return (FALSE);
2131 }
2132
2133 void
2134 go_back_for_real(struct tab *t)
2135 {
2136 int i;
2137 WebKitWebHistoryItem *item;
2138 const gchar *uri;
2139
2140 if (t == NULL)
2141 return;
2142
2143 uri = get_uri(t);
2144 if (uri == NULL) {
2145 webkit_web_view_go_back(t->wv);
2146 return;
2147 }
2148 /* the back/forwars list is stupid so help selecting a different item */
2149 for (i = 0, item = webkit_web_back_forward_list_get_current_item(t->bfl);
2150 item != NULL;
2151 i--, item = webkit_web_back_forward_list_get_nth_item(t->bfl, i)) {
2152 if (strcmp(webkit_web_history_item_get_uri(item), uri)) {
2153 webkit_web_view_go_to_back_forward_item(t->wv, item);
2154 break;
2155 }
2156 }
2157 }
2158
2159 void
2160 go_forward_for_real(struct tab *t)
2161 {
2162 int i;
2163 WebKitWebHistoryItem *item;
2164 const gchar *uri;
2165
2166 if (t == NULL)
2167 return;
2168
2169 uri = get_uri(t);
2170 if (uri == NULL) {
2171 webkit_web_view_go_forward(t->wv);
2172 return;
2173 }
2174 /* the back/forwars list is stupid so help selecting a different item */
2175 for (i = 0, item = webkit_web_back_forward_list_get_current_item(t->bfl);
2176 item != NULL;
2177 i++, item = webkit_web_back_forward_list_get_nth_item(t->bfl, i)) {
2178 if (strcmp(webkit_web_history_item_get_uri(item), uri)) {
2179 webkit_web_view_go_to_back_forward_item(t->wv, item);
2180 break;
2181 }
2182 }
2183 }
2184
2185 int
2186 navaction(struct tab *t, struct karg *args)
2187 {
2188 WebKitWebHistoryItem *item;
2189 WebKitWebFrame *frame;
2190
2191 DNPRINTF(XT_D_NAV, "navaction: tab %d opcode %d\n",
2192 t->tab_id, args->i);
2193
2194 t->xtp_meaning = XT_XTP_TAB_MEANING_NORMAL;
2195 if (t->item) {
2196 if (args->i == XT_NAV_BACK)
2197 item = webkit_web_back_forward_list_get_current_item(t->bfl);
2198 else
2199 item = webkit_web_back_forward_list_get_forward_item(t->bfl);
2200 if (item == NULL)
2201 return (XT_CB_PASSTHROUGH);
2202 webkit_web_view_go_to_back_forward_item(t->wv, item);
2203 t->item = NULL;
2204 return (XT_CB_PASSTHROUGH);
2205 }
2206
2207 switch (args->i) {
2208 case XT_NAV_BACK:
2209 marks_clear(t);
2210 go_back_for_real(t);
2211 break;
2212 case XT_NAV_FORWARD:
2213 marks_clear(t);
2214 go_forward_for_real(t);
2215 break;
2216 case XT_NAV_RELOAD:
2217 frame = webkit_web_view_get_main_frame(t->wv);
2218 webkit_web_frame_reload(frame);
2219 break;
2220 case XT_NAV_STOP:
2221 frame = webkit_web_view_get_main_frame(t->wv);
2222 webkit_web_frame_stop_loading(frame);
2223 break;
2224 }
2225 return (XT_CB_PASSTHROUGH);
2226 }
2227
2228 int
2229 move(struct tab *t, struct karg *args)
2230 {
2231 GtkAdjustment *adjust;
2232 double pi, si, pos, ps, upper, lower, max;
2233 double percent;
2234
2235 switch (args->i) {
2236 case XT_MOVE_DOWN:
2237 case XT_MOVE_UP:
2238 case XT_MOVE_BOTTOM:
2239 case XT_MOVE_TOP:
2240 case XT_MOVE_PAGEDOWN:
2241 case XT_MOVE_PAGEUP:
2242 case XT_MOVE_HALFDOWN:
2243 case XT_MOVE_HALFUP:
2244 case XT_MOVE_PERCENT:
2245 case XT_MOVE_CENTER:
2246 adjust = t->adjust_v;
2247 break;
2248 default:
2249 adjust = t->adjust_h;
2250 break;
2251 }
2252
2253 pos = gtk_adjustment_get_value(adjust);
2254 ps = gtk_adjustment_get_page_size(adjust);
2255 upper = gtk_adjustment_get_upper(adjust);
2256 lower = gtk_adjustment_get_lower(adjust);
2257 si = gtk_adjustment_get_step_increment(adjust);
2258 pi = gtk_adjustment_get_page_increment(adjust);
2259 max = upper - ps;
2260
2261 DNPRINTF(XT_D_MOVE, "move: opcode %d %s pos %f ps %f upper %f lower %f "
2262 "max %f si %f pi %f\n",
2263 args->i, adjust == t->adjust_h ? "horizontal" : "vertical",
2264 pos, ps, upper, lower, max, si, pi);
2265
2266 switch (args->i) {
2267 case XT_MOVE_DOWN:
2268 case XT_MOVE_RIGHT:
2269 pos += si;
2270 gtk_adjustment_set_value(adjust, MIN(pos, max));
2271 break;
2272 case XT_MOVE_UP:
2273 case XT_MOVE_LEFT:
2274 pos -= si;
2275 gtk_adjustment_set_value(adjust, MAX(pos, lower));
2276 break;
2277 case XT_MOVE_BOTTOM:
2278 case XT_MOVE_FARRIGHT:
2279 gtk_adjustment_set_value(adjust, max);
2280 break;
2281 case XT_MOVE_TOP:
2282 case XT_MOVE_FARLEFT:
2283 gtk_adjustment_set_value(adjust, lower);
2284 break;
2285 case XT_MOVE_PAGEDOWN:
2286 pos += pi;
2287 gtk_adjustment_set_value(adjust, MIN(pos, max));
2288 break;
2289 case XT_MOVE_PAGEUP:
2290 pos -= pi;
2291 gtk_adjustment_set_value(adjust, MAX(pos, lower));
2292 break;
2293 case XT_MOVE_HALFDOWN:
2294 pos += pi / 2;
2295 gtk_adjustment_set_value(adjust, MIN(pos, max));
2296 break;
2297 case XT_MOVE_HALFUP:
2298 pos -= pi / 2;
2299 gtk_adjustment_set_value(adjust, MAX(pos, lower));
2300 break;
2301 case XT_MOVE_CENTER:
2302 args->s = g_strdup("50.0");
2303 /* FALLTHROUGH */
2304 case XT_MOVE_PERCENT:
2305 percent = atoi(args->s) / 100.0;
2306 pos = max * percent;
2307 if (pos < 0.0 || pos > max)
2308 break;
2309 gtk_adjustment_set_value(adjust, pos);
2310 break;
2311 default:
2312 return (XT_CB_PASSTHROUGH);
2313 }
2314
2315 DNPRINTF(XT_D_MOVE, "move: new pos %f %f\n", pos, MIN(pos, max));
2316
2317 return (XT_CB_HANDLED);
2318 }
2319
2320 void
2321 url_set_visibility(void)
2322 {
2323 struct tab *t;
2324
2325 TAILQ_FOREACH(t, &tabs, entry)
2326 if (show_url == 0) {
2327 gtk_widget_hide(t->toolbar);
2328 focus_webview(t);
2329 } else
2330 gtk_widget_show(t->toolbar);
2331 }
2332
2333 void
2334 notebook_tab_set_visibility(void)
2335 {
2336 if (show_tabs == 0) {
2337 gtk_widget_hide(tab_bar);
2338 gtk_notebook_set_show_tabs(notebook, FALSE);
2339 } else {
2340 if (tab_style == XT_TABS_NORMAL) {
2341 gtk_widget_hide(tab_bar);
2342 gtk_notebook_set_show_tabs(notebook, TRUE);
2343 } else if (tab_style == XT_TABS_COMPACT) {
2344 gtk_widget_show(tab_bar);
2345 gtk_notebook_set_show_tabs(notebook, FALSE);
2346 }
2347 }
2348 }
2349
2350 void
2351 statusbar_set_visibility(void)
2352 {
2353 struct tab *t;
2354
2355 TAILQ_FOREACH(t, &tabs, entry){
2356 if (show_statusbar == 0)
2357 gtk_widget_hide(t->statusbar_box);
2358 else
2359 gtk_widget_show(t->statusbar_box);
2360
2361 focus_webview(t);
2362 }
2363 }
2364
2365 void
2366 url_set(struct tab *t, int enable_url_entry)
2367 {
2368 GdkPixbuf *pixbuf;
2369 int progress;
2370
2371 show_url = enable_url_entry;
2372
2373 if (enable_url_entry) {
2374 gtk_entry_set_icon_from_icon_name(GTK_ENTRY(t->sbe.statusbar),
2375 GTK_ENTRY_ICON_PRIMARY, NULL);
2376 gtk_entry_set_progress_fraction(GTK_ENTRY(t->sbe.statusbar), 0);
2377 } else {
2378 pixbuf = gtk_entry_get_icon_pixbuf(GTK_ENTRY(t->uri_entry),
2379 GTK_ENTRY_ICON_PRIMARY);
2380 progress =
2381 gtk_entry_get_progress_fraction(GTK_ENTRY(t->uri_entry));
2382 gtk_entry_set_icon_from_pixbuf(GTK_ENTRY(t->sbe.statusbar),
2383 GTK_ENTRY_ICON_PRIMARY, pixbuf);
2384 gtk_entry_set_progress_fraction(GTK_ENTRY(t->sbe.statusbar),
2385 progress);
2386 }
2387 }
2388
2389 int
2390 fullscreen(struct tab *t, struct karg *args)
2391 {
2392 DNPRINTF(XT_D_TAB, "%s: %p %d\n", __func__, t, args->i);
2393
2394 if (t == NULL)
2395 return (XT_CB_PASSTHROUGH);
2396
2397 if (show_url == 0) {
2398 url_set(t, 1);
2399 show_tabs = 1;
2400 } else {
2401 url_set(t, 0);
2402 show_tabs = 0;
2403 }
2404
2405 url_set_visibility();
2406 notebook_tab_set_visibility();
2407
2408 return (XT_CB_HANDLED);
2409 }
2410
2411 int
2412 statustoggle(struct tab *t, struct karg *args)
2413 {
2414 DNPRINTF(XT_D_TAB, "%s: %p %d\n", __func__, t, args->i);
2415
2416 if (show_statusbar == 1) {
2417 show_statusbar = 0;
2418 statusbar_set_visibility();
2419 } else if (show_statusbar == 0) {
2420 show_statusbar = 1;
2421 statusbar_set_visibility();
2422 }
2423 return (XT_CB_HANDLED);
2424 }
2425
2426 int
2427 urlaction(struct tab *t, struct karg *args)
2428 {
2429 int rv = XT_CB_HANDLED;
2430
2431 DNPRINTF(XT_D_TAB, "%s: %p %d\n", __func__, t, args->i);
2432
2433 if (t == NULL)
2434 return (XT_CB_PASSTHROUGH);
2435
2436 switch (args->i) {
2437 case XT_URL_SHOW:
2438 if (show_url == 0) {
2439 url_set(t, 1);
2440 url_set_visibility();
2441 }
2442 break;
2443 case XT_URL_HIDE:
2444 if (show_url == 1) {
2445 url_set(t, 0);
2446 url_set_visibility();
2447 }
2448 break;
2449 }
2450 return (rv);
2451 }
2452
2453 int
2454 tabaction(struct tab *t, struct karg *args)
2455 {
2456 int rv = XT_CB_HANDLED;
2457 char *url = args->s;
2458 struct undo *u;
2459 struct tab *tt;
2460
2461 DNPRINTF(XT_D_TAB, "tabaction: %p %d\n", t, args->i);
2462
2463 if (t == NULL)
2464 return (XT_CB_PASSTHROUGH);
2465
2466 switch (args->i) {
2467 case XT_TAB_NEW:
2468 if (strlen(url) > 0)
2469 create_new_tab(url, NULL, 1, args->precount);
2470 else
2471 create_new_tab(NULL, NULL, 1, args->precount);
2472 break;
2473 case XT_TAB_DELETE:
2474 if (args->precount < 0)
2475 delete_tab(t);
2476 else
2477 TAILQ_FOREACH(tt, &tabs, entry)
2478 if (tt->tab_id == args->precount - 1) {
2479 delete_tab(tt);
2480 break;
2481 }
2482 break;
2483 case XT_TAB_DELQUIT:
2484 if (gtk_notebook_get_n_pages(notebook) > 1)
2485 delete_tab(t);
2486 else
2487 quit(t, args);
2488 break;
2489 case XT_TAB_OPEN:
2490 if (strlen(url) > 0)
2491 ;
2492 else {
2493 rv = XT_CB_PASSTHROUGH;
2494 goto done;
2495 }
2496 load_uri(t, url);
2497 break;
2498 case XT_TAB_SHOW:
2499 if (show_tabs == 0) {
2500 show_tabs = 1;
2501 notebook_tab_set_visibility();
2502 }
2503 break;
2504 case XT_TAB_HIDE:
2505 if (show_tabs == 1) {
2506 show_tabs = 0;
2507 notebook_tab_set_visibility();
2508 }
2509 break;
2510 case XT_TAB_NEXTSTYLE:
2511 if (tab_style == XT_TABS_NORMAL) {
2512 tab_style = XT_TABS_COMPACT;
2513 recolor_compact_tabs();
2514 }
2515 else
2516 tab_style = XT_TABS_NORMAL;
2517 notebook_tab_set_visibility();
2518 break;
2519 case XT_TAB_UNDO_CLOSE:
2520 if (undo_count == 0) {
2521 DNPRINTF(XT_D_TAB, "%s: no tabs to undo close",
2522 __func__);
2523 goto done;
2524 } else {
2525 undo_count--;
2526 u = TAILQ_FIRST(&undos);
2527 create_new_tab(u->uri, u, 1, -1);
2528
2529 TAILQ_REMOVE(&undos, u, entry);
2530 g_free(u->uri);
2531 /* u->history is freed in create_new_tab() */
2532 g_free(u);
2533 }
2534 break;
2535 default:
2536 rv = XT_CB_PASSTHROUGH;
2537 goto done;
2538 }
2539
2540 done:
2541 if (args->s) {
2542 g_free(args->s);
2543 args->s = NULL;
2544 }
2545
2546 return (rv);
2547 }
2548
2549 int
2550 resizetab(struct tab *t, struct karg *args)
2551 {
2552 if (t == NULL || args == NULL) {
2553 show_oops(NULL, "resizetab invalid parameters");
2554 return (XT_CB_PASSTHROUGH);
2555 }
2556
2557 DNPRINTF(XT_D_TAB, "resizetab: tab %d %d\n",
2558 t->tab_id, args->i);
2559
2560 setzoom_webkit(t, args->i);
2561
2562 return (XT_CB_HANDLED);
2563 }
2564
2565 int
2566 movetab(struct tab *t, struct karg *args)
2567 {
2568 int n, dest;
2569
2570 if (t == NULL || args == NULL) {
2571 show_oops(NULL, "movetab invalid parameters");
2572 return (XT_CB_PASSTHROUGH);
2573 }
2574
2575 DNPRINTF(XT_D_TAB, "movetab: tab %d opcode %d\n",
2576 t->tab_id, args->i);
2577
2578 if (args->i >= XT_TAB_INVALID)
2579 return (XT_CB_PASSTHROUGH);
2580
2581 if (TAILQ_EMPTY(&tabs))
2582 return (XT_CB_PASSTHROUGH);
2583
2584 n = gtk_notebook_get_n_pages(notebook);
2585 dest = gtk_notebook_get_current_page(notebook);
2586
2587 switch (args->i) {
2588 case XT_TAB_NEXT:
2589 if (args->precount < 0)
2590 dest = dest == n - 1 ? 0 : dest + 1;
2591 else
2592 dest = args->precount - 1;
2593
2594 break;
2595 case XT_TAB_PREV:
2596 if (args->precount < 0)
2597 dest -= 1;
2598 else
2599 dest -= args->precount % n;
2600
2601 if (dest < 0)
2602 dest += n;
2603
2604 break;
2605 case XT_TAB_FIRST:
2606 dest = 0;
2607 break;
2608 case XT_TAB_LAST:
2609 dest = n - 1;
2610 break;
2611 default:
2612 return (XT_CB_PASSTHROUGH);
2613 }
2614
2615 if (dest < 0 || dest >= n)
2616 return (XT_CB_PASSTHROUGH);
2617 if (t->tab_id == dest) {
2618 DNPRINTF(XT_D_TAB, "movetab: do nothing\n");
2619 return (XT_CB_HANDLED);
2620 }
2621
2622 set_current_tab(dest);
2623
2624 return (XT_CB_HANDLED);
2625 }
2626
2627 int cmd_prefix = 0;
2628
2629
2630 int
2631 command(struct tab *t, struct karg *args)
2632 {
2633 char *s = NULL, *ss = NULL;
2634 GdkColor color;
2635 const gchar *uri;
2636 struct karg a;
2637
2638 if (t == NULL || args == NULL) {
2639 show_oops(NULL, "command invalid parameters");
2640 return (XT_CB_PASSTHROUGH);
2641 }
2642
2643 switch (args->i) {
2644 case '/':
2645 s = "/";
2646 break;
2647 case '?':
2648 s = "?";
2649 break;
2650 case ':':
2651 if (cmd_prefix == 0)
2652 s = ":";
2653 else {
2654 ss = g_strdup_printf(":%d", cmd_prefix);
2655 s = ss;
2656 cmd_prefix = 0;
2657 }
2658 break;
2659 case '.':
2660 t->mode = XT_MODE_HINT;
2661 bzero(&a, sizeof a);
2662 a.i = 0;
2663 hint(t, &a);
2664 s = ".";
2665 break;
2666 case ',':
2667 t->mode = XT_MODE_HINT;
2668 bzero(&a, sizeof a);
2669 a.i = XT_HINT_NEWTAB;
2670 hint(t, &a);
2671 s = ",";
2672 break;
2673 case XT_CMD_OPEN:
2674 s = ":open ";
2675 break;
2676 case XT_CMD_TABNEW:
2677 s = ":tabnew ";
2678 break;
2679 case XT_CMD_OPEN_CURRENT:
2680 s = ":open ";
2681 /* FALL THROUGH */
2682 case XT_CMD_TABNEW_CURRENT:
2683 if (!s) /* FALL THROUGH? */
2684 s = ":tabnew ";
2685 if ((uri = get_uri(t)) != NULL) {
2686 ss = g_strdup_printf("%s%s", s, uri);
2687 s = ss;
2688 }
2689 break;
2690 default:
2691 show_oops(t, "command: invalid opcode %d", args->i);
2692 return (XT_CB_PASSTHROUGH);
2693 }
2694
2695 DNPRINTF(XT_D_CMD, "%s: tab %d type %s\n", __func__, t->tab_id, s);
2696
2697 gtk_entry_set_text(GTK_ENTRY(t->cmd), s);
2698 gdk_color_parse(XT_COLOR_WHITE, &color);
2699 gtk_widget_modify_base(t->cmd, GTK_STATE_NORMAL, &color);
2700 show_cmd(t);
2701 gtk_widget_grab_focus(GTK_WIDGET(t->cmd));
2702 gtk_editable_set_position(GTK_EDITABLE(t->cmd), -1);
2703
2704 if (ss)
2705 g_free(ss);
2706
2707 return (XT_CB_HANDLED);
2708 }
2709
2710 int
2711 search(struct tab *t, struct karg *args)
2712 {
2713 gboolean d;
2714
2715 if (t == NULL || args == NULL) {
2716 show_oops(NULL, "search invalid parameters");
2717 return (1);
2718 }
2719
2720 switch (args->i) {
2721 case XT_SEARCH_NEXT:
2722 d = t->search_forward;
2723 break;
2724 case XT_SEARCH_PREV:
2725 d = !t->search_forward;
2726 break;
2727 default:
2728 return (XT_CB_PASSTHROUGH);
2729 }
2730
2731 if (t->search_text == NULL) {
2732 if (global_search == NULL)
2733 return (XT_CB_PASSTHROUGH);
2734 else {
2735 d = t->search_forward = TRUE;
2736 t->search_text = g_strdup(global_search);
2737 webkit_web_view_mark_text_matches(t->wv, global_search, FALSE, 0);
2738 webkit_web_view_set_highlight_text_matches(t->wv, TRUE);
2739 }
2740 }
2741
2742 DNPRINTF(XT_D_CMD, "search: tab %d opc %d forw %d text %s\n",
2743 t->tab_id, args->i, t->search_forward, t->search_text);
2744
2745 webkit_web_view_search_text(t->wv, t->search_text, FALSE, d, TRUE);
2746
2747 return (XT_CB_HANDLED);
2748 }
2749
2750 int
2751 session_save(struct tab *t, char *filename)
2752 {
2753 struct karg a;
2754 int rv = 1;
2755 struct session *s;
2756
2757 if (strlen(filename) == 0)
2758 goto done;
2759
2760 if (filename[0] == '.' || filename[0] == '/')
2761 goto done;
2762
2763 a.s = filename;
2764 if (save_tabs(t, &a))
2765 goto done;
2766 strlcpy(named_session, filename, sizeof named_session);
2767
2768 /* add the new session to the list of sessions */
2769 s = g_malloc(sizeof(struct session));
2770 s->name = g_strdup(filename);
2771 TAILQ_INSERT_TAIL(&sessions, s, entry);
2772
2773 rv = 0;
2774 done:
2775 return (rv);
2776 }
2777
2778 int
2779 session_open(struct tab *t, char *filename)
2780 {
2781 struct karg a;
2782 int rv = 1;
2783
2784 if (strlen(filename) == 0)
2785 goto done;
2786
2787 if (filename[0] == '.' || filename[0] == '/')
2788 goto done;
2789
2790 a.s = filename;
2791 a.i = XT_SES_CLOSETABS;
2792 if (open_tabs(t, &a))
2793 goto done;
2794
2795 strlcpy(named_session, filename, sizeof named_session);
2796
2797 rv = 0;
2798 done:
2799 return (rv);
2800 }
2801
2802 int
2803 session_delete(struct tab *t, char *filename)
2804 {
2805 char file[PATH_MAX];
2806 int rv = 1;
2807 struct session *s;
2808
2809 if (strlen(filename) == 0)
2810 goto done;
2811
2812 if (filename[0] == '.' || filename[0] == '/')
2813 goto done;
2814
2815 snprintf(file, sizeof file, "%s/%s", sessions_dir, filename);
2816 if (unlink(file))
2817 goto done;
2818
2819 if (!strcmp(filename, named_session))
2820 strlcpy(named_session, XT_SAVED_TABS_FILE,
2821 sizeof named_session);
2822
2823 /* remove session from sessions list */
2824 TAILQ_FOREACH(s, &sessions, entry) {
2825 if (!strcmp(s->name, filename))
2826 break;
2827 }
2828 if (s == NULL)
2829 goto done;
2830 TAILQ_REMOVE(&sessions, s, entry);
2831 g_free((gpointer) s->name);
2832 g_free(s);
2833
2834 rv = 0;
2835 done:
2836 return (rv);
2837 }
2838
2839 int
2840 session_cmd(struct tab *t, struct karg *args)
2841 {
2842 char *filename = args->s;
2843
2844 if (t == NULL)
2845 return (1);
2846
2847 if (args->i & XT_SHOW)
2848 show_oops(t, "Current session: %s", named_session[0] == '\0' ?
2849 XT_SAVED_TABS_FILE : named_session);
2850 else if (args->i & XT_SAVE) {
2851 if (session_save(t, filename)) {
2852 show_oops(t, "Can't save session: %s",
2853 filename ? filename : "INVALID");
2854 goto done;
2855 }
2856 } else if (args->i & XT_OPEN) {
2857 if (session_open(t, filename)) {
2858 show_oops(t, "Can't open session: %s",
2859 filename ? filename : "INVALID");
2860 goto done;
2861 }
2862 } else if (args->i & XT_DELETE) {
2863 if (session_delete(t, filename)) {
2864 show_oops(t, "Can't delete session: %s",
2865 filename ? filename : "INVALID");
2866 goto done;
2867 }
2868 }
2869 done:
2870 return (XT_CB_PASSTHROUGH);
2871 }
2872
2873 int
2874 script_cmd(struct tab *t, struct karg *args)
2875 {
2876 JSGlobalContextRef ctx;
2877 WebKitWebFrame *frame;
2878 JSStringRef str;
2879 JSValueRef val, exception;
2880 char *es;
2881 struct stat sb;
2882 FILE *f = NULL;
2883 char *buf = NULL;
2884
2885 if (t == NULL)
2886 goto done;
2887
2888 if ((f = fopen(args->s, "r")) == NULL) {
2889 show_oops(t, "Can't open script file: %s", args->s);
2890 goto done;
2891 }
2892
2893 if (fstat(fileno(f), &sb) == -1) {
2894 show_oops(t, "Can't stat script file: %s", args->s);
2895 goto done;
2896 }
2897
2898 buf = g_malloc0(sb.st_size + 1);
2899 if (fread(buf, 1, sb.st_size, f) != sb.st_size) {
2900 show_oops(t, "Can't read script file: %s", args->s);
2901 goto done;
2902 }
2903
2904 /* this code needs to be redone */
2905 frame = webkit_web_view_get_main_frame(t->wv);
2906 ctx = webkit_web_frame_get_global_context(frame);
2907
2908 str = JSStringCreateWithUTF8CString(buf);
2909 val = JSEvaluateScript(ctx, str, JSContextGetGlobalObject(ctx),
2910 NULL, 0, &exception);
2911 JSStringRelease(str);
2912
2913 DNPRINTF(XT_D_JS, "%s: val %p\n", __func__, val);
2914 if (val == NULL) {
2915 es = js_ref_to_string(ctx, exception);
2916 if (es) {
2917 show_oops(t, "script exception: %s", es);
2918 g_free(es);
2919 }
2920 goto done;
2921 } else {
2922 es = js_ref_to_string(ctx, val);
2923 #if 0
2924 /* return values */
2925 if (!strncmp(es, XT_JS_DONE, XT_JS_DONE_LEN))
2926 ; /* do nothing */
2927 if (!strncmp(es, XT_JS_INSERT, XT_JS_INSERT_LEN))
2928 ; /* do nothing */
2929 #endif
2930 if (es) {
2931 show_oops(t, "script complete return value: '%s'", es);
2932 g_free(es);
2933 } else
2934 show_oops(t, "script complete: without a return value");
2935 }
2936
2937 done:
2938 if (f)
2939 fclose(f);
2940 if (buf)
2941 g_free(buf);
2942
2943 return (XT_CB_PASSTHROUGH);
2944 }
2945
2946 /*
2947 * Make a hardcopy of the page
2948 */
2949 int
2950 print_page(struct tab *t, struct karg *args)
2951 {
2952 WebKitWebFrame *frame;
2953 GtkPageSetup *ps;
2954 GtkPrintOperation *op;
2955 GtkPrintOperationAction action;
2956 GtkPrintOperationResult print_res;
2957 GError *g_err = NULL;
2958 int marg_l, marg_r, marg_t, marg_b;
2959
2960 DNPRINTF(XT_D_PRINTING, "%s:", __func__);
2961
2962 ps = gtk_page_setup_new();
2963 op = gtk_print_operation_new();
2964 action = GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG;
2965 frame = webkit_web_view_get_main_frame(t->wv);
2966
2967 /* the default margins are too small, so we will bump them */
2968 marg_l = gtk_page_setup_get_left_margin(ps, GTK_UNIT_MM) +
2969 XT_PRINT_EXTRA_MARGIN;
2970 marg_r = gtk_page_setup_get_right_margin(ps, GTK_UNIT_MM) +
2971 XT_PRINT_EXTRA_MARGIN;
2972 marg_t = gtk_page_setup_get_top_margin(ps, GTK_UNIT_MM) +
2973 XT_PRINT_EXTRA_MARGIN;
2974 marg_b = gtk_page_setup_get_bottom_margin(ps, GTK_UNIT_MM) +
2975 XT_PRINT_EXTRA_MARGIN;
2976
2977 /* set margins */
2978 gtk_page_setup_set_left_margin(ps, marg_l, GTK_UNIT_MM);
2979 gtk_page_setup_set_right_margin(ps, marg_r, GTK_UNIT_MM);
2980 gtk_page_setup_set_top_margin(ps, marg_t, GTK_UNIT_MM);
2981 gtk_page_setup_set_bottom_margin(ps, marg_b, GTK_UNIT_MM);
2982
2983 gtk_print_operation_set_default_page_setup(op, ps);
2984
2985 /* this appears to free 'op' and 'ps' */
2986 print_res = webkit_web_frame_print_full(frame, op, action, &g_err);
2987
2988 /* check it worked */
2989 if (print_res == GTK_PRINT_OPERATION_RESULT_ERROR) {
2990 show_oops(NULL, "can't print: %s", g_err->message);
2991 g_error_free (g_err);
2992 return (1);
2993 }
2994
2995 return (0);
2996 }
2997
2998 int
2999 go_home(struct tab *t, struct karg *args)
3000 {
3001 load_uri(t, home);
3002 return (0);
3003 }
3004
3005 int
3006 set_encoding(struct tab *t, struct karg *args)
3007 {
3008 const gchar *e;
3009
3010 if (args->s && strlen(g_strstrip(args->s)) == 0) {
3011 e = webkit_web_view_get_custom_encoding(t->wv);
3012 if (e == NULL)
3013 e = webkit_web_view_get_encoding(t->wv);
3014 show_oops(t, "encoding: %s", e ? e : "N/A");
3015 } else
3016 webkit_web_view_set_custom_encoding(t->wv, args->s);
3017
3018 return (0);
3019 }
3020
3021 int
3022 restart(struct tab *t, struct karg *args)
3023 {
3024 struct karg a;
3025
3026 a.s = XT_RESTART_TABS_FILE;
3027 save_tabs(t, &a);
3028 execvp(start_argv[0], start_argv);
3029 /* NOTREACHED */
3030
3031 return (0);
3032 }
3033
3034 char *http_proxy_save; /* not a setting, used to toggle */
3035
3036 int
3037 proxy_cmd(struct tab *t, struct karg *args)
3038 {
3039 DNPRINTF(XT_D_CMD, "%s: tab %d\n", __func__, t->tab_id);
3040
3041 if (t == NULL)
3042 return (1);
3043
3044 /* setup */
3045 if (http_proxy) {
3046 if (http_proxy_save)
3047 g_free(http_proxy_save);
3048 http_proxy_save = g_strdup(http_proxy);
3049 }
3050
3051 if (args->i & XT_PRXY_SHOW) {
3052 if (http_proxy)
3053 show_oops(t, "http_proxy = %s", http_proxy);
3054 else
3055 show_oops(t, "proxy is currently disabled");
3056 } else if (args->i & XT_PRXY_TOGGLE) {
3057 if (http_proxy_save == NULL && http_proxy == NULL) {
3058 show_oops(t, "can't toggle proxy");
3059 goto done;
3060 }
3061 if (http_proxy)
3062 setup_proxy(NULL);
3063 else
3064 setup_proxy(http_proxy_save);
3065 }
3066 done:
3067 return (XT_CB_PASSTHROUGH);
3068 }
3069 struct cmd {
3070 char *cmd;
3071 int level;
3072 int (*func)(struct tab *, struct karg *);
3073 int arg;
3074 int type;
3075 } cmds[] = {
3076 { "command_mode", 0, command_mode, XT_MODE_COMMAND, 0 },
3077 { "insert_mode", 0, command_mode, XT_MODE_INSERT, 0 },
3078 { "command", 0, command, ':', 0 },
3079 { "search", 0, command, '/', 0 },
3080 { "searchb", 0, command, '?', 0 },
3081 { "hinting", 0, command, '.', 0 },
3082 { "hinting_newtab", 0, command, ',', 0 },
3083 { "togglesrc", 0, toggle_src, 0, 0 },
3084
3085 /* yanking and pasting */
3086 { "yankuri", 0, yank_uri, 0, 0 },
3087 /* XXX: pasteuri{cur,new} do not work from the cmd_entry? */
3088 { "pasteuricur", 0, paste_uri, XT_PASTE_CURRENT_TAB, 0 },
3089 { "pasteurinew", 0, paste_uri, XT_PASTE_NEW_TAB, 0 },
3090
3091 /* search */
3092 { "searchnext", 0, search, XT_SEARCH_NEXT, 0 },
3093 { "searchprevious", 0, search, XT_SEARCH_PREV, 0 },
3094
3095 /* focus */
3096 { "focusaddress", 0, focus, XT_FOCUS_URI, 0 },
3097 { "focussearch", 0, focus, XT_FOCUS_SEARCH, 0 },
3098
3099 /* hinting */
3100 { "hinting", 0, hint, 0, 0 },
3101 { "hinting_newtab", 0, hint, XT_HINT_NEWTAB, 0 },
3102
3103 /* custom stylesheet */
3104 { "userstyle", 0, userstyle, 0, 0 },
3105
3106 /* navigation */
3107 { "goback", 0, navaction, XT_NAV_BACK, 0 },
3108 { "goforward", 0, navaction, XT_NAV_FORWARD, 0 },
3109 { "reload", 0, navaction, XT_NAV_RELOAD, 0 },
3110 { "stop", 0, navaction, XT_NAV_STOP, 0 },
3111
3112 /* vertical movement */
3113 { "scrolldown", 0, move, XT_MOVE_DOWN, 0 },
3114 { "scrollup", 0, move, XT_MOVE_UP, 0 },
3115 { "scrollbottom", 0, move, XT_MOVE_BOTTOM, 0 },
3116 { "scrolltop", 0, move, XT_MOVE_TOP, 0 },
3117 { "1", 0, move, XT_MOVE_TOP, 0 },
3118 { "scrollhalfdown", 0, move, XT_MOVE_HALFDOWN, 0 },
3119 { "scrollhalfup", 0, move, XT_MOVE_HALFUP, 0 },
3120 { "scrollpagedown", 0, move, XT_MOVE_PAGEDOWN, 0 },
3121 { "scrollpageup", 0, move, XT_MOVE_PAGEUP, 0 },
3122 /* horizontal movement */
3123 { "scrollright", 0, move, XT_MOVE_RIGHT, 0 },
3124 { "scrollleft", 0, move, XT_MOVE_LEFT, 0 },
3125 { "scrollfarright", 0, move, XT_MOVE_FARRIGHT, 0 },
3126 { "scrollfarleft", 0, move, XT_MOVE_FARLEFT, 0 },
3127
3128 { "favorites", 0, xtp_page_fl, 0, 0 },
3129 { "fav", 0, xtp_page_fl, 0, 0 },
3130 { "favadd", 0, add_favorite, 0, 0 },
3131
3132 { "qall", 0, quit, 0, 0 },
3133 { "quitall", 0, quit, 0, 0 },
3134 { "w", 0, save_tabs, 0, 0 },
3135 { "wq", 0, save_tabs_and_quit, 0, 0 },
3136 { "help", 0, help, 0, 0 },
3137 { "about", 0, about, 0, 0 },
3138 { "stats", 0, stats, 0, 0 },
3139 { "version", 0, about, 0, 0 },
3140
3141 /* js command */
3142 { "js", 0, js_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3143 { "save", 1, js_cmd, XT_SAVE | XT_WL_FQDN, 0 },
3144 { "domain", 2, js_cmd, XT_SAVE | XT_WL_TOPLEVEL, 0 },
3145 { "fqdn", 2, js_cmd, XT_SAVE | XT_WL_FQDN, 0 },
3146 { "show", 1, js_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3147 { "all", 2, js_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3148 { "persistent", 2, js_cmd, XT_SHOW | XT_WL_PERSISTENT, 0 },
3149 { "session", 2, js_cmd, XT_SHOW | XT_WL_SESSION, 0 },
3150 { "toggle", 1, js_cmd, XT_WL_TOGGLE | XT_WL_FQDN, 0 },
3151 { "domain", 2, js_cmd, XT_WL_TOGGLE | XT_WL_TOPLEVEL, 0 },
3152 { "fqdn", 2, js_cmd, XT_WL_TOGGLE | XT_WL_FQDN, 0 },
3153
3154 /* cookie command */
3155 { "cookie", 0, cookie_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3156 { "save", 1, cookie_cmd, XT_SAVE | XT_WL_FQDN, 0 },
3157 { "domain", 2, cookie_cmd, XT_SAVE | XT_WL_TOPLEVEL, 0 },
3158 { "fqdn", 2, cookie_cmd, XT_SAVE | XT_WL_FQDN, 0 },
3159 { "show", 1, cookie_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3160 { "all", 2, cookie_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3161 { "persistent", 2, cookie_cmd, XT_SHOW | XT_WL_PERSISTENT, 0 },
3162 { "session", 2, cookie_cmd, XT_SHOW | XT_WL_SESSION, 0 },
3163 { "toggle", 1, cookie_cmd, XT_WL_TOGGLE | XT_WL_FQDN, 0 },
3164 { "domain", 2, cookie_cmd, XT_WL_TOGGLE | XT_WL_TOPLEVEL, 0 },
3165 { "fqdn", 2, cookie_cmd, XT_WL_TOGGLE | XT_WL_FQDN, 0 },
3166
3167 /* plugin command */
3168 { "plugin", 0, pl_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3169 { "save", 1, pl_cmd, XT_SAVE | XT_WL_FQDN, 0 },
3170 { "domain", 2, pl_cmd, XT_SAVE | XT_WL_TOPLEVEL, 0 },
3171 { "fqdn", 2, pl_cmd, XT_SAVE | XT_WL_FQDN, 0 },
3172 { "show", 1, pl_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3173 { "all", 2, pl_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3174 { "persistent", 2, pl_cmd, XT_SHOW | XT_WL_PERSISTENT, 0 },
3175 { "session", 2, pl_cmd, XT_SHOW | XT_WL_SESSION, 0 },
3176 { "toggle", 1, pl_cmd, XT_WL_TOGGLE | XT_WL_FQDN, 0 },
3177 { "domain", 2, pl_cmd, XT_WL_TOGGLE | XT_WL_TOPLEVEL, 0 },
3178 { "fqdn", 2, pl_cmd, XT_WL_TOGGLE | XT_WL_FQDN, 0 },
3179
3180 /* toplevel (domain) command */
3181 { "toplevel", 0, toplevel_cmd, XT_WL_TOGGLE | XT_WL_TOPLEVEL | XT_WL_RELOAD, 0 },
3182 { "toggle", 1, toplevel_cmd, XT_WL_TOGGLE | XT_WL_TOPLEVEL | XT_WL_RELOAD, 0 },
3183
3184 /* cookie jar */
3185 { "cookiejar", 0, xtp_page_cl, 0, 0 },
3186
3187 /* cert command */
3188 { "cert", 0, cert_cmd, XT_SHOW, 0 },
3189 { "save", 1, cert_cmd, XT_SAVE, 0 },
3190 { "show", 1, cert_cmd, XT_SHOW, 0 },
3191
3192 { "ca", 0, ca_cmd, 0, 0 },
3193 { "downloadmgr", 0, xtp_page_dl, 0, 0 },
3194 { "dl", 0, xtp_page_dl, 0, 0 },
3195 { "h", 0, xtp_page_hl, 0, 0 },
3196 { "history", 0, xtp_page_hl, 0, 0 },
3197 { "home", 0, go_home, 0, 0 },
3198 { "restart", 0, restart, 0, 0 },
3199 { "urlhide", 0, urlaction, XT_URL_HIDE, 0 },
3200 { "urlshow", 0, urlaction, XT_URL_SHOW, 0 },
3201 { "statustoggle", 0, statustoggle, 0, 0 },
3202 { "run_script", 0, run_page_script, 0, XT_USERARG },
3203
3204 { "print", 0, print_page, 0, 0 },
3205
3206 /* tabs */
3207 { "focusin", 0, resizetab, XT_ZOOM_IN, 0 },
3208 { "focusout", 0, resizetab, XT_ZOOM_OUT, 0 },
3209 { "focusreset", 0, resizetab, XT_ZOOM_NORMAL, 0 },
3210 { "q", 0, tabaction, XT_TAB_DELQUIT, 0 },
3211 { "quit", 0, tabaction, XT_TAB_DELQUIT, 0 },
3212 { "open", 0, tabaction, XT_TAB_OPEN, XT_URLARG },
3213 { "tabclose", 0, tabaction, XT_TAB_DELETE, XT_PREFIX | XT_INTARG},
3214 { "tabedit", 0, tabaction, XT_TAB_NEW, XT_PREFIX | XT_URLARG },
3215 { "tabfirst", 0, movetab, XT_TAB_FIRST, 0 },
3216 { "tabhide", 0, tabaction, XT_TAB_HIDE, 0 },
3217 { "tablast", 0, movetab, XT_TAB_LAST, 0 },
3218 { "tabnew", 0, tabaction, XT_TAB_NEW, XT_PREFIX | XT_URLARG },
3219 { "tabnext", 0, movetab, XT_TAB_NEXT, XT_PREFIX | XT_INTARG},
3220 { "tabnextstyle", 0, tabaction, XT_TAB_NEXTSTYLE, 0 },
3221 { "tabprevious", 0, movetab, XT_TAB_PREV, XT_PREFIX | XT_INTARG},
3222 { "tabrewind", 0, movetab, XT_TAB_FIRST, 0 },
3223 { "tabshow", 0, tabaction, XT_TAB_SHOW, 0 },
3224 { "tabs", 0, buffers, 0, 0 },
3225 { "tabundoclose", 0, tabaction, XT_TAB_UNDO_CLOSE, 0 },
3226 { "buffers", 0, buffers, 0, 0 },
3227 { "ls", 0, buffers, 0, 0 },
3228 { "encoding", 0, set_encoding, 0, XT_USERARG },
3229
3230 /* command aliases (handy when -S flag is used) */
3231 { "promptopen", 0, command, XT_CMD_OPEN, 0 },
3232 { "promptopencurrent", 0, command, XT_CMD_OPEN_CURRENT, 0 },
3233 { "prompttabnew", 0, command, XT_CMD_TABNEW, 0 },
3234 { "prompttabnewcurrent",0, command, XT_CMD_TABNEW_CURRENT, 0 },
3235
3236 /* settings */
3237 { "set", 0, set, 0, XT_SETARG },
3238
3239 { "fullscreen", 0, fullscreen, 0, 0 },
3240 { "f", 0, fullscreen, 0, 0 },
3241
3242 /* sessions */
3243 { "session", 0, session_cmd, XT_SHOW, 0 },
3244 { "delete", 1, session_cmd, XT_DELETE, XT_SESSARG },
3245 { "open", 1, session_cmd, XT_OPEN, XT_SESSARG },
3246 { "save", 1, session_cmd, XT_SAVE, XT_USERARG },
3247 { "show", 1, session_cmd, XT_SHOW, 0 },
3248
3249 /* external javascript */
3250 { "script", 0, script_cmd, XT_EJS_SHOW, XT_USERARG },
3251
3252 /* inspector */
3253 { "inspector", 0, inspector_cmd, XT_INS_SHOW, 0 },
3254 { "show", 1, inspector_cmd, XT_INS_SHOW, 0 },
3255 { "hide", 1, inspector_cmd, XT_INS_HIDE, 0 },
3256
3257 /* proxy */
3258 { "proxy", 0, proxy_cmd, XT_PRXY_SHOW, 0 },
3259 { "show", 1, proxy_cmd, XT_PRXY_SHOW, 0 },
3260 { "toggle", 1, proxy_cmd, XT_PRXY_TOGGLE, 0 },
3261 };
3262
3263 struct {
3264 int index;
3265 int len;
3266 gchar *list[256];
3267 } cmd_status = {-1, 0};
3268
3269 gboolean
3270 wv_release_button_cb(GtkWidget *btn, GdkEventButton *e, struct tab *t)
3271 {
3272
3273 if (e->type == GDK_BUTTON_RELEASE && e->button == 1)
3274 btn_down = 0;
3275
3276 return (FALSE);
3277 }
3278
3279 gboolean
3280 wv_button_cb(GtkWidget *btn, GdkEventButton *e, struct tab *t)
3281 {
3282 struct karg a;
3283 WebKitHitTestResult *hit_test_result;
3284 guint context;
3285
3286 hit_test_result = webkit_web_view_get_hit_test_result(t->wv, e);
3287 g_object_get(hit_test_result, "context", &context, NULL);
3288
3289 hide_oops(t);
3290 hide_buffers(t);
3291
3292 if (context & WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE)
3293 t->mode = XT_MODE_INSERT;
3294 else
3295 t->mode = XT_MODE_COMMAND;
3296
3297 if (e->type == GDK_BUTTON_PRESS && e->button == 1)
3298 btn_down = 1;
3299 else if (e->type == GDK_BUTTON_PRESS && e->button == 8 /* btn 4 */) {
3300 /* go backward */
3301 a.i = XT_NAV_BACK;
3302 navaction(t, &a);
3303
3304 return (TRUE);
3305 } else if (e->type == GDK_BUTTON_PRESS && e->button == 9 /* btn 5 */) {
3306 /* go forward */
3307 a.i = XT_NAV_FORWARD;
3308 navaction(t, &a);
3309
3310 return (TRUE);
3311 }
3312
3313 return (FALSE);
3314 }
3315
3316 gboolean
3317 tab_close_cb(GtkWidget *btn, GdkEventButton *e, struct tab *t)
3318 {
3319 DNPRINTF(XT_D_TAB, "tab_close_cb: tab %d\n", t->tab_id);
3320
3321 if (e->type == GDK_BUTTON_PRESS && e->button == 1)
3322 delete_tab(t);
3323
3324 return (FALSE);
3325 }
3326
3327
3328
3329 void
3330 activate_uri_entry_cb(GtkWidget* entry, struct tab *t)
3331 {
3332 const gchar *uri = gtk_entry_get_text(GTK_ENTRY(entry));
3333
3334 DNPRINTF(XT_D_URL, "activate_uri_entry_cb: %s\n", uri);
3335
3336 if (t == NULL) {
3337 show_oops(NULL, "activate_uri_entry_cb invalid parameters");
3338 return;
3339 }
3340
3341 if (uri == NULL) {
3342 show_oops(t, "activate_uri_entry_cb no uri");
3343 return;
3344 }
3345
3346 uri += strspn(uri, "\t ");
3347
3348 /* if xxxt:// treat specially */
3349 if (parse_xtp_url(t, uri))
3350 return;
3351
3352 /* otherwise continue to load page normally */
3353 load_uri(t, (gchar *)uri);
3354 focus_webview(t);
3355 }
3356
3357 void
3358 activate_search_entry_cb(GtkWidget* entry, struct tab *t)
3359 {
3360 const gchar *search = gtk_entry_get_text(GTK_ENTRY(entry));
3361 char *newuri = NULL;
3362 gchar *enc_search;
3363
3364 DNPRINTF(XT_D_URL, "activate_search_entry_cb: %s\n", search);
3365
3366 if (t == NULL) {
3367 show_oops(NULL, "activate_search_entry_cb invalid parameters");
3368 return;
3369 }
3370
3371 if (search_string == NULL) {
3372 show_oops(t, "no search_string");
3373 return;
3374 }
3375
3376 t->xtp_meaning = XT_XTP_TAB_MEANING_NORMAL;
3377
3378 enc_search = soup_uri_encode(search, XT_RESERVED_CHARS);
3379 newuri = g_strdup_printf(search_string, enc_search);
3380 g_free(enc_search);
3381
3382 marks_clear(t);
3383 webkit_web_view_load_uri(t->wv, newuri);
3384 focus_webview(t);
3385
3386 if (newuri)
3387 g_free(newuri);
3388 }
3389
3390 void
3391 check_and_set_cookie(const gchar *uri, struct tab *t)
3392 {
3393 struct domain *d = NULL;
3394 int es = 0;
3395
3396 if (uri == NULL || t == NULL)
3397 return;
3398
3399 if ((d = wl_find_uri(uri, &c_wl)) == NULL)
3400 es = 0;
3401 else
3402 es = 1;
3403
3404 DNPRINTF(XT_D_COOKIE, "check_and_set_cookie: %s %s\n",
3405 es ? "enable" : "disable", uri);
3406
3407 g_object_set(G_OBJECT(t->settings),
3408 "enable-html5-local-storage", es, (char *)NULL);
3409 webkit_web_view_set_settings(t->wv, t->settings);
3410 }
3411
3412 void
3413 check_and_set_js(const gchar *uri, struct tab *t)
3414 {
3415 struct domain *d = NULL;
3416 int es = 0;
3417
3418 if (uri == NULL || t == NULL)
3419 return;
3420
3421 if ((d = wl_find_uri(uri, &js_wl)) == NULL)
3422 es = 0;
3423 else
3424 es = 1;
3425
3426 DNPRINTF(XT_D_JS, "check_and_set_js: %s %s\n",
3427 es ? "enable" : "disable", uri);
3428
3429 g_object_set(G_OBJECT(t->settings),
3430 "enable-scripts", es, (char *)NULL);
3431 g_object_set(G_OBJECT(t->settings),
3432 "javascript-can-open-windows-automatically", es, (char *)NULL);
3433 webkit_web_view_set_settings(t->wv, t->settings);
3434
3435 button_set_stockid(t->js_toggle,
3436 es ? GTK_STOCK_MEDIA_PLAY : GTK_STOCK_MEDIA_PAUSE);
3437 }
3438
3439 void
3440 check_and_set_pl(const gchar *uri, struct tab *t)
3441 {
3442 struct domain *d = NULL;
3443 int es = 0;
3444
3445 if (uri == NULL || t == NULL)
3446 return;
3447
3448 if ((d = wl_find_uri(uri, &pl_wl)) == NULL)
3449 es = 0;
3450 else
3451 es = 1;
3452
3453 DNPRINTF(XT_D_JS, "check_and_set_pl: %s %s\n",
3454 es ? "enable" : "disable", uri);
3455
3456 g_object_set(G_OBJECT(t->settings),
3457 "enable-plugins", es, (char *)NULL);
3458 webkit_web_view_set_settings(t->wv, t->settings);
3459 }
3460
3461 void
3462 color_address_bar(gpointer p)
3463 {
3464 GdkColor color;
3465 struct tab *tt, *t = p;
3466 gchar *col_str = XT_COLOR_WHITE;
3467 const gchar *uri, *u = NULL, *error_str = NULL;
3468
3469 #ifdef USE_THREADS
3470 gdk_threads_enter();
3471 #endif
3472 DNPRINTF(XT_D_URL, "%s:\n", __func__);
3473
3474 /* make sure t still exists */
3475 if (t == NULL)
3476 return;
3477 TAILQ_FOREACH(tt, &tabs, entry)
3478 if (t == tt)
3479 break;
3480 if (t != tt)
3481 goto done;
3482
3483 if ((uri = get_uri(t)) == NULL)
3484 goto white;
3485 u = g_strdup(uri);
3486
3487 #ifdef USE_THREADS
3488 gdk_threads_leave();
3489 #endif
3490
3491 col_str = XT_COLOR_YELLOW;
3492 switch (load_compare_cert(u, &error_str)) {
3493 case CERT_LOCAL:
3494 col_str = XT_COLOR_BLUE;
3495 break;
3496 case CERT_TRUSTED:
3497 col_str = XT_COLOR_GREEN;
3498 break;
3499 case CERT_UNTRUSTED:
3500 col_str = XT_COLOR_YELLOW;
3501 break;
3502 case CERT_BAD:
3503 col_str = XT_COLOR_RED;
3504 break;
3505 }
3506
3507 #ifdef USE_THREADS
3508 gdk_threads_enter();
3509 #endif
3510 /* make sure t isn't deleted */
3511 TAILQ_FOREACH(tt, &tabs, entry)
3512 if (t == tt)
3513 break;
3514 if (t != tt)
3515 goto done;
3516
3517 #ifdef USE_THREADS
3518 /* test to see if the user navigated away and canceled the thread */
3519 if (t->thread != g_thread_self())
3520 goto done;
3521 if ((uri = get_uri(t)) == NULL) {
3522 t->thread = NULL;
3523 goto done;
3524 }
3525 if (strcmp(uri, u)) {
3526 /* make sure we are still the same url */
3527 t->thread = NULL;
3528 goto done;
3529 }
3530 #endif
3531 white:
3532 gdk_color_parse(col_str, &color);
3533 gtk_widget_modify_base(t->uri_entry, GTK_STATE_NORMAL, &color);
3534
3535 if (!strcmp(col_str, XT_COLOR_WHITE))
3536 statusbar_modify_attr(t, col_str, XT_COLOR_BLACK);
3537 else
3538 statusbar_modify_attr(t, XT_COLOR_BLACK, col_str);
3539
3540 if (error_str && error_str[0] != '\0')
3541 show_oops(t, "%s", error_str);
3542 #ifdef USE_THREADS
3543 t->thread = NULL;
3544 #endif
3545 done:
3546 /* t is invalid at this point */
3547 if (u)
3548 g_free((gpointer)u);
3549 #ifdef USE_THREADS
3550 gdk_threads_leave();
3551 #endif
3552 }
3553
3554 void
3555 show_ca_status(struct tab *t, const char *uri)
3556 {
3557 GdkColor color;
3558 gchar *col_str = XT_COLOR_WHITE;
3559
3560 DNPRINTF(XT_D_URL, "show_ca_status: %d %s %s\n",
3561 ssl_strict_certs, ssl_ca_file, uri);
3562
3563 if (t == NULL)
3564 return;
3565
3566 if (uri == NULL)
3567 goto done;
3568 if (ssl_ca_file == NULL) {
3569 if (g_str_has_prefix(uri, "http://"))
3570 goto done;
3571 if (g_str_has_prefix(uri, "https://")) {
3572 col_str = XT_COLOR_RED;
3573 goto done;
3574 }
3575 return;
3576 }
3577 if (g_str_has_prefix(uri, "http://") ||
3578 !g_str_has_prefix(uri, "https://"))
3579 goto done;
3580 #ifdef USE_THREADS
3581 /*
3582 * It is not necessary to see if the thread is already running.
3583 * If the thread is in progress setting it to something else aborts it
3584 * on the way out.
3585 */
3586
3587 /* thread the coloring of the address bar */
3588 t->thread = g_thread_create((GThreadFunc)color_address_bar, t, TRUE, NULL);
3589 #else
3590 color_address_bar(t);
3591 #endif
3592 return;
3593
3594 done:
3595 if (col_str) {
3596 gdk_color_parse(col_str, &color);
3597 gtk_widget_modify_base(t->uri_entry, GTK_STATE_NORMAL, &color);
3598
3599 if (!strcmp(col_str, XT_COLOR_WHITE))
3600 statusbar_modify_attr(t, col_str, XT_COLOR_BLACK);
3601 else
3602 statusbar_modify_attr(t, XT_COLOR_BLACK, col_str);
3603 }
3604 }
3605
3606 void
3607 free_favicon(struct tab *t)
3608 {
3609 DNPRINTF(XT_D_DOWNLOAD, "%s: down %p req %p\n",
3610 __func__, t->icon_download, t->icon_request);
3611
3612 if (t->icon_request)
3613 g_object_unref(t->icon_request);
3614 if (t->icon_dest_uri)
3615 g_free(t->icon_dest_uri);
3616
3617 t->icon_request = NULL;
3618 t->icon_dest_uri = NULL;
3619 }
3620
3621 void
3622 xt_icon_from_name(struct tab *t, gchar *name)
3623 {
3624 gtk_entry_set_icon_from_icon_name(GTK_ENTRY(t->uri_entry),
3625 GTK_ENTRY_ICON_PRIMARY, "text-html");
3626 if (show_url == 0)
3627 gtk_entry_set_icon_from_icon_name(GTK_ENTRY(t->sbe.statusbar),
3628 GTK_ENTRY_ICON_PRIMARY, "text-html");
3629 else
3630 gtk_entry_set_icon_from_icon_name(GTK_ENTRY(t->sbe.statusbar),
3631 GTK_ENTRY_ICON_PRIMARY, NULL);
3632 }
3633
3634 void
3635 xt_icon_from_pixbuf(struct tab *t, GdkPixbuf *pb)
3636 {
3637 GdkPixbuf *pb_scaled;
3638
3639 if (gdk_pixbuf_get_width(pb) > 16 || gdk_pixbuf_get_height(pb) > 16)
3640 pb_scaled = gdk_pixbuf_scale_simple(pb, 16, 16,
3641 GDK_INTERP_BILINEAR);
3642 else
3643 pb_scaled = pb;
3644
3645 gtk_entry_set_icon_from_pixbuf(GTK_ENTRY(t->uri_entry),
3646 GTK_ENTRY_ICON_PRIMARY, pb_scaled);
3647 if (show_url == 0)
3648 gtk_entry_set_icon_from_pixbuf(GTK_ENTRY(t->sbe.statusbar),
3649 GTK_ENTRY_ICON_PRIMARY, pb_scaled);
3650 else
3651 gtk_entry_set_icon_from_icon_name(GTK_ENTRY(t->sbe.statusbar),
3652 GTK_ENTRY_ICON_PRIMARY, NULL);
3653
3654 if (pb_scaled != pb)
3655 g_object_unref(pb_scaled);
3656 }
3657
3658 void
3659 xt_icon_from_file(struct tab *t, char *file)
3660 {
3661 GdkPixbuf *pb;
3662
3663 if (g_str_has_prefix(file, "file://"))
3664 file += strlen("file://");
3665
3666 pb = gdk_pixbuf_new_from_file(file, NULL);
3667 if (pb) {
3668 xt_icon_from_pixbuf(t, pb);
3669 g_object_unref(pb);
3670 } else
3671 xt_icon_from_name(t, "text-html");
3672 }
3673
3674 gboolean
3675 is_valid_icon(char *file)
3676 {
3677 gboolean valid = 0;
3678 const char *mime_type;
3679 GFileInfo *fi;
3680 GFile *gf;
3681
3682 gf = g_file_new_for_path(file);
3683 fi = g_file_query_info(gf, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE, 0,
3684 NULL, NULL);
3685 mime_type = g_file_info_get_content_type(fi);
3686 valid = g_strcmp0(mime_type, "image/x-ico") == 0 ||
3687 g_strcmp0(mime_type, "image/vnd.microsoft.icon") == 0 ||
3688 g_strcmp0(mime_type, "image/png") == 0 ||
3689 g_strcmp0(mime_type, "image/gif") == 0 ||
3690 g_strcmp0(mime_type, "application/octet-stream") == 0;
3691 g_object_unref(fi);
3692 g_object_unref(gf);
3693
3694 return (valid);
3695 }
3696
3697 void
3698 set_favicon_from_file(struct tab *t, char *file)
3699 {
3700 struct stat sb;
3701
3702 if (t == NULL || file == NULL)
3703 return;
3704
3705 if (g_str_has_prefix(file, "file://"))
3706 file += strlen("file://");
3707 DNPRINTF(XT_D_DOWNLOAD, "%s: loading %s\n", __func__, file);
3708
3709 if (!stat(file, &sb)) {
3710 if (sb.st_size == 0 || !is_valid_icon(file)) {
3711 /* corrupt icon so trash it */
3712 DNPRINTF(XT_D_DOWNLOAD, "%s: corrupt icon %s\n",
3713 __func__, file);
3714 unlink(file);
3715 /* no need to set icon to default here */
3716 return;
3717 }
3718 }
3719 xt_icon_from_file(t, file);
3720 }
3721
3722 void
3723 favicon_download_status_changed_cb(WebKitDownload *download, GParamSpec *spec,
3724 WebKitWebView *wv)
3725 {
3726 WebKitDownloadStatus status = webkit_download_get_status(download);
3727 struct tab *tt = NULL, *t = NULL;
3728
3729 /*
3730 * find the webview instead of passing in the tab as it could have been
3731 * deleted from underneath us.
3732 */
3733 TAILQ_FOREACH(tt, &tabs, entry) {
3734 if (tt->wv == wv) {
3735 t = tt;
3736 break;
3737 }
3738 }
3739 if (t == NULL)
3740 return;
3741
3742 DNPRINTF(XT_D_DOWNLOAD, "%s: tab %d status %d\n",
3743 __func__, t->tab_id, status);
3744
3745 switch (status) {
3746 case WEBKIT_DOWNLOAD_STATUS_ERROR:
3747 /* -1 */
3748 t->icon_download = NULL;
3749 free_favicon(t);
3750 break;
3751 case WEBKIT_DOWNLOAD_STATUS_CREATED:
3752 /* 0 */
3753 break;
3754 case WEBKIT_DOWNLOAD_STATUS_STARTED:
3755 /* 1 */
3756 break;
3757 case WEBKIT_DOWNLOAD_STATUS_CANCELLED:
3758 /* 2 */
3759 DNPRINTF(XT_D_DOWNLOAD, "%s: freeing favicon %d\n",
3760 __func__, t->tab_id);
3761 t->icon_download = NULL;
3762 free_favicon(t);
3763 break;
3764 case WEBKIT_DOWNLOAD_STATUS_FINISHED:
3765 /* 3 */
3766
3767 DNPRINTF(XT_D_DOWNLOAD, "%s: setting icon to %s\n",
3768 __func__, t->icon_dest_uri);
3769 set_favicon_from_file(t, t->icon_dest_uri);
3770 /* these will be freed post callback */
3771 t->icon_request = NULL;
3772 t->icon_download = NULL;
3773 break;
3774 default:
3775 break;
3776 }
3777 }
3778
3779 void
3780 abort_favicon_download(struct tab *t)
3781 {
3782 DNPRINTF(XT_D_DOWNLOAD, "%s: down %p\n", __func__, t->icon_download);
3783
3784 #if !WEBKIT_CHECK_VERSION(1, 4, 0)
3785 if (t->icon_download) {
3786 g_signal_handlers_disconnect_by_func(G_OBJECT(t->icon_download),
3787 G_CALLBACK(favicon_download_status_changed_cb), t->wv);
3788 webkit_download_cancel(t->icon_download);
3789 t->icon_download = NULL;
3790 } else
3791 free_favicon(t);
3792 #endif
3793
3794 xt_icon_from_name(t, "text-html");
3795 }
3796
3797 void
3798 notify_icon_loaded_cb(WebKitWebView *wv, gchar *uri, struct tab *t)
3799 {
3800 DNPRINTF(XT_D_DOWNLOAD, "%s %s\n", __func__, uri);
3801
3802 if (uri == NULL || t == NULL)
3803 return;
3804
3805 #if WEBKIT_CHECK_VERSION(1, 4, 0)
3806 /* take icon from WebKitIconDatabase */
3807 GdkPixbuf *pb;
3808
3809 pb = webkit_web_view_get_icon_pixbuf(wv);
3810 if (pb) {
3811 xt_icon_from_pixbuf(t, pb);
3812 g_object_unref(pb);
3813 } else
3814 xt_icon_from_name(t, "text-html");
3815 #elif WEBKIT_CHECK_VERSION(1, 1, 18)
3816 /* download icon to cache dir */
3817 gchar *name_hash, file[PATH_MAX];
3818 struct stat sb;
3819
3820 if (t->icon_request) {
3821 DNPRINTF(XT_D_DOWNLOAD, "%s: download in progress\n", __func__);
3822 return;
3823 }
3824
3825 /* check to see if we got the icon in cache */
3826 name_hash = g_compute_checksum_for_string(G_CHECKSUM_SHA256, uri, -1);
3827 snprintf(file, sizeof file, "%s/%s.ico", cache_dir, name_hash);
3828 g_free(name_hash);
3829
3830 if (!stat(file, &sb)) {
3831 if (sb.st_size > 0) {
3832 DNPRINTF(XT_D_DOWNLOAD, "%s: loading from cache %s\n",
3833 __func__, file);
3834 set_favicon_from_file(t, file);
3835 return;
3836 }
3837
3838 /* corrupt icon so trash it */
3839 DNPRINTF(XT_D_DOWNLOAD, "%s: corrupt icon %s\n",
3840 __func__, file);
3841 unlink(file);
3842 }
3843
3844 /* create download for icon */
3845 t->icon_request = webkit_network_request_new(uri);
3846 if (t->icon_request == NULL) {
3847 DNPRINTF(XT_D_DOWNLOAD, "%s: invalid uri %s\n",
3848 __func__, uri);
3849 return;
3850 }
3851
3852 t->icon_download = webkit_download_new(t->icon_request);
3853 if (t->icon_download == NULL)
3854 return;
3855
3856 /* we have to free icon_dest_uri later */
3857 t->icon_dest_uri = g_strdup_printf("file://%s", file);
3858 webkit_download_set_destination_uri(t->icon_download,
3859 t->icon_dest_uri);
3860
3861 if (webkit_download_get_status(t->icon_download) ==
3862 WEBKIT_DOWNLOAD_STATUS_ERROR) {
3863 g_object_unref(t->icon_request);
3864 g_free(t->icon_dest_uri);
3865 t->icon_request = NULL;
3866 t->icon_dest_uri = NULL;
3867 return;
3868 }
3869
3870 g_signal_connect(G_OBJECT(t->icon_download), "notify::status",
3871 G_CALLBACK(favicon_download_status_changed_cb), t->wv);
3872
3873 webkit_download_start(t->icon_download);
3874 #endif
3875 }
3876
3877 void
3878 notify_load_status_cb(WebKitWebView* wview, GParamSpec* pspec, struct tab *t)
3879 {
3880 const gchar *uri = NULL;
3881 struct history *h, find;
3882 struct karg a;
3883 GdkColor color;
3884
3885 DNPRINTF(XT_D_URL, "notify_load_status_cb: %d %s\n",
3886 webkit_web_view_get_load_status(wview),
3887 get_uri(t) ? get_uri(t) : "NOTHING");
3888
3889 if (t == NULL) {
3890 show_oops(NULL, "notify_load_status_cb invalid parameters");
3891 return;
3892 }
3893
3894 switch (webkit_web_view_get_load_status(wview)) {
3895 case WEBKIT_LOAD_PROVISIONAL:
3896 /* 0 */
3897 abort_favicon_download(t);
3898 #if GTK_CHECK_VERSION(2, 20, 0)
3899 gtk_widget_show(t->spinner);
3900 gtk_spinner_start(GTK_SPINNER(t->spinner));
3901 #endif
3902 gtk_label_set_text(GTK_LABEL(t->label), "Loading");
3903
3904 gtk_widget_set_sensitive(GTK_WIDGET(t->stop), TRUE);
3905
3906 /* assume we are a new address */
3907 gdk_color_parse("white", &color);
3908 gtk_widget_modify_base(t->uri_entry, GTK_STATE_NORMAL, &color);
3909 statusbar_modify_attr(t, "white", XT_COLOR_BLACK);
3910
3911 /* take focus if we are visible */
3912 focus_webview(t);
3913 t->focus_wv = 1;
3914
3915 marks_clear(t);
3916 #ifdef USE_THREAD
3917 /* kill color thread */
3918 t->thread = NULL;
3919 #endif
3920 break;
3921
3922 case WEBKIT_LOAD_COMMITTED:
3923 /* 1 */
3924 uri = get_uri(t);
3925 if (uri == NULL)
3926 return;
3927 gtk_entry_set_text(GTK_ENTRY(t->uri_entry), uri);
3928
3929 if (t->status) {
3930 g_free(t->status);
3931 t->status = NULL;
3932 }
3933 set_status(t, (char *)uri, XT_STATUS_LOADING);
3934
3935 /* check if js white listing is enabled */
3936 if (enable_plugin_whitelist)
3937 check_and_set_pl(uri, t);
3938 if (enable_cookie_whitelist)
3939 check_and_set_cookie(uri, t);
3940 if (enable_js_whitelist)
3941 check_and_set_js(uri, t);
3942
3943 if (t->styled)
3944 apply_style(t);
3945
3946
3947 /* we know enough to autosave the session */
3948 if (session_autosave) {
3949 a.s = NULL;
3950 save_tabs(t, &a);
3951 }
3952
3953 show_ca_status(t, uri);
3954 run_script(t, JS_HINTING);
3955 break;
3956
3957 case WEBKIT_LOAD_FIRST_VISUALLY_NON_EMPTY_LAYOUT:
3958 /* 3 */
3959 if (color_visited_uris) {
3960 color_visited(t, color_visited_helper());
3961
3962 /* This colors the links you middle-click (open in new
3963 * tab) in the current tab. */
3964 if (t->tab_id != gtk_notebook_get_current_page(notebook) &&
3965 (uri = get_uri(t)) != NULL)
3966 color_visited(get_current_tab(),
3967 g_strdup_printf("{'%s' : 'dummy'}", uri));
3968 }
3969 break;
3970
3971 case WEBKIT_LOAD_FINISHED:
3972 /* 2 */
3973 if ((uri = get_uri(t)) == NULL)
3974 return;
3975
3976 if (!strncmp(uri, "http://", strlen("http://")) ||
3977 !strncmp(uri, "https://", strlen("https://")) ||
3978 !strncmp(uri, "file://", strlen("file://"))) {
3979 find.uri = (gchar *)uri;
3980 h = RB_FIND(history_list, &hl, &find);
3981 if (!h)
3982 insert_history_item(uri,
3983 get_title(t, FALSE), time(NULL));
3984 else
3985 h->time = time(NULL);
3986 }
3987
3988 set_status(t, (char *)uri, XT_STATUS_URI);
3989 #if WEBKIT_CHECK_VERSION(1, 1, 18)
3990 case WEBKIT_LOAD_FAILED:
3991 /* 4 */
3992 #endif
3993 #if GTK_CHECK_VERSION(2, 20, 0)
3994 gtk_spinner_stop(GTK_SPINNER(t->spinner));
3995 gtk_widget_hide(t->spinner);
3996 #endif
3997 default:
3998 gtk_widget_set_sensitive(GTK_WIDGET(t->stop), FALSE);
3999 break;
4000 }
4001
4002 if (t->item)
4003 gtk_widget_set_sensitive(GTK_WIDGET(t->backward), TRUE);
4004 else
4005 gtk_widget_set_sensitive(GTK_WIDGET(t->backward),
4006 can_go_back_for_real(t));
4007
4008 gtk_widget_set_sensitive(GTK_WIDGET(t->forward),
4009 can_go_forward_for_real(t));
4010 }
4011
4012 void
4013 notify_title_cb(WebKitWebView* wview, GParamSpec* pspec, struct tab *t)
4014 {
4015 const gchar *title = NULL, *win_title = NULL;
4016
4017 title = get_title(t, FALSE);
4018 win_title = get_title(t, TRUE);
4019 if (title) {
4020 gtk_label_set_text(GTK_LABEL(t->label), title);
4021 gtk_label_set_text(GTK_LABEL(t->tab_elems.label), title);
4022 }
4023
4024 if (win_title && t->tab_id == gtk_notebook_get_current_page(notebook))
4025 gtk_window_set_title(GTK_WINDOW(main_window), win_title);
4026 }
4027
4028 char *
4029 get_domain(const gchar *host)
4030 {
4031 size_t x;
4032 char *p;
4033
4034 /* handle silly domains like .co.uk */
4035
4036 if ((x = strlen(host)) <= 6)
4037 return (g_strdup(host));
4038
4039 if (host[x - 3] == '.' && host[x - 6] == '.') {
4040 x = x - 7;
4041 while (x > 0)
4042 if (host[x] != '.')
4043 x--;
4044 else
4045 return (g_strdup(&host[x + 1]));
4046 }
4047
4048 /* find first . */
4049 p = g_strrstr(host, ".");
4050 if (p == NULL)
4051 return (g_strdup(""));
4052 p--;
4053 while (p > host)
4054 if (*p != '.')
4055 p--;
4056 else
4057 return (g_strdup(p + 1));
4058
4059 return (g_strdup(host));
4060 }
4061
4062 void
4063 js_autorun(struct tab *t)
4064 {
4065 SoupURI *su = NULL;
4066 const gchar *uri;
4067 size_t got_default = 0, got_host = 0;
4068 struct stat sb;
4069 char deff[PATH_MAX], hostf[PATH_MAX];
4070 char *js = NULL, *jsat, *domain = NULL;
4071 FILE *deffile = NULL, *hostfile = NULL;
4072 JSGlobalContextRef ctx;
4073 WebKitWebFrame *frame;
4074 JSStringRef str;
4075 JSValueRef val, exception;
4076 char *es;
4077
4078 if (js_autorun_enabled == 0)
4079 return;
4080
4081 uri = get_uri(t);
4082 if (uri &&
4083 !(g_str_has_prefix(uri, "http://") ||
4084 g_str_has_prefix(uri, "https://")))
4085 goto done;
4086
4087 su = soup_uri_new(uri);
4088 if (su == NULL)
4089 goto done;
4090 if (!SOUP_URI_VALID_FOR_HTTP(su))
4091 goto done;
4092
4093 DNPRINTF(XT_D_JS, "%s: host: %s domain: %s\n", __func__,
4094 su->host, domain);
4095 domain = get_domain(su->host);
4096
4097 snprintf(deff, sizeof deff, "%s/default.js", js_dir);
4098 if ((deffile = fopen(deff, "r")) != NULL) {
4099 if (fstat(fileno(deffile), &sb) == -1) {
4100 show_oops(t, "can't stat default JS file");
4101 goto done;
4102 }
4103 got_default = sb.st_size;
4104 }
4105
4106 /* try host first followed by domain */
4107 snprintf(hostf, sizeof hostf, "%s/%s.js", js_dir, su->host);
4108 DNPRINTF(XT_D_JS, "trying file: %s\n", hostf);
4109 if ((hostfile = fopen(hostf, "r")) == NULL) {
4110 snprintf(hostf, sizeof hostf, "%s/%s.js", js_dir, domain);
4111 DNPRINTF(XT_D_JS, "trying file: %s\n", hostf);
4112 if ((hostfile = fopen(hostf, "r")) == NULL)
4113 goto nofile;
4114 }
4115 DNPRINTF(XT_D_JS, "file: %s\n", hostf);
4116 if (fstat(fileno(hostfile), &sb) == -1) {
4117 show_oops(t, "can't stat %s JS file", hostf);
4118 goto done;
4119 }
4120 got_host = sb.st_size;
4121
4122 nofile:
4123 if (got_default + got_host == 0)
4124 goto done;
4125
4126 js = g_malloc0(got_default + got_host + 1);
4127 jsat = js;
4128
4129 if (got_default) {
4130 if (fread(js, got_default, 1, deffile) != 1) {
4131 show_oops(t, "default file read error");
4132 goto done;
4133 }
4134 jsat = js + got_default;
4135 }
4136
4137 if (got_host) {
4138 if (fread(jsat, got_host, 1, hostfile) != 1) {
4139 show_oops(t, "host file read error");
4140 goto done;
4141 }
4142 }
4143
4144 /* this code needs to be redone */
4145 frame = webkit_web_view_get_main_frame(t->wv);
4146 ctx = webkit_web_frame_get_global_context(frame);
4147
4148 str = JSStringCreateWithUTF8CString(js);
4149 val = JSEvaluateScript(ctx, str, JSContextGetGlobalObject(ctx),
4150 NULL, 0, &exception);
4151 JSStringRelease(str);
4152
4153 DNPRINTF(XT_D_JS, "%s: val %p\n", __func__, val);
4154 if (val == NULL) {
4155 es = js_ref_to_string(ctx, exception);
4156 if (es) {
4157 show_oops(t, "script exception: %s", es);
4158 g_free(es);
4159 }
4160 goto done;
4161 } else {
4162 es = js_ref_to_string(ctx, val);
4163 g_free(es);
4164 #if 0
4165 /* return values */
4166 if (!strncmp(es, XT_JS_DONE, XT_JS_DONE_LEN))
4167 ; /* do nothing */
4168 if (!strncmp(es, XT_JS_INSERT, XT_JS_INSERT_LEN))
4169 ; /* do nothing */
4170 if (es) {
4171 show_oops(t, "script complete return value: '%s'", es);
4172 g_free(es);
4173 } else
4174 show_oops(t, "script complete: without a return value");
4175 #endif
4176 }
4177 done:
4178 if (su)
4179 soup_uri_free(su);
4180 if (js)
4181 g_free(js);
4182 if (deffile)
4183 fclose(deffile);
4184 if (hostfile)
4185 fclose(hostfile);
4186 if (domain)
4187 g_free(domain);
4188 }
4189
4190 void
4191 webview_load_finished_cb(WebKitWebView *wv, WebKitWebFrame *wf, struct tab *t)
4192 {
4193 /* autorun some js if enabled */
4194 js_autorun(t);
4195
4196 input_autofocus(t);
4197
4198 }
4199
4200 void
4201 webview_progress_changed_cb(WebKitWebView *wv, int progress, struct tab *t)
4202 {
4203 gtk_entry_set_progress_fraction(GTK_ENTRY(t->uri_entry),
4204 progress == 100 ? 0 : (double)progress / 100);
4205 if (show_url == 0) {
4206 gtk_entry_set_progress_fraction(GTK_ENTRY(t->sbe.statusbar),
4207 progress == 100 ? 0 : (double)progress / 100);
4208 }
4209
4210 update_statusbar_position(NULL, NULL);
4211 }
4212
4213 int
4214 webview_npd_cb(WebKitWebView *wv, WebKitWebFrame *wf,
4215 WebKitNetworkRequest *request, WebKitWebNavigationAction *na,
4216 WebKitWebPolicyDecision *pd, struct tab *t)
4217 {
4218 char *uri;
4219 WebKitWebNavigationReason reason;
4220 struct domain *d = NULL;
4221
4222 if (t == NULL) {
4223 show_oops(NULL, "webview_npd_cb invalid parameters");
4224 return (FALSE);
4225 }
4226
4227 DNPRINTF(XT_D_NAV, "webview_npd_cb: ctrl_click %d %s\n",
4228 t->ctrl_click,
4229 webkit_network_request_get_uri(request));
4230
4231 uri = (char *)webkit_network_request_get_uri(request);
4232
4233 /* if this is an xtp url, we don't load anything else */
4234 if (parse_xtp_url(t, uri))
4235 return (TRUE);
4236
4237 if ((t->mode == XT_MODE_HINT && t->new_tab) || t->ctrl_click) {
4238 t->ctrl_click = 0;
4239 create_new_tab(uri, NULL, ctrl_click_focus, -1);
4240 webkit_web_policy_decision_ignore(pd);
4241 return (TRUE); /* we made the decission */
4242 }
4243
4244 /*
4245 * This is a little hairy but it comes down to this:
4246 * when we run in whitelist mode we have to assist the browser in
4247 * opening the URL that it would have opened in a new tab.
4248 */
4249 reason = webkit_web_navigation_action_get_reason(na);
4250 if (reason == WEBKIT_WEB_NAVIGATION_REASON_LINK_CLICKED) {
4251 t->xtp_meaning = XT_XTP_TAB_MEANING_NORMAL;
4252 if (enable_scripts == 0 && enable_cookie_whitelist == 1)
4253 if (uri && (d = wl_find_uri(uri, &js_wl)) == NULL)
4254 load_uri(t, uri);
4255 webkit_web_policy_decision_use(pd);
4256 return (TRUE); /* we made the decision */
4257 }
4258
4259 return (FALSE);
4260 }
4261
4262 WebKitWebView *
4263 webview_cwv_cb(WebKitWebView *wv, WebKitWebFrame *wf, struct tab *t)
4264 {
4265 struct tab *tt;
4266 struct domain *d = NULL;
4267 const gchar *uri;
4268 WebKitWebView *webview = NULL;
4269 int x = 1;
4270
4271 DNPRINTF(XT_D_NAV, "webview_cwv_cb: %s\n",
4272 webkit_web_view_get_uri(wv));
4273
4274 if (tabless) {
4275 /* open in current tab */
4276 webview = t->wv;
4277 } else if (enable_scripts == 0 && enable_js_whitelist == 1) {
4278 uri = webkit_web_view_get_uri(wv);
4279 if (uri && (d = wl_find_uri(uri, &js_wl)) == NULL)
4280 return (NULL);
4281
4282 if (t->ctrl_click) {
4283 x = ctrl_click_focus;
4284 t->ctrl_click = 0;
4285 }
4286 tt = create_new_tab(NULL, NULL, x, -1);
4287 webview = tt->wv;
4288 } else if (enable_scripts == 1) {
4289 if (t->ctrl_click) {
4290 x = ctrl_click_focus;
4291 t->ctrl_click = 0;
4292 }
4293 tt = create_new_tab(NULL, NULL, x, -1);
4294 webview = tt->wv;
4295 }
4296
4297 return (webview);
4298 }
4299
4300 gboolean
4301 webview_closewv_cb(WebKitWebView *wv, struct tab *t)
4302 {
4303 const gchar *uri;
4304 struct domain *d = NULL;
4305
4306 DNPRINTF(XT_D_NAV, "webview_close_cb: %d\n", t->tab_id);
4307
4308 if (enable_scripts == 0 && enable_cookie_whitelist == 1) {
4309 uri = webkit_web_view_get_uri(wv);
4310 if (uri && (d = wl_find_uri(uri, &js_wl)) == NULL)
4311 return (FALSE);
4312
4313 delete_tab(t);
4314 } else if (enable_scripts == 1)
4315 delete_tab(t);
4316
4317 return (TRUE);
4318 }
4319
4320 int
4321 webview_event_cb(GtkWidget *w, GdkEventButton *e, struct tab *t)
4322 {
4323 /* we can not eat the event without throwing gtk off so defer it */
4324
4325 /* catch middle click */
4326 if (e->type == GDK_BUTTON_RELEASE && e->button == 2) {
4327 t->ctrl_click = 1;
4328 goto done;
4329 }
4330
4331 /* catch ctrl click */
4332 if (e->type == GDK_BUTTON_RELEASE &&
4333 CLEAN(e->state) == GDK_CONTROL_MASK)
4334 t->ctrl_click = 1;
4335 else
4336 t->ctrl_click = 0;
4337 done:
4338 return (XT_CB_PASSTHROUGH);
4339 }
4340
4341 int
4342 run_mimehandler(struct tab *t, char *mime_type, WebKitNetworkRequest *request)
4343 {
4344 struct mime_type *m;
4345
4346 m = find_mime_type(mime_type);
4347 if (m == NULL)
4348 return (1);
4349 if (m->mt_download)
4350 return (1);
4351
4352 switch (fork()) {
4353 case -1:
4354 show_oops(t, "can't fork mime handler");
4355 return (1);
4356 /* NOTREACHED */
4357 case 0:
4358 break;
4359 default:
4360 return (0);
4361 }
4362
4363 /* child */
4364 execlp(m->mt_action, m->mt_action,
4365 webkit_network_request_get_uri(request), (void *)NULL);
4366
4367 _exit(0);
4368
4369 /* NOTREACHED */
4370 return (0);
4371 }
4372
4373 char *
4374 get_mime_type(const char *file)
4375 {
4376 const gchar *m;
4377 char *mime_type = NULL;
4378 GFileInfo *fi;
4379 GFile *gf;
4380
4381 if (g_str_has_prefix(file, "file://"))
4382 file += strlen("file://");
4383
4384 gf = g_file_new_for_path(file);
4385 fi = g_file_query_info(gf, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE, 0,
4386 NULL, NULL);
4387 if ((m = g_file_info_get_content_type(fi)) != NULL)
4388 mime_type = g_strdup(m);
4389 g_object_unref(fi);
4390 g_object_unref(gf);
4391
4392 return (mime_type);
4393 }
4394
4395 int
4396 run_download_mimehandler(char *mime_type, char *file)
4397 {
4398 struct mime_type *m;
4399
4400 m = find_mime_type(mime_type);
4401 if (m == NULL)
4402 return (1);
4403
4404 switch (fork()) {
4405 case -1:
4406 show_oops(NULL, "can't fork download mime handler");
4407 return (1);
4408 /* NOTREACHED */
4409 case 0:
4410 break;
4411 default:
4412 return (0);
4413 }
4414
4415 /* child */
4416 if (g_str_has_prefix(file, "file://"))
4417 file += strlen("file://");
4418 execlp(m->mt_action, m->mt_action, file, (void *)NULL);
4419
4420 _exit(0);
4421
4422 /* NOTREACHED */
4423 return (0);
4424 }
4425
4426 void
4427 download_status_changed_cb(WebKitDownload *download, GParamSpec *spec,
4428 WebKitWebView *wv)
4429 {
4430 WebKitDownloadStatus status;
4431 const char *file = NULL;
4432 char *mime = NULL;
4433
4434 if (download == NULL)
4435 return;
4436 status = webkit_download_get_status(download);
4437 if (status != WEBKIT_DOWNLOAD_STATUS_FINISHED)
4438 return;
4439
4440 file = webkit_download_get_destination_uri(download);
4441 if (file == NULL)
4442 return;
4443 mime = get_mime_type(file);
4444 if (mime == NULL)
4445 return;
4446
4447 run_download_mimehandler((char *)mime, (char *)file);
4448 g_free(mime);
4449 }
4450
4451 int
4452 webview_mimetype_cb(WebKitWebView *wv, WebKitWebFrame *frame,
4453 WebKitNetworkRequest *request, char *mime_type,
4454 WebKitWebPolicyDecision *decision, struct tab *t)
4455 {
4456 if (t == NULL) {
4457 show_oops(NULL, "webview_mimetype_cb invalid parameters");
4458 return (FALSE);
4459 }
4460
4461 DNPRINTF(XT_D_DOWNLOAD, "webview_mimetype_cb: tab %d mime %s\n",
4462 t->tab_id, mime_type);
4463
4464 if (run_mimehandler(t, mime_type, request) == 0) {
4465 webkit_web_policy_decision_ignore(decision);
4466 focus_webview(t);
4467 return (TRUE);
4468 }
4469
4470 if (webkit_web_view_can_show_mime_type(wv, mime_type) == FALSE) {
4471 webkit_web_policy_decision_download(decision);
4472 return (TRUE);
4473 }
4474
4475 return (FALSE);
4476 }
4477
4478 int
4479 webview_download_cb(WebKitWebView *wv, WebKitDownload *wk_download,
4480 struct tab *t)
4481 {
4482 struct stat sb;
4483 const gchar *suggested_name;
4484 gchar *filename = NULL;
4485 char *uri = NULL;
4486 struct download *download_entry;
4487 int i, ret = TRUE;
4488
4489 if (wk_download == NULL || t == NULL) {
4490 show_oops(NULL, "%s invalid parameters", __func__);
4491 return (FALSE);
4492 }
4493
4494 suggested_name = webkit_download_get_suggested_filename(wk_download);
4495 if (suggested_name == NULL)
4496 return (FALSE); /* abort download */
4497
4498 i = 0;
4499 do {
4500 if (filename) {
4501 g_free(filename);
4502 filename = NULL;
4503 }
4504 if (i) {
4505 g_free(uri);
4506 uri = NULL;
4507 filename = g_strdup_printf("%d%s", i, suggested_name);
4508 }
4509 uri = g_strdup_printf("file://%s/%s", download_dir, i ?
4510 filename : suggested_name);
4511 i++;
4512 } while (!stat(uri + strlen("file://"), &sb));
4513
4514 DNPRINTF(XT_D_DOWNLOAD, "%s: tab %d filename %s "
4515 "local %s\n", __func__, t->tab_id, filename, uri);
4516
4517 webkit_download_set_destination_uri(wk_download, uri);
4518
4519 if (webkit_download_get_status(wk_download) ==
4520 WEBKIT_DOWNLOAD_STATUS_ERROR) {
4521 show_oops(t, "%s: download failed to start", __func__);
4522 ret = FALSE;
4523 gtk_label_set_text(GTK_LABEL(t->label), "Download Failed");
4524 } else {
4525 /* connect "download first" mime handler */
4526 g_signal_connect(G_OBJECT(wk_download), "notify::status",
4527 G_CALLBACK(download_status_changed_cb), NULL);
4528
4529 download_entry = g_malloc(sizeof(struct download));
4530 download_entry->download = wk_download;
4531 download_entry->tab = t;
4532 download_entry->id = next_download_id++;
4533 RB_INSERT(download_list, &downloads, download_entry);
4534 /* get from history */
4535 g_object_ref(wk_download);
4536 gtk_label_set_text(GTK_LABEL(t->label), "Downloading");
4537 show_oops(t, "Download of '%s' started...",
4538 basename((char *)webkit_download_get_destination_uri(wk_download)));
4539 }
4540
4541 if (uri)
4542 g_free(uri);
4543
4544 if (filename)
4545 g_free(filename);
4546
4547 /* sync other download manager tabs */
4548 update_download_tabs(NULL);
4549
4550 /*
4551 * NOTE: never redirect/render the current tab before this
4552 * function returns. This will cause the download to never start.
4553 */
4554 return (ret); /* start download */
4555 }
4556
4557 void
4558 webview_hover_cb(WebKitWebView *wv, gchar *title, gchar *uri, struct tab *t)
4559 {
4560 DNPRINTF(XT_D_KEY, "webview_hover_cb: %s %s\n", title, uri);
4561
4562 if (t == NULL) {
4563 show_oops(NULL, "webview_hover_cb");
4564 return;
4565 }
4566
4567 if (uri)
4568 set_status(t, uri, XT_STATUS_LINK);
4569 else {
4570 if (t->status)
4571 set_status(t, t->status, XT_STATUS_NOTHING);
4572 }
4573 }
4574
4575 int
4576 mark(struct tab *t, struct karg *arg)
4577 {
4578 char mark;
4579 int index;
4580
4581 mark = arg->s[1];
4582 if ((index = marktoindex(mark)) == -1)
4583 return (-1);
4584
4585 if (arg->i == XT_MARK_SET)
4586 t->mark[index] = gtk_adjustment_get_value(t->adjust_v);
4587 else if (arg->i == XT_MARK_GOTO) {
4588 if (t->mark[index] == XT_INVALID_MARK) {
4589 show_oops(t, "mark '%c' does not exist", mark);
4590 return (-1);
4591 }
4592 /* XXX t->mark[index] can be bigger than the maximum if ajax or
4593 something changes the document size */
4594 gtk_adjustment_set_value(t->adjust_v, t->mark[index]);
4595 }
4596
4597 return (0);
4598 }
4599
4600 void
4601 marks_clear(struct tab *t)
4602 {
4603 int i;
4604
4605 for (i = 0; i < LENGTH(t->mark); i++)
4606 t->mark[i] = XT_INVALID_MARK;
4607 }
4608
4609 int
4610 qmarks_load(void)
4611 {
4612 char file[PATH_MAX];
4613 char *line = NULL, *p;
4614 int index, i;
4615 FILE *f;
4616 size_t linelen;
4617
4618 snprintf(file, sizeof file, "%s/%s", work_dir, XT_QMARKS_FILE);
4619 if ((f = fopen(file, "r+")) == NULL) {
4620 show_oops(NULL, "Can't open quickmarks file: %s", strerror(errno));
4621 return (1);
4622 }
4623
4624 for (i = 1; ; i++) {
4625 if ((line = fparseln(f, &linelen, NULL, NULL, 0)) == NULL)
4626 break;
4627 if (strlen(line) == 0 || line[0] == '#') {
4628 free(line);
4629 line = NULL;
4630 continue;
4631 }
4632
4633 p = strtok(line, " \t");
4634
4635 if (p == NULL || strlen(p) != 1 ||
4636 (index = marktoindex(*p)) == -1) {
4637 warnx("corrupt quickmarks file, line %d", i);
4638 break;
4639 }
4640
4641 p = strtok(NULL, " \t");
4642 if (qmarks[index] != NULL)
4643 g_free(qmarks[index]);
4644 qmarks[index] = g_strdup(p);
4645 }
4646
4647 fclose(f);
4648
4649 return (0);
4650 }
4651
4652 int
4653 qmarks_save(void)
4654 {
4655 char file[PATH_MAX];
4656 int i;
4657 FILE *f;
4658
4659 snprintf(file, sizeof file, "%s/%s", work_dir, XT_QMARKS_FILE);
4660 if ((f = fopen(file, "r+")) == NULL) {
4661 show_oops(NULL, "Can't open quickmarks file: %s", strerror(errno));
4662 return (1);
4663 }
4664
4665 for (i = 0; i < XT_NOMARKS; i++)
4666 if (qmarks[i] != NULL)
4667 fprintf(f, "%c %s\n", indextomark(i), qmarks[i]);
4668
4669 fclose(f);
4670
4671 return (0);
4672 }
4673
4674 int
4675 qmark(struct tab *t, struct karg *arg)
4676 {
4677 char mark;
4678 int index;
4679
4680 mark = arg->s[strlen(arg->s)-1];
4681 index = marktoindex(mark);
4682 if (index == -1)
4683 return (-1);
4684
4685 switch (arg->i) {
4686 case XT_QMARK_SET:
4687 if (qmarks[index] != NULL)
4688 g_free(qmarks[index]);
4689
4690 qmarks_load(); /* sync if multiple instances */
4691 qmarks[index] = g_strdup(get_uri(t));
4692 qmarks_save();
4693 break;
4694 case XT_QMARK_OPEN:
4695 if (qmarks[index] != NULL)
4696 load_uri(t, qmarks[index]);
4697 else {
4698 show_oops(t, "quickmark \"%c\" does not exist",
4699 mark);
4700 return (-1);
4701 }
4702 break;
4703 case XT_QMARK_TAB:
4704 if (qmarks[index] != NULL)
4705 create_new_tab(qmarks[index], NULL, 1, -1);
4706 else {
4707 show_oops(t, "quickmark \"%c\" does not exist",
4708 mark);
4709 return (-1);
4710 }
4711 break;
4712 }
4713
4714 return (0);
4715 }
4716
4717 int
4718 go_up(struct tab *t, struct karg *args)
4719 {
4720 int levels;
4721 char *uri;
4722 char *tmp;
4723
4724 levels = atoi(args->s);
4725 if (levels == 0)
4726 levels = 1;
4727
4728 uri = g_strdup(webkit_web_view_get_uri(t->wv));
4729 if ((tmp = strstr(uri, XT_PROTO_DELIM)) == NULL)
4730 return (1);
4731 tmp += strlen(XT_PROTO_DELIM);
4732
4733 /* if an uri starts with a slash, leave it alone (for file:///) */
4734 if (tmp[0] == '/')
4735 tmp++;
4736
4737 while (levels--) {
4738 char *p;
4739
4740 p = strrchr(tmp, '/');
4741 if (p != NULL)
4742 *p = '\0';
4743 else
4744 break;
4745 }
4746
4747 load_uri(t, uri);
4748 g_free(uri);
4749
4750 return (0);
4751 }
4752
4753 int
4754 gototab(struct tab *t, struct karg *args)
4755 {
4756 int tab;
4757 struct karg arg = {0, NULL, -1};
4758
4759 tab = atoi(args->s);
4760
4761 arg.i = XT_TAB_NEXT;
4762 arg.precount = tab;
4763
4764 movetab(t, &arg);
4765
4766 return (0);
4767 }
4768
4769 int
4770 zoom_amount(struct tab *t, struct karg *arg)
4771 {
4772 struct karg narg = {0, NULL, -1};
4773
4774 narg.i = atoi(arg->s);
4775 resizetab(t, &narg);
4776
4777 return (0);
4778 }
4779
4780 int
4781 flip_colon(struct tab *t, struct karg *arg)
4782 {
4783 struct karg narg = {0, NULL, -1};
4784 char *p;
4785
4786 if (t == NULL || arg == NULL)
4787 return (1);
4788
4789 p = strstr(arg->s, ":");
4790 if (p == NULL)
4791 return (1);
4792 *p = '\0';
4793
4794 narg.i = ':';
4795 narg.s = arg->s;
4796 command(t, &narg);
4797
4798 return (0);
4799 }
4800
4801 /* buffer commands receive the regex that triggered them in arg.s */
4802 char bcmd[XT_BUFCMD_SZ];
4803 struct buffercmd {
4804 char *regex;
4805 int precount;
4806 #define XT_PRE_NO (0)
4807 #define XT_PRE_YES (1)
4808 #define XT_PRE_MAYBE (2)
4809 char *cmd;
4810 int (*func)(struct tab *, struct karg *);
4811 int arg;
4812 regex_t cregex;
4813 } buffercmds[] = {
4814 { "^[0-9]*gu$", XT_PRE_MAYBE, "gu", go_up, 0 },
4815 { "^gg$", XT_PRE_NO, "gg", move, XT_MOVE_TOP },
4816 { "^gG$", XT_PRE_NO, "gG", move, XT_MOVE_BOTTOM },
4817 { "^[0-9]+%$", XT_PRE_YES, "%", move, XT_MOVE_PERCENT },
4818 { "^zz$", XT_PRE_NO, "zz", move, XT_MOVE_CENTER },
4819 { "^gh$", XT_PRE_NO, "gh", go_home, 0 },
4820 { "^m[a-zA-Z0-9]$", XT_PRE_NO, "m", mark, XT_MARK_SET },
4821 { "^['][a-zA-Z0-9]$", XT_PRE_NO, "'", mark, XT_MARK_GOTO },
4822 { "^[0-9]+t$", XT_PRE_YES, "t", gototab, 0 },
4823 { "^M[a-zA-Z0-9]$", XT_PRE_NO, "M", qmark, XT_QMARK_SET },
4824 { "^go[a-zA-Z0-9]$", XT_PRE_NO, "go", qmark, XT_QMARK_OPEN },
4825 { "^gn[a-zA-Z0-9]$", XT_PRE_NO, "gn", qmark, XT_QMARK_TAB },
4826 { "^ZR$", XT_PRE_NO, "ZR", restart, 0 },
4827 { "^ZZ$", XT_PRE_NO, "ZZ", quit, 0 },
4828 { "^zi$", XT_PRE_NO, "zi", resizetab, XT_ZOOM_IN },
4829 { "^zo$", XT_PRE_NO, "zo", resizetab, XT_ZOOM_OUT },
4830 { "^z0$", XT_PRE_NO, "z0", resizetab, XT_ZOOM_NORMAL },
4831 { "^[0-9]+Z$", XT_PRE_YES, "Z", zoom_amount, 0 },
4832 { "^[0-9]+:$", XT_PRE_YES, ":", flip_colon, 0 },
4833 };
4834
4835 void
4836 buffercmd_init(void)
4837 {
4838 int i;
4839
4840 for (i = 0; i < LENGTH(buffercmds); i++)
4841 if (regcomp(&buffercmds[i].cregex, buffercmds[i].regex,
4842 REG_EXTENDED | REG_NOSUB))
4843 startpage_add("invalid buffercmd regex %s",
4844 buffercmds[i].regex);
4845 }
4846
4847 void
4848 buffercmd_abort(struct tab *t)
4849 {
4850 int i;
4851
4852 DNPRINTF(XT_D_BUFFERCMD, "buffercmd_abort: clearing buffer\n");
4853 for (i = 0; i < LENGTH(bcmd); i++)
4854 bcmd[i] = '\0';
4855
4856 cmd_prefix = 0; /* clear prefix for non-buffer commands */
4857 gtk_entry_set_text(GTK_ENTRY(t->sbe.buffercmd), bcmd);
4858 }
4859
4860 void
4861 buffercmd_execute(struct tab *t, struct buffercmd *cmd)
4862 {
4863 struct karg arg = {0, NULL, -1};
4864
4865 arg.i = cmd->arg;
4866 arg.s = g_strdup(bcmd);
4867
4868 DNPRINTF(XT_D_BUFFERCMD, "buffercmd_execute: buffer \"%s\" "
4869 "matches regex \"%s\", executing\n", bcmd, cmd->regex);
4870 cmd->func(t, &arg);
4871
4872 if (arg.s)
4873 g_free(arg.s);
4874
4875 buffercmd_abort(t);
4876 }
4877
4878 gboolean
4879 buffercmd_addkey(struct tab *t, guint keyval)
4880 {
4881 int i, c, match ;
4882 char s[XT_BUFCMD_SZ];
4883
4884 if (keyval == GDK_Escape) {
4885 buffercmd_abort(t);
4886 return (XT_CB_HANDLED);
4887 }
4888
4889 /* key with modifier or non-ascii character */
4890 if (!isascii(keyval)) {
4891 /*
4892 * XXX this looks wrong but fixes some sites like
4893 * http://www.seslisozluk.com/
4894 * that eat a shift or ctrl and end putting default focus in js
4895 * instead of ignoring the keystroke
4896 * so instead of return (XT_CB_PASSTHROUGH); eat the key
4897 */
4898 return (XT_CB_HANDLED);
4899 }
4900
4901 DNPRINTF(XT_D_BUFFERCMD, "buffercmd_addkey: adding key \"%c\" "
4902 "to buffer \"%s\"\n", keyval, bcmd);
4903
4904 for (i = 0; i < LENGTH(bcmd); i++)
4905 if (bcmd[i] == '\0') {
4906 bcmd[i] = keyval;
4907 break;
4908 }
4909
4910 /* buffer full, ignore input */
4911 if (i >= LENGTH(bcmd) -1) {
4912 DNPRINTF(XT_D_BUFFERCMD, "buffercmd_addkey: buffer full\n");
4913 buffercmd_abort(t);
4914 return (XT_CB_HANDLED);
4915 }
4916
4917 gtk_entry_set_text(GTK_ENTRY(t->sbe.buffercmd), bcmd);
4918
4919 /* find exact match */
4920 for (i = 0; i < LENGTH(buffercmds); i++)
4921 if (regexec(&buffercmds[i].cregex, bcmd,
4922 (size_t) 0, NULL, 0) == 0) {
4923 buffercmd_execute(t, &buffercmds[i]);
4924 goto done;
4925 }
4926
4927 /* find non exact matches to see if we need to abort ot not */
4928 for (i = 0, match = 0; i < LENGTH(buffercmds); i++) {
4929 DNPRINTF(XT_D_BUFFERCMD, "trying: %s\n", bcmd);
4930 c = -1;
4931 s[0] = '\0';
4932 if (buffercmds[i].precount == XT_PRE_MAYBE) {
4933 if (isdigit(bcmd[0])) {
4934 if (sscanf(bcmd, "%d%s", &c, s) == 0)
4935 continue;
4936 } else {
4937 c = 0;
4938 if (sscanf(bcmd, "%s", s) == 0)
4939 continue;
4940 }
4941 } else if (buffercmds[i].precount == XT_PRE_YES) {
4942 if (sscanf(bcmd, "%d%s", &c, s) == 0)
4943 continue;
4944 } else {
4945 if (sscanf(bcmd, "%s", s) == 0)
4946 continue;
4947 }
4948 if (c == -1 && buffercmds[i].precount)
4949 continue;
4950 if (!strncmp(s, buffercmds[i].cmd, strlen(s)))
4951 match++;
4952
4953 DNPRINTF(XT_D_BUFFERCMD, "got[%d] %d <%s>: %d %s\n",
4954 i, match, buffercmds[i].cmd, c, s);
4955 }
4956 if (match == 0) {
4957 DNPRINTF(XT_D_BUFFERCMD, "aborting: %s\n", bcmd);
4958 buffercmd_abort(t);
4959 }
4960
4961 done:
4962 return (XT_CB_HANDLED);
4963 }
4964
4965 gboolean
4966 handle_keypress(struct tab *t, GdkEventKey *e, int entry)
4967 {
4968 struct key_binding *k;
4969
4970 /* handle keybindings if buffercmd is empty.
4971 if not empty, allow commands like C-n */
4972 if (bcmd[0] == '\0' || ((e->state & (CTRL | MOD1)) != 0))
4973 TAILQ_FOREACH(k, &kbl, entry)
4974 if (e->keyval == k->key
4975 && (entry ? k->use_in_entry : 1)) {
4976 /* when we are edditing eat ctrl/mod keys */
4977 if (edit_mode == XT_EM_VI &&
4978 t->mode == XT_MODE_INSERT &&
4979 (e->state & CTRL || e->state & MOD1))
4980 return (XT_CB_PASSTHROUGH);
4981
4982 if (k->mask == 0) {
4983 if ((e->state & (CTRL | MOD1)) == 0)
4984 return (cmd_execute(t, k->cmd));
4985 } else if ((e->state & k->mask) == k->mask) {
4986 return (cmd_execute(t, k->cmd));
4987 }
4988 }
4989
4990 if (!entry && ((e->state & (CTRL | MOD1)) == 0))
4991 return buffercmd_addkey(t, e->keyval);
4992
4993 return (XT_CB_PASSTHROUGH);
4994 }
4995
4996 int
4997 wv_keypress_cb(GtkEntry *w, GdkEventKey *e, struct tab *t)
4998 {
4999 char s[2];
5000 void *active = NULL;
5001
5002 /* don't use w directly; use t->whatever instead */
5003
5004 if (t == NULL) {
5005 show_oops(NULL, "wv_keypress_cb");
5006 return (XT_CB_PASSTHROUGH);
5007 }
5008
5009 hide_oops(t);
5010
5011 DNPRINTF(XT_D_KEY, "wv_keypress_cb: mode %d keyval 0x%x mask "
5012 "0x%x tab %d\n", t->mode, e->keyval, e->state, t->tab_id);
5013
5014 /* Hide buffers, if they are visible, with escape. */
5015 if (gtk_widget_get_visible(GTK_WIDGET(t->buffers)) &&
5016 CLEAN(e->state) == 0 && e->keyval == GDK_Escape) {
5017 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
5018 hide_buffers(t);
5019 return (XT_CB_HANDLED);
5020 }
5021
5022 if (t->mode == XT_MODE_HINT)
5023 return (XT_CB_HANDLED);
5024
5025 if ((CLEAN(e->state) == 0 && e->keyval == GDK_Tab) ||
5026 (CLEAN(e->state) == SHFT && e->keyval == GDK_Tab))
5027 /* something focussy is about to happen */
5028 return (XT_CB_PASSTHROUGH);
5029
5030 /* check if we are some sort of text input thing in the dom */
5031 active = input_check_mode(t);
5032
5033 if (t->mode == XT_MODE_HINT) {
5034 /* XXX make sure cmd entry is enabled */
5035 return (XT_CB_HANDLED);
5036 } else if (t->mode == XT_MODE_COMMAND) {
5037 /* prefix input */
5038 snprintf(s, sizeof s, "%c", e->keyval);
5039 if (CLEAN(e->state) == 0 && isdigit(s[0]))
5040 cmd_prefix = 10 * cmd_prefix + atoi(s);
5041 return (handle_keypress(t, e, 0));
5042 } else {
5043 /* insert mode */
5044 return (handle_keypress(t, e, 1));
5045 }
5046
5047 /* NOTREACHED */
5048 return (XT_CB_PASSTHROUGH);
5049 }
5050
5051 gboolean
5052 hint_continue(struct tab *t)
5053 {
5054 const gchar *c = gtk_entry_get_text(GTK_ENTRY(t->cmd));
5055 char *s;
5056 const gchar *errstr = NULL;
5057 gboolean rv = TRUE;
5058 long long i;
5059
5060 if (!(c[0] == '.' || c[0] == ','))
5061 goto done;
5062 if (strlen(c) == 1) {
5063 /* XXX should not happen */
5064 rv = TRUE;
5065 goto done;
5066 }
5067
5068 if (isdigit(c[1])) {
5069 /* numeric input */
5070 i = strtonum(&c[1], 1, 4096, &errstr);
5071 if (errstr) {
5072 show_oops(t, "invalid numerical hint %s", &c[1]);
5073 goto done;
5074 }
5075 s = g_strdup_printf("hints.updateHints(%lld);", i);
5076 run_script(t, s);
5077 g_free(s);
5078 } else {
5079 /* alphanumeric input */
5080 s = g_strdup_printf("hints.createHints('%s', '%c');",
5081 &c[1], c[0] == '.' ? 'f' : 'F');
5082 run_script(t, s);
5083 g_free(s);
5084 }
5085
5086 rv = FALSE;
5087 done:
5088 return (rv);
5089 }
5090
5091 gboolean
5092 search_continue(struct tab *t)
5093 {
5094 const gchar *c = gtk_entry_get_text(GTK_ENTRY(t->cmd));
5095 gboolean rv = FALSE;
5096
5097 if (c[0] == ':' || c[0] == '.' || c[0] == ',')
5098 goto done;
5099 if (strlen(c) == 1) {
5100 webkit_web_view_unmark_text_matches(t->wv);
5101 goto done;
5102 }
5103
5104 if (c[0] == '/')
5105 t->search_forward = TRUE;
5106 else if (c[0] == '?')
5107 t->search_forward = FALSE;
5108 else
5109 goto done;
5110
5111 rv = TRUE;
5112 done:
5113 return (rv);
5114 }
5115
5116 gboolean
5117 search_cb(struct tab *t)
5118 {
5119 const gchar *c = gtk_entry_get_text(GTK_ENTRY(t->cmd));
5120 GdkColor color;
5121
5122 if (search_continue(t) == FALSE)
5123 goto done;
5124
5125 /* search */
5126 if (webkit_web_view_search_text(t->wv, &c[1], FALSE, t->search_forward,
5127 TRUE) == FALSE) {
5128 /* not found, mark red */
5129 gdk_color_parse(XT_COLOR_RED, &color);
5130 gtk_widget_modify_base(t->cmd, GTK_STATE_NORMAL, &color);
5131 /* unmark and remove selection */
5132 webkit_web_view_unmark_text_matches(t->wv);
5133 /* my kingdom for a way to unselect text in webview */
5134 } else {
5135 /* found, highlight all */
5136 webkit_web_view_unmark_text_matches(t->wv);
5137 webkit_web_view_mark_text_matches(t->wv, &c[1], FALSE, 0);
5138 webkit_web_view_set_highlight_text_matches(t->wv, TRUE);
5139 gdk_color_parse(XT_COLOR_WHITE, &color);
5140 gtk_widget_modify_base(t->cmd, GTK_STATE_NORMAL, &color);
5141 }
5142 done:
5143 t->search_id = 0;
5144 return (FALSE);
5145 }
5146
5147 int
5148 cmd_keyrelease_cb(GtkEntry *w, GdkEventKey *e, struct tab *t)
5149 {
5150 const gchar *c = gtk_entry_get_text(w);
5151
5152 if (t == NULL) {
5153 show_oops(NULL, "cmd_keyrelease_cb invalid parameters");
5154 return (XT_CB_PASSTHROUGH);
5155 }
5156
5157 DNPRINTF(XT_D_CMD, "cmd_keyrelease_cb: keyval 0x%x mask 0x%x tab %d\n",
5158 e->keyval, e->state, t->tab_id);
5159
5160 /* hinting */
5161 if (!(e->keyval == GDK_Tab || e->keyval == GDK_ISO_Left_Tab)) {
5162 if (hint_continue(t) == FALSE)
5163 goto done;
5164 }
5165
5166 /* search */
5167 if (search_continue(t) == FALSE)
5168 goto done;
5169
5170 /* if search length is > 4 then no longer play timeout games */
5171 if (strlen(c) > 4) {
5172 if (t->search_id) {
5173 g_source_remove(t->search_id);
5174 t->search_id = 0;
5175 }
5176 search_cb(t);
5177 goto done;
5178 }
5179
5180 /* reestablish a new timer if the user types fast */
5181 if (t->search_id)
5182 g_source_remove(t->search_id);
5183 t->search_id = g_timeout_add(250, (GSourceFunc)search_cb, (gpointer)t);
5184
5185 done:
5186 return (XT_CB_PASSTHROUGH);
5187 }
5188
5189 gboolean
5190 match_uri(const gchar *uri, const gchar *key) {
5191 gchar *voffset;
5192 size_t len;
5193 gboolean match = FALSE;
5194
5195 len = strlen(key);
5196
5197 if (!strncmp(key, uri, len))
5198 match = TRUE;
5199 else {
5200 voffset = strstr(uri, "/") + 2;
5201 if (!strncmp(key, voffset, len))
5202 match = TRUE;
5203 else if (g_str_has_prefix(voffset, "www.")) {
5204 voffset = voffset + strlen("www.");
5205 if (!strncmp(key, voffset, len))
5206 match = TRUE;
5207 }
5208 }
5209
5210 return (match);
5211 }
5212
5213 gboolean
5214 match_session(const gchar *name, const gchar *key) {
5215 char *sub;
5216
5217 sub = strcasestr(name, key);
5218
5219 return sub == name;
5220 }
5221
5222 void
5223 cmd_getlist(int id, char *key)
5224 {
5225 int i, dep, c = 0;
5226 struct history *h;
5227 struct session *s;
5228
5229 if (id >= 0) {
5230 if (cmds[id].type & XT_URLARG) {
5231 RB_FOREACH_REVERSE(h, history_list, &hl)
5232 if (match_uri(h->uri, key)) {
5233 cmd_status.list[c] = (char *)h->uri;
5234 if (++c > 255)
5235 break;
5236 }
5237 cmd_status.len = c;
5238 return;
5239 } else if (cmds[id].type & XT_SESSARG) {
5240 TAILQ_FOREACH(s, &sessions, entry)
5241 if (match_session(s->name, key)) {
5242 cmd_status.list[c] = (char *)s->name;
5243 if (++c > 255)
5244 break;
5245 }
5246 cmd_status.len = c;
5247 return;
5248 } else if (cmds[id].type & XT_SETARG) {
5249 for (i = 0; i < get_settings_size(); i++)
5250 if(!strncmp(key, get_setting_name(i),
5251 strlen(key)))
5252 cmd_status.list[c++] = get_setting_name(i);
5253 cmd_status.len = c;
5254 return;
5255 }
5256 }
5257
5258 dep = (id == -1) ? 0 : cmds[id].level + 1;
5259
5260 for (i = id + 1; i < LENGTH(cmds); i++) {
5261 if (cmds[i].level < dep)
5262 break;
5263 if (cmds[i].level == dep && !strncmp(key, cmds[i].cmd,
5264 strlen(key)) && !isdigit(cmds[i].cmd[0]))
5265 cmd_status.list[c++] = cmds[i].cmd;
5266
5267 }
5268
5269 cmd_status.len = c;
5270 }
5271
5272 char *
5273 cmd_getnext(int dir)
5274 {
5275 cmd_status.index += dir;
5276
5277 if (cmd_status.index < 0)
5278 cmd_status.index = cmd_status.len - 1;
5279 else if (cmd_status.index >= cmd_status.len)
5280 cmd_status.index = 0;
5281
5282 return cmd_status.list[cmd_status.index];
5283 }
5284
5285 int
5286 cmd_tokenize(char *s, char *tokens[])
5287 {
5288 int i = 0;
5289 char *tok, *last = NULL;
5290 size_t len = strlen(s);
5291 bool blank;
5292
5293 blank = len == 0 || (len > 0 && s[len - 1] == ' ');
5294 for (tok = strtok_r(s, " ", &last); tok && i < 3;
5295 tok = strtok_r(NULL, " ", &last), i++)
5296 tokens[i] = tok;
5297
5298 if (blank && i < 3)
5299 tokens[i++] = "";
5300
5301 return (i);
5302 }
5303
5304 void
5305 cmd_complete(struct tab *t, char *str, int dir)
5306 {
5307 GtkEntry *w = GTK_ENTRY(t->cmd);
5308 int i, j, levels, c = 0, dep = 0, parent = -1;
5309 int matchcount = 0;
5310 char *tok, *match, *s = g_strdup(str);
5311 char *tokens[3];
5312 char res[XT_MAX_URL_LENGTH + 32] = ":";
5313 char *sc = s;
5314
5315 DNPRINTF(XT_D_CMD, "%s: complete %s\n", __func__, str);
5316
5317 /* copy prefix*/
5318 for (i = 0; isdigit(s[i]); i++)
5319 res[i + 1] = s[i];
5320
5321 for (; isspace(s[i]); i++)
5322 res[i + 1] = s[i];
5323
5324 s += i;
5325
5326 levels = cmd_tokenize(s, tokens);
5327
5328 for (i = 0; i < levels - 1; i++) {
5329 tok = tokens[i];
5330 matchcount = 0;
5331 for (j = c; j < LENGTH(cmds); j++) {
5332 if (cmds[j].level < dep)
5333 break;
5334 if (cmds[j].level == dep && !strncmp(tok, cmds[j].cmd,
5335 strlen(tok))) {
5336 matchcount++;
5337 c = j + 1;
5338 if (strlen(tok) == strlen(cmds[j].cmd)) {
5339 matchcount = 1;
5340 break;
5341 }
5342 }
5343 }
5344
5345 if (matchcount == 1) {
5346 strlcat(res, tok, sizeof res);
5347 strlcat(res, " ", sizeof res);
5348 dep++;
5349 } else {
5350 g_free(sc);
5351 return;
5352 }
5353
5354 parent = c - 1;
5355 }
5356
5357 if (cmd_status.index == -1)
5358 cmd_getlist(parent, tokens[i]);
5359
5360 if (cmd_status.len > 0) {
5361 match = cmd_getnext(dir);
5362 strlcat(res, match, sizeof res);
5363 gtk_entry_set_text(w, res);
5364 gtk_editable_set_position(GTK_EDITABLE(w), -1);
5365 }
5366
5367 g_free(sc);
5368 }
5369
5370 gboolean
5371 cmd_execute(struct tab *t, char *str)
5372 {
5373 struct cmd *cmd = NULL;
5374 char *tok, *last = NULL, *s = g_strdup(str), *sc;
5375 char prefixstr[4];
5376 int j, len, c = 0, dep = 0, matchcount = 0;
5377 int prefix = -1, rv = XT_CB_PASSTHROUGH;
5378 struct karg arg = {0, NULL, -1};
5379
5380 sc = s;
5381
5382 /* copy prefix*/
5383 for (j = 0; j<3 && isdigit(s[j]); j++)
5384 prefixstr[j]=s[j];
5385
5386 prefixstr[j]='\0';
5387
5388 s += j;
5389 while (isspace(s[0]))
5390 s++;
5391
5392 if (strlen(s) > 0 && strlen(prefixstr) > 0)
5393 prefix = atoi(prefixstr);
5394 else
5395 s = sc;
5396
5397 for (tok = strtok_r(s, " ", &last); tok;
5398 tok = strtok_r(NULL, " ", &last)) {
5399 matchcount = 0;
5400 for (j = c; j < LENGTH(cmds); j++) {
5401 if (cmds[j].level < dep)
5402 break;
5403 len = (tok[strlen(tok) - 1] == '!') ? strlen(tok) - 1 :
5404 strlen(tok);
5405 if (cmds[j].level == dep &&
5406 !strncmp(tok, cmds[j].cmd, len)) {
5407 matchcount++;
5408 c = j + 1;
5409 cmd = &cmds[j];
5410 if (len == strlen(cmds[j].cmd)) {
5411 matchcount = 1;
5412 break;
5413 }
5414 }
5415 }
5416 if (matchcount == 1) {
5417 if (cmd->type > 0)
5418 goto execute_cmd;
5419 dep++;
5420 } else {
5421 show_oops(t, "Invalid command: %s", str);
5422 goto done;
5423 }
5424 }
5425 execute_cmd:
5426 if (cmd == NULL) {
5427 show_oops(t, "Empty command");
5428 goto done;
5429 }
5430 arg.i = cmd->arg;
5431
5432 if (prefix != -1)
5433 arg.precount = prefix;
5434 else if (cmd_prefix > 0)
5435 arg.precount = cmd_prefix;
5436
5437 if (j > 0 && !(cmd->type & XT_PREFIX) && arg.precount > -1) {
5438 show_oops(t, "No prefix allowed: %s", str);
5439 goto done;
5440 }
5441 if (cmd->type > 1)
5442 arg.s = last ? g_strdup(last) : g_strdup("");
5443 if (cmd->type & XT_INTARG && last && strlen(last) > 0) {
5444 if (arg.s == NULL) {
5445 show_oops(t, "Invalid command");
5446 goto done;
5447 }
5448 arg.precount = atoi(arg.s);
5449 if (arg.precount <= 0) {
5450 if (arg.s[0] == '0')
5451 show_oops(t, "Zero count");
5452 else
5453 show_oops(t, "Trailing characters");
5454 goto done;
5455 }
5456 }
5457
5458 DNPRINTF(XT_D_CMD, "%s: prefix %d arg %s\n",
5459 __func__, arg.precount, arg.s);
5460
5461 cmd->func(t, &arg);
5462
5463 rv = XT_CB_HANDLED;
5464 done:
5465 if (j > 0)
5466 cmd_prefix = 0;
5467 g_free(sc);
5468 if (arg.s)
5469 g_free(arg.s);
5470
5471 return (rv);
5472 }
5473
5474 int
5475 entry_key_cb(GtkEntry *w, GdkEventKey *e, struct tab *t)
5476 {
5477 if (t == NULL) {
5478 show_oops(NULL, "entry_key_cb invalid parameters");
5479 return (XT_CB_PASSTHROUGH);
5480 }
5481
5482 DNPRINTF(XT_D_CMD, "entry_key_cb: keyval 0x%x mask 0x%x tab %d\n",
5483 e->keyval, e->state, t->tab_id);
5484
5485 hide_oops(t);
5486
5487 if (e->keyval == GDK_Escape) {
5488 /* don't use focus_webview(t) because we want to type :cmds */
5489 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
5490 }
5491
5492 return (handle_keypress(t, e, 1));
5493 }
5494
5495 struct command_entry *
5496 history_prev(struct command_list *l, struct command_entry *at)
5497 {
5498 if (at == NULL)
5499 at = TAILQ_LAST(l, command_list);
5500 else {
5501 at = TAILQ_PREV(at, command_list, entry);
5502 if (at == NULL)
5503 at = TAILQ_LAST(l, command_list);
5504 }
5505
5506 return (at);
5507 }
5508
5509 struct command_entry *
5510 history_next(struct command_list *l, struct command_entry *at)
5511 {
5512 if (at == NULL)
5513 at = TAILQ_FIRST(l);
5514 else {
5515 at = TAILQ_NEXT(at, entry);
5516 if (at == NULL)
5517 at = TAILQ_FIRST(l);
5518 }
5519
5520 return (at);
5521 }
5522
5523 int
5524 cmd_keypress_cb(GtkEntry *w, GdkEventKey *e, struct tab *t)
5525 {
5526 int rv = XT_CB_HANDLED;
5527 const gchar *c = gtk_entry_get_text(w);
5528 char *s;
5529
5530 if (t == NULL) {
5531 show_oops(NULL, "cmd_keypress_cb parameters");
5532 return (XT_CB_PASSTHROUGH);
5533 }
5534
5535 DNPRINTF(XT_D_CMD, "cmd_keypress_cb: keyval 0x%x mask 0x%x tab %d\n",
5536 e->keyval, e->state, t->tab_id);
5537
5538 /* sanity */
5539 if (c == NULL)
5540 e->keyval = GDK_Escape;
5541 else if (!(c[0] == ':' || c[0] == '/' || c[0] == '?' ||
5542 c[0] == '.' || c[0] == ','))
5543 e->keyval = GDK_Escape;
5544
5545 if (e->keyval != GDK_Tab && e->keyval != GDK_Shift_L &&
5546 e->keyval != GDK_ISO_Left_Tab)
5547 cmd_status.index = -1;
5548
5549 switch (e->keyval) {
5550 case GDK_Tab:
5551 if (c[0] == ':')
5552 cmd_complete(t, (char *)&c[1], 1);
5553 else if (c[0] == '.' || c[0] == ',')
5554 run_script(t, "hints.focusNextHint();");
5555 goto done;
5556 case GDK_ISO_Left_Tab:
5557 if (c[0] == ':')
5558 cmd_complete(t, (char *)&c[1], -1);
5559 else if (c[0] == '.' || c[0] == ',')
5560 run_script(t, "hints.focusPreviousHint();");
5561 goto done;
5562 case GDK_Down:
5563 if (c[0] == '?') {
5564 if ((search_at = history_next(&shl, search_at))) {
5565 search_at->line[0] = c[0];
5566 gtk_entry_set_text(w, search_at->line);
5567 gtk_editable_set_position(GTK_EDITABLE(w), -1);
5568 }
5569 } else if (c[0] == '/') {
5570 if ((search_at = history_prev(&chl, search_at))) {
5571 search_at->line[0] = c[0];
5572 gtk_entry_set_text(w, search_at->line);
5573 gtk_editable_set_position(GTK_EDITABLE(w), -1);
5574 }
5575 } if (c[0] == ':') {
5576 if ((history_at = history_prev(&chl, history_at))) {
5577 history_at->line[0] = c[0];
5578 gtk_entry_set_text(w, history_at->line);
5579 gtk_editable_set_position(GTK_EDITABLE(w), -1);
5580 }
5581 }
5582 goto done;
5583 case GDK_Up:
5584 if (c[0] == '/') {
5585 if ((search_at = history_next(&shl, search_at))) {
5586 search_at->line[0] = c[0];
5587 gtk_entry_set_text(w, search_at->line);
5588 gtk_editable_set_position(GTK_EDITABLE(w), -1);
5589 }
5590 } else if (c[0] == '?') {
5591 if ((search_at = history_prev(&chl, search_at))) {
5592 search_at->line[0] = c[0];
5593 gtk_entry_set_text(w, search_at->line);
5594 gtk_editable_set_position(GTK_EDITABLE(w), -1);
5595 }
5596 } if (c[0] == ':') {
5597 if ((history_at = history_next(&chl, history_at))) {
5598 history_at->line[0] = c[0];
5599 gtk_entry_set_text(w, history_at->line);
5600 gtk_editable_set_position(GTK_EDITABLE(w), -1);
5601 }
5602 }
5603 goto done;
5604 case GDK_BackSpace:
5605 if (!(!strcmp(c, ":") || !strcmp(c, "/") || !strcmp(c, "?") ||
5606 !strcmp(c, ".") || !strcmp(c, ","))) {
5607 /* see if we are doing hinting and reset it */
5608 if (c[0] == '.' || c[0] == ',') {
5609 /* recreate hints */
5610 s = g_strdup_printf("hints.createHints('', "
5611 "'%c');", c[0] == '.' ? 'f' : 'F');
5612 run_script(t, s);
5613 g_free(s);
5614 }
5615 break;
5616 }
5617
5618 /* FALLTHROUGH */
5619 case GDK_Escape:
5620 hide_cmd(t);
5621 focus_webview(t);
5622
5623 /* cancel search */
5624 if (c != NULL && (c[0] == '/' || c[0] == '?'))
5625 webkit_web_view_unmark_text_matches(t->wv);
5626
5627 /* no need to cancel hints */
5628 goto done;
5629 }
5630
5631 rv = XT_CB_PASSTHROUGH;
5632 done:
5633 return (rv);
5634 }
5635
5636 void
5637 wv_popup_cb(GtkEntry *entry, GtkMenu *menu, struct tab *t)
5638 {
5639 DNPRINTF(XT_D_CMD, "wv_popup_cb: tab %d\n", t->tab_id);
5640 }
5641
5642 void
5643 cmd_popup_cb(GtkEntry *entry, GtkMenu *menu, struct tab *t)
5644 {
5645 /* popup menu enabled */
5646 t->popup = 1;
5647 }
5648
5649 int
5650 cmd_focusout_cb(GtkWidget *w, GdkEventFocus *e, struct tab *t)
5651 {
5652 if (t == NULL) {
5653 show_oops(NULL, "cmd_focusout_cb invalid parameters");
5654 return (XT_CB_PASSTHROUGH);
5655 }
5656
5657 DNPRINTF(XT_D_CMD, "cmd_focusout_cb: tab %d popup %d\n",
5658 t->tab_id, t->popup);
5659
5660 /* if popup is enabled don't lose focus */
5661 if (t->popup) {
5662 t->popup = 0;
5663 return (XT_CB_PASSTHROUGH);
5664 }
5665
5666 hide_cmd(t);
5667 hide_oops(t);
5668 disable_hints(t);
5669
5670 if (show_url == 0 || t->focus_wv)
5671 focus_webview(t);
5672 else
5673 gtk_widget_grab_focus(GTK_WIDGET(t->uri_entry));
5674
5675 return (XT_CB_PASSTHROUGH);
5676 }
5677
5678 void
5679 cmd_activate_cb(GtkEntry *entry, struct tab *t)
5680 {
5681 char *s;
5682 const gchar *c = gtk_entry_get_text(entry);
5683
5684 if (t == NULL) {
5685 show_oops(NULL, "cmd_activate_cb invalid parameters");
5686 return;
5687 }
5688
5689 DNPRINTF(XT_D_CMD, "cmd_activate_cb: tab %d %s\n", t->tab_id, c);
5690
5691 /* sanity */
5692 if (c == NULL)
5693 goto done;
5694 else if (!(c[0] == ':' || c[0] == '/' || c[0] == '?' ||
5695 c[0] == '.' || c[0] == ','))
5696 goto done;
5697 if (strlen(c) < 1)
5698 goto done;
5699 s = (char *)&c[1];
5700
5701 if (c[0] == '/' || c[0] == '?') {
5702 /* see if there is a timer pending */
5703 if (t->search_id) {
5704 g_source_remove(t->search_id);
5705 t->search_id = 0;
5706 search_cb(t);
5707 }
5708
5709 if (t->search_text) {
5710 g_free(t->search_text);
5711 t->search_text = NULL;
5712 }
5713
5714 t->search_text = g_strdup(s);
5715 if (global_search)
5716 g_free(global_search);
5717 global_search = g_strdup(s);
5718 t->search_forward = c[0] == '/';
5719
5720 history_add(&shl, search_file, s, &search_history_count);
5721 } else if (c[0] == '.' || c[0] == ',') {
5722 run_script(t, "hints.fire();");
5723 /* XXX history for link following? */
5724 } else if (c[0] == ':') {
5725 history_add(&chl, command_file, s, &cmd_history_count);
5726 /* can't call hide_cmd after cmd_execute */
5727 hide_cmd(t);
5728 cmd_execute(t, s);
5729 return;
5730 }
5731
5732 done:
5733 hide_cmd(t);
5734 }
5735
5736 void
5737 backward_cb(GtkWidget *w, struct tab *t)
5738 {
5739 struct karg a;
5740
5741 if (t == NULL) {
5742 show_oops(NULL, "backward_cb invalid parameters");
5743 return;
5744 }
5745
5746 DNPRINTF(XT_D_NAV, "backward_cb: tab %d\n", t->tab_id);
5747
5748 a.i = XT_NAV_BACK;
5749 navaction(t, &a);
5750 }
5751
5752 void
5753 forward_cb(GtkWidget *w, struct tab *t)
5754 {
5755 struct karg a;
5756
5757 if (t == NULL) {
5758 show_oops(NULL, "forward_cb invalid parameters");
5759 return;
5760 }
5761
5762 DNPRINTF(XT_D_NAV, "forward_cb: tab %d\n", t->tab_id);
5763
5764 a.i = XT_NAV_FORWARD;
5765 navaction(t, &a);
5766 }
5767
5768 void
5769 home_cb(GtkWidget *w, struct tab *t)
5770 {
5771 if (t == NULL) {
5772 show_oops(NULL, "home_cb invalid parameters");
5773 return;
5774 }
5775
5776 DNPRINTF(XT_D_NAV, "home_cb: tab %d\n", t->tab_id);
5777
5778 load_uri(t, home);
5779 }
5780
5781 void
5782 stop_cb(GtkWidget *w, struct tab *t)
5783 {
5784 WebKitWebFrame *frame;
5785
5786 if (t == NULL) {
5787 show_oops(NULL, "stop_cb invalid parameters");
5788 return;
5789 }
5790
5791 DNPRINTF(XT_D_NAV, "stop_cb: tab %d\n", t->tab_id);
5792
5793 frame = webkit_web_view_get_main_frame(t->wv);
5794 if (frame == NULL) {
5795 show_oops(t, "stop_cb: no frame");
5796 return;
5797 }
5798
5799 webkit_web_frame_stop_loading(frame);
5800 abort_favicon_download(t);
5801 }
5802
5803 void
5804 setup_webkit(struct tab *t)
5805 {
5806 if (is_g_object_setting(G_OBJECT(t->settings), "enable-dns-prefetching"))
5807 g_object_set(G_OBJECT(t->settings), "enable-dns-prefetching",
5808 FALSE, (char *)NULL);
5809 else
5810 warnx("webkit does not have \"enable-dns-prefetching\" property");
5811 g_object_set(G_OBJECT(t->settings),
5812 "user-agent", t->user_agent, (char *)NULL);
5813 g_object_set(G_OBJECT(t->settings),
5814 "enable-scripts", enable_scripts, (char *)NULL);
5815 g_object_set(G_OBJECT(t->settings),
5816 "enable-plugins", enable_plugins, (char *)NULL);
5817 g_object_set(G_OBJECT(t->settings),
5818 "javascript-can-open-windows-automatically", enable_scripts,
5819 (char *)NULL);
5820 g_object_set(G_OBJECT(t->settings),
5821 "enable-html5-database", FALSE, (char *)NULL);
5822 g_object_set(G_OBJECT(t->settings),
5823 "enable-html5-local-storage", enable_localstorage, (char *)NULL);
5824 g_object_set(G_OBJECT(t->settings),
5825 "enable_spell_checking", enable_spell_checking, (char *)NULL);
5826 g_object_set(G_OBJECT(t->settings),
5827 "spell_checking_languages", spell_check_languages, (char *)NULL);
5828 g_object_set(G_OBJECT(t->settings),
5829 "enable-developer-extras", TRUE, (char *)NULL);
5830 g_object_set(G_OBJECT(t->wv),
5831 "full-content-zoom", TRUE, (char *)NULL);
5832
5833 webkit_web_view_set_settings(t->wv, t->settings);
5834 }
5835
5836 gboolean
5837 update_statusbar_position(GtkAdjustment* adjustment, gpointer data)
5838 {
5839 struct tab *ti, *t = NULL;
5840 gdouble view_size, value, max;
5841 gchar *position;
5842
5843 TAILQ_FOREACH(ti, &tabs, entry)
5844 if (ti->tab_id == gtk_notebook_get_current_page(notebook)) {
5845 t = ti;
5846 break;
5847 }
5848
5849 if (t == NULL)
5850 return FALSE;
5851
5852 if (adjustment == NULL)
5853 adjustment = gtk_scrolled_window_get_vadjustment(
5854 GTK_SCROLLED_WINDOW(t->browser_win));
5855
5856 view_size = gtk_adjustment_get_page_size(adjustment);
5857 value = gtk_adjustment_get_value(adjustment);
5858 max = gtk_adjustment_get_upper(adjustment) - view_size;
5859
5860 if (max == 0)
5861 position = g_strdup("All");
5862 else if (value == max)
5863 position = g_strdup("Bot");
5864 else if (value == 0)
5865 position = g_strdup("Top");
5866 else
5867 position = g_strdup_printf("%d%%", (int) ((value / max) * 100));
5868
5869 gtk_entry_set_text(GTK_ENTRY(t->sbe.position), position);
5870 g_free(position);
5871
5872 return (TRUE);
5873 }
5874
5875 GtkWidget *
5876 create_window(const gchar *name)
5877 {
5878 GtkWidget *w;
5879
5880 w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
5881 gtk_window_set_default_size(GTK_WINDOW(w), window_width, window_height);
5882 gtk_widget_set_name(w, name);
5883 gtk_window_set_wmclass(GTK_WINDOW(w), name, "XXXTerm");
5884
5885 return (w);
5886 }
5887
5888 GtkWidget *
5889 create_browser(struct tab *t)
5890 {
5891 GtkWidget *w;
5892 gchar *strval;
5893 GtkAdjustment *adjustment;
5894
5895 if (t == NULL) {
5896 show_oops(NULL, "create_browser invalid parameters");
5897 return (NULL);
5898 }
5899
5900 t->sb_h = GTK_SCROLLBAR(gtk_hscrollbar_new(NULL));
5901 t->sb_v = GTK_SCROLLBAR(gtk_vscrollbar_new(NULL));
5902 t->adjust_h = gtk_range_get_adjustment(GTK_RANGE(t->sb_h));
5903 t->adjust_v = gtk_range_get_adjustment(GTK_RANGE(t->sb_v));
5904
5905 w = gtk_scrolled_window_new(t->adjust_h, t->adjust_v);
5906 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w),
5907 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
5908
5909 t->wv = WEBKIT_WEB_VIEW(webkit_web_view_new());
5910 gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(t->wv));
5911
5912 /* set defaults */
5913 t->settings = webkit_web_settings_new();
5914
5915 g_object_set(t->settings, "default-encoding", encoding, (char *)NULL);
5916
5917 if (user_agent == NULL) {
5918 g_object_get(G_OBJECT(t->settings), "user-agent", &strval,
5919 (char *)NULL);
5920 t->user_agent = g_strdup_printf("%s %s+", strval, version);
5921 g_free(strval);
5922 } else
5923 t->user_agent = g_strdup(user_agent);
5924
5925 t->stylesheet = g_strdup_printf("file://%s/style.css", resource_dir);
5926
5927 adjustment =
5928 gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(w));
5929 g_signal_connect(G_OBJECT(adjustment), "value-changed",
5930 G_CALLBACK(update_statusbar_position), NULL);
5931
5932 setup_webkit(t);
5933 setup_inspector(t);
5934
5935 return (w);
5936 }
5937
5938 GtkWidget *
5939 create_kiosk_toolbar(struct tab *t)
5940 {
5941 GtkWidget *toolbar = NULL, *b;
5942
5943 b = gtk_hbox_new(FALSE, 0);
5944 toolbar = b;
5945 gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);
5946
5947 /* backward button */
5948 t->backward = create_button("Back", GTK_STOCK_GO_BACK, 0);
5949 gtk_widget_set_sensitive(t->backward, FALSE);
5950 g_signal_connect(G_OBJECT(t->backward), "clicked",
5951 G_CALLBACK(backward_cb), t);
5952 gtk_box_pack_start(GTK_BOX(b), t->backward, TRUE, TRUE, 0);
5953
5954 /* forward button */
5955 t->forward = create_button("Forward", GTK_STOCK_GO_FORWARD, 0);
5956 gtk_widget_set_sensitive(t->forward, FALSE);
5957 g_signal_connect(G_OBJECT(t->forward), "clicked",
5958 G_CALLBACK(forward_cb), t);
5959 gtk_box_pack_start(GTK_BOX(b), t->forward, TRUE, TRUE, 0);
5960
5961 /* home button */
5962 t->gohome = create_button("Home", GTK_STOCK_HOME, 0);
5963 gtk_widget_set_sensitive(t->gohome, true);
5964 g_signal_connect(G_OBJECT(t->gohome), "clicked",
5965 G_CALLBACK(home_cb), t);
5966 gtk_box_pack_start(GTK_BOX(b), t->gohome, TRUE, TRUE, 0);
5967
5968 /* create widgets but don't use them */
5969 t->uri_entry = gtk_entry_new();
5970 t->stop = create_button("Stop", GTK_STOCK_STOP, 0);
5971 t->js_toggle = create_button("JS-Toggle", enable_scripts ?
5972 GTK_STOCK_MEDIA_PLAY : GTK_STOCK_MEDIA_PAUSE, 0);
5973
5974 return (toolbar);
5975 }
5976
5977 GtkWidget *
5978 create_toolbar(struct tab *t)
5979 {
5980 GtkWidget *toolbar = NULL, *b, *eb1;
5981
5982 b = gtk_hbox_new(FALSE, 0);
5983 toolbar = b;
5984 gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);
5985
5986 /* backward button */
5987 t->backward = create_button("Back", GTK_STOCK_GO_BACK, 0);
5988 gtk_widget_set_sensitive(t->backward, FALSE);
5989 g_signal_connect(G_OBJECT(t->backward), "clicked",
5990 G_CALLBACK(backward_cb), t);
5991 gtk_box_pack_start(GTK_BOX(b), t->backward, FALSE, FALSE, 0);
5992
5993 /* forward button */
5994 t->forward = create_button("Forward",GTK_STOCK_GO_FORWARD, 0);
5995 gtk_widget_set_sensitive(t->forward, FALSE);
5996 g_signal_connect(G_OBJECT(t->forward), "clicked",
5997 G_CALLBACK(forward_cb), t);
5998 gtk_box_pack_start(GTK_BOX(b), t->forward, FALSE,
5999 FALSE, 0);
6000
6001 /* stop button */
6002 t->stop = create_button("Stop", GTK_STOCK_STOP, 0);
6003 gtk_widget_set_sensitive(t->stop, FALSE);
6004 g_signal_connect(G_OBJECT(t->stop), "clicked",
6005 G_CALLBACK(stop_cb), t);
6006 gtk_box_pack_start(GTK_BOX(b), t->stop, FALSE,
6007 FALSE, 0);
6008
6009 /* JS button */
6010 t->js_toggle = create_button("JS-Toggle", enable_scripts ?
6011 GTK_STOCK_MEDIA_PLAY : GTK_STOCK_MEDIA_PAUSE, 0);
6012 gtk_widget_set_sensitive(t->js_toggle, TRUE);
6013 g_signal_connect(G_OBJECT(t->js_toggle), "clicked",
6014 G_CALLBACK(js_toggle_cb), t);
6015 gtk_box_pack_start(GTK_BOX(b), t->js_toggle, FALSE, FALSE, 0);
6016
6017 t->uri_entry = gtk_entry_new();
6018 g_signal_connect(G_OBJECT(t->uri_entry), "activate",
6019 G_CALLBACK(activate_uri_entry_cb), t);
6020 g_signal_connect(G_OBJECT(t->uri_entry), "key-press-event",
6021 G_CALLBACK(entry_key_cb), t);
6022 completion_add(t);
6023 eb1 = gtk_hbox_new(FALSE, 0);
6024 gtk_container_set_border_width(GTK_CONTAINER(eb1), 1);
6025 gtk_box_pack_start(GTK_BOX(eb1), t->uri_entry, TRUE, TRUE, 0);
6026 gtk_box_pack_start(GTK_BOX(b), eb1, TRUE, TRUE, 0);
6027
6028 /* search entry */
6029 if (search_string) {
6030 GtkWidget *eb2;
6031 t->search_entry = gtk_entry_new();
6032 gtk_entry_set_width_chars(GTK_ENTRY(t->search_entry), 30);
6033 g_signal_connect(G_OBJECT(t->search_entry), "activate",
6034 G_CALLBACK(activate_search_entry_cb), t);
6035 g_signal_connect(G_OBJECT(t->search_entry), "key-press-event",
6036 G_CALLBACK(entry_key_cb), t);
6037 gtk_widget_set_size_request(t->search_entry, -1, -1);
6038 eb2 = gtk_hbox_new(FALSE, 0);
6039 gtk_container_set_border_width(GTK_CONTAINER(eb2), 1);
6040 gtk_box_pack_start(GTK_BOX(eb2), t->search_entry, TRUE, TRUE,
6041 0);
6042 gtk_box_pack_start(GTK_BOX(b), eb2, FALSE, FALSE, 0);
6043 }
6044
6045 return (toolbar);
6046 }
6047
6048 GtkWidget *
6049 create_buffers(struct tab *t)
6050 {
6051 GtkCellRenderer *renderer;
6052 GtkWidget *view;
6053
6054 view = gtk_tree_view_new();
6055
6056 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
6057
6058 renderer = gtk_cell_renderer_text_new();
6059 gtk_tree_view_insert_column_with_attributes
6060 (GTK_TREE_VIEW(view), -1, "Id", renderer, "text", COL_ID, (char *)NULL);
6061
6062 renderer = gtk_cell_renderer_text_new();
6063 gtk_tree_view_insert_column_with_attributes
6064 (GTK_TREE_VIEW(view), -1, "Title", renderer, "text", COL_TITLE,
6065 (char *)NULL);
6066
6067 gtk_tree_view_set_model
6068 (GTK_TREE_VIEW(view), GTK_TREE_MODEL(buffers_store));
6069
6070 return (view);
6071 }
6072
6073 void
6074 row_activated_cb(GtkTreeView *view, GtkTreePath *path,
6075 GtkTreeViewColumn *col, struct tab *t)
6076 {
6077 GtkTreeIter iter;
6078 guint id;
6079
6080 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
6081
6082 if (gtk_tree_model_get_iter(GTK_TREE_MODEL(buffers_store), &iter,
6083 path)) {
6084 gtk_tree_model_get
6085 (GTK_TREE_MODEL(buffers_store), &iter, COL_ID, &id, -1);
6086 set_current_tab(id - 1);
6087 }
6088
6089 hide_buffers(t);
6090 }
6091
6092 /* after tab reordering/creation/removal */
6093 void
6094 recalc_tabs(void)
6095 {
6096 struct tab *t;
6097 int maxid = 0;
6098
6099 TAILQ_FOREACH(t, &tabs, entry) {
6100 t->tab_id = gtk_notebook_page_num(notebook, t->vbox);
6101 if (t->tab_id > maxid)
6102 maxid = t->tab_id;
6103
6104 gtk_widget_show(t->tab_elems.sep);
6105 }
6106
6107 TAILQ_FOREACH(t, &tabs, entry) {
6108 if (t->tab_id == maxid) {
6109 gtk_widget_hide(t->tab_elems.sep);
6110 break;
6111 }
6112 }
6113 }
6114
6115 /* after active tab change */
6116 void
6117 recolor_compact_tabs(void)
6118 {
6119 struct tab *t;
6120 int curid = 0;
6121 GdkColor color;
6122
6123 gdk_color_parse(XT_COLOR_CT_INACTIVE, &color);
6124 TAILQ_FOREACH(t, &tabs, entry)
6125 gtk_widget_modify_fg(t->tab_elems.label, GTK_STATE_NORMAL,
6126 &color);
6127
6128 curid = gtk_notebook_get_current_page(notebook);
6129 TAILQ_FOREACH(t, &tabs, entry)
6130 if (t->tab_id == curid) {
6131 gdk_color_parse(XT_COLOR_CT_ACTIVE, &color);
6132 gtk_widget_modify_fg(t->tab_elems.label,
6133 GTK_STATE_NORMAL, &color);
6134 break;
6135 }
6136 }
6137
6138 void
6139 set_current_tab(int page_num)
6140 {
6141 buffercmd_abort(get_current_tab());
6142 gtk_notebook_set_current_page(notebook, page_num);
6143 recolor_compact_tabs();
6144 }
6145
6146 int
6147 undo_close_tab_save(struct tab *t)
6148 {
6149 int m, n;
6150 const gchar *uri;
6151 struct undo *u1, *u2;
6152 GList *items;
6153 WebKitWebHistoryItem *item;
6154
6155 if ((uri = get_uri(t)) == NULL)
6156 return (1);
6157
6158 u1 = g_malloc0(sizeof(struct undo));
6159 u1->uri = g_strdup(uri);
6160
6161 t->bfl = webkit_web_view_get_back_forward_list(t->wv);
6162
6163 m = webkit_web_back_forward_list_get_forward_length(t->bfl);
6164 n = webkit_web_back_forward_list_get_back_length(t->bfl);
6165 u1->back = n;
6166
6167 /* forward history */
6168 items = webkit_web_back_forward_list_get_forward_list_with_limit(t->bfl, m);
6169
6170 while (items) {
6171 item = items->data;
6172 u1->history = g_list_prepend(u1->history,
6173 webkit_web_history_item_copy(item));
6174 items = g_list_next(items);
6175 }
6176
6177 /* current item */
6178 if (m) {
6179 item = webkit_web_back_forward_list_get_current_item(t->bfl);
6180 u1->history = g_list_prepend(u1->history,
6181 webkit_web_history_item_copy(item));
6182 }
6183
6184 /* back history */
6185 items = webkit_web_back_forward_list_get_back_list_with_limit(t->bfl, n);
6186
6187 while (items) {
6188 item = items->data;
6189 u1->history = g_list_prepend(u1->history,
6190 webkit_web_history_item_copy(item));
6191 items = g_list_next(items);
6192 }
6193
6194 TAILQ_INSERT_HEAD(&undos, u1, entry);
6195
6196 if (undo_count > XT_MAX_UNDO_CLOSE_TAB) {
6197 u2 = TAILQ_LAST(&undos, undo_tailq);
6198 TAILQ_REMOVE(&undos, u2, entry);
6199 g_free(u2->uri);
6200 g_list_free(u2->history);
6201 g_free(u2);
6202 } else
6203 undo_count++;
6204
6205 return (0);
6206 }
6207
6208 void
6209 delete_tab(struct tab *t)
6210 {
6211 struct karg a;
6212
6213 DNPRINTF(XT_D_TAB, "delete_tab: %p\n", t);
6214
6215 if (t == NULL)
6216 return;
6217
6218 /*
6219 * no need to join thread here because it won't access t on completion
6220 */
6221
6222 TAILQ_REMOVE(&tabs, t, entry);
6223 buffercmd_abort(t);
6224
6225 /* Halt all webkit activity. */
6226 abort_favicon_download(t);
6227 webkit_web_view_stop_loading(t->wv);
6228
6229 /* Save the tab, so we can undo the close. */
6230 undo_close_tab_save(t);
6231
6232 /* just in case */
6233 if (t->search_id)
6234 g_source_remove(t->search_id);
6235
6236 /* inspector */
6237 bzero(&a, sizeof a);
6238 a.i = XT_INS_CLOSE;
6239 inspector_cmd(t, &a);
6240
6241 if (browser_mode == XT_BM_KIOSK) {
6242 gtk_widget_destroy(t->uri_entry);
6243 gtk_widget_destroy(t->stop);
6244 gtk_widget_destroy(t->js_toggle);
6245 }
6246
6247 gtk_widget_destroy(t->tab_elems.eventbox);
6248 gtk_widget_destroy(t->vbox);
6249
6250 g_free(t->user_agent);
6251 g_free(t->stylesheet);
6252 g_free(t->tmp_uri);
6253 g_free(t);
6254 t = NULL;
6255
6256 if (TAILQ_EMPTY(&tabs)) {
6257 if (browser_mode == XT_BM_KIOSK)
6258 create_new_tab(home, NULL, 1, -1);
6259 else
6260 create_new_tab(NULL, NULL, 1, -1);
6261 }
6262
6263 /* recreate session */
6264 if (session_autosave) {
6265 bzero(&a, sizeof a);
6266 a.s = NULL;
6267 save_tabs(NULL, &a);
6268 }
6269
6270 recalc_tabs();
6271 recolor_compact_tabs();
6272 }
6273
6274 void
6275 update_statusbar_zoom(struct tab *t)
6276 {
6277 gfloat zoom;
6278 char s[16] = { '\0' };
6279
6280 g_object_get(G_OBJECT(t->wv), "zoom-level", &zoom, (char *)NULL);
6281 if ((zoom <= 0.99 || zoom >= 1.01))
6282 snprintf(s, sizeof s, "%d%%", (int)(zoom * 100));
6283 gtk_entry_set_text(GTK_ENTRY(t->sbe.zoom), s);
6284 }
6285
6286 void
6287 setzoom_webkit(struct tab *t, int adjust)
6288 {
6289 #define XT_ZOOMPERCENT 0.04
6290
6291 gfloat zoom;
6292
6293 if (t == NULL) {
6294 show_oops(NULL, "setzoom_webkit invalid parameters");
6295 return;
6296 }
6297
6298 g_object_get(G_OBJECT(t->wv), "zoom-level", &zoom, (char *)NULL);
6299 if (adjust == XT_ZOOM_IN)
6300 zoom += XT_ZOOMPERCENT;
6301 else if (adjust == XT_ZOOM_OUT)
6302 zoom -= XT_ZOOMPERCENT;
6303 else if (adjust > 0)
6304 zoom = default_zoom_level + adjust / 100.0 - 1.0;
6305 else {
6306 show_oops(t, "setzoom_webkit invalid zoom value");
6307 return;
6308 }
6309
6310 if (zoom < XT_ZOOMPERCENT)
6311 zoom = XT_ZOOMPERCENT;
6312 g_object_set(G_OBJECT(t->wv), "zoom-level", zoom, (char *)NULL);
6313 update_statusbar_zoom(t);
6314 }
6315
6316 gboolean
6317 tab_clicked_cb(GtkWidget *widget, GdkEventButton *event, gpointer data)
6318 {
6319 struct tab *t = (struct tab *) data;
6320
6321 DNPRINTF(XT_D_TAB, "tab_clicked_cb: tab: %d\n", t->tab_id);
6322
6323 switch (event->button) {
6324 case 1:
6325 set_current_tab(t->tab_id);
6326 break;
6327 case 2:
6328 delete_tab(t);
6329 break;
6330 }
6331
6332 return TRUE;
6333 }
6334
6335 void
6336 append_tab(struct tab *t)
6337 {
6338 if (t == NULL)
6339 return;
6340
6341 TAILQ_INSERT_TAIL(&tabs, t, entry);
6342 t->tab_id = gtk_notebook_append_page(notebook, t->vbox, t->tab_content);
6343 }
6344
6345 GtkWidget *
6346 create_sbe(int width)
6347 {
6348 GtkWidget *sbe;
6349
6350 sbe = gtk_entry_new();
6351 gtk_entry_set_inner_border(GTK_ENTRY(sbe), NULL);
6352 gtk_entry_set_has_frame(GTK_ENTRY(sbe), FALSE);
6353 gtk_widget_set_can_focus(GTK_WIDGET(sbe), FALSE);
6354 gtk_widget_modify_font(GTK_WIDGET(sbe), statusbar_font);
6355 gtk_entry_set_alignment(GTK_ENTRY(sbe), 1.0);
6356 gtk_widget_set_size_request(sbe, width, -1);
6357
6358 return sbe;
6359 }
6360
6361 struct tab *
6362 create_new_tab(char *title, struct undo *u, int focus, int position)
6363 {
6364 struct tab *t;
6365 int load = 1, id;
6366 GtkWidget *b, *bb;
6367 WebKitWebHistoryItem *item;
6368 GList *items;
6369 GdkColor color;
6370 char *p;
6371 int sbe_p = 0, sbe_b = 0,
6372 sbe_z = 0;
6373
6374 DNPRINTF(XT_D_TAB, "create_new_tab: title %s focus %d\n", title, focus);
6375
6376 if (tabless && !TAILQ_EMPTY(&tabs)) {
6377 DNPRINTF(XT_D_TAB, "create_new_tab: new tab rejected\n");
6378 return (NULL);
6379 }
6380
6381 t = g_malloc0(sizeof *t);
6382
6383 if (title == NULL) {
6384 title = "(untitled)";
6385 load = 0;
6386 }
6387
6388 t->vbox = gtk_vbox_new(FALSE, 0);
6389
6390 /* label + button for tab */
6391 b = gtk_hbox_new(FALSE, 0);
6392 t->tab_content = b;
6393
6394 #if GTK_CHECK_VERSION(2, 20, 0)
6395 t->spinner = gtk_spinner_new();
6396 #endif
6397 t->label = gtk_label_new(title);
6398 bb = create_button("Close", GTK_STOCK_CLOSE, 1);
6399 gtk_widget_set_size_request(t->label, 100, 0);
6400 gtk_label_set_max_width_chars(GTK_LABEL(t->label), 20);
6401 gtk_label_set_ellipsize(GTK_LABEL(t->label), PANGO_ELLIPSIZE_END);
6402 gtk_widget_set_size_request(b, 130, 0);
6403
6404 gtk_box_pack_start(GTK_BOX(b), bb, FALSE, FALSE, 0);
6405 gtk_box_pack_start(GTK_BOX(b), t->label, FALSE, FALSE, 0);
6406 #if GTK_CHECK_VERSION(2, 20, 0)
6407 gtk_box_pack_start(GTK_BOX(b), t->spinner, FALSE, FALSE, 0);
6408 #endif
6409
6410 /* toolbar */
6411 if (browser_mode == XT_BM_KIOSK) {
6412 t->toolbar = create_kiosk_toolbar(t);
6413 gtk_box_pack_start(GTK_BOX(t->vbox), t->toolbar, FALSE, FALSE,
6414 0);
6415 } else {
6416 t->toolbar = create_toolbar(t);
6417 if (fancy_bar)
6418 gtk_box_pack_start(GTK_BOX(t->vbox), t->toolbar, FALSE,
6419 FALSE, 0);
6420 }
6421
6422 /* marks */
6423 marks_clear(t);
6424
6425 /* browser */
6426 t->browser_win = create_browser(t);
6427 gtk_box_pack_start(GTK_BOX(t->vbox), t->browser_win, TRUE, TRUE, 0);
6428
6429 /* oops message for user feedback */
6430 t->oops = gtk_entry_new();
6431 gtk_entry_set_inner_border(GTK_ENTRY(t->oops), NULL);
6432 gtk_entry_set_has_frame(GTK_ENTRY(t->oops), FALSE);
6433 gtk_widget_set_can_focus(GTK_WIDGET(t->oops), FALSE);
6434 gdk_color_parse(XT_COLOR_RED, &color);
6435 gtk_widget_modify_base(t->oops, GTK_STATE_NORMAL, &color);
6436 gtk_box_pack_end(GTK_BOX(t->vbox), t->oops, FALSE, FALSE, 0);
6437 gtk_widget_modify_font(GTK_WIDGET(t->oops), oops_font);
6438
6439 /* command entry */
6440 t->cmd = gtk_entry_new();
6441 gtk_entry_set_inner_border(GTK_ENTRY(t->cmd), NULL);
6442 gtk_entry_set_has_frame(GTK_ENTRY(t->cmd), FALSE);
6443 gtk_box_pack_end(GTK_BOX(t->vbox), t->cmd, FALSE, FALSE, 0);
6444 gtk_widget_modify_font(GTK_WIDGET(t->cmd), cmd_font);
6445
6446 /* status bar */
6447 t->statusbar_box = gtk_hbox_new(FALSE, 0);
6448
6449 t->sbe.statusbar = gtk_entry_new();
6450 gtk_entry_set_inner_border(GTK_ENTRY(t->sbe.statusbar), NULL);
6451 gtk_entry_set_has_frame(GTK_ENTRY(t->sbe.statusbar), FALSE);
6452 gtk_widget_set_can_focus(GTK_WIDGET(t->sbe.statusbar), FALSE);
6453 gtk_widget_modify_font(GTK_WIDGET(t->sbe.statusbar), statusbar_font);
6454
6455 /* create these widgets only if specified in statusbar_elems */
6456
6457 t->sbe.position = create_sbe(40);
6458 t->sbe.zoom = create_sbe(40);
6459 t->sbe.buffercmd = create_sbe(60);
6460
6461 statusbar_modify_attr(t, XT_COLOR_WHITE, XT_COLOR_BLACK);
6462
6463 gtk_box_pack_start(GTK_BOX(t->statusbar_box), t->sbe.statusbar, TRUE,
6464 TRUE, FALSE);
6465
6466 /* gtk widgets cannot be added to a box twice. sbe_* variables
6467 make sure of this */
6468 for (p = statusbar_elems; *p != '\0'; p++) {
6469 switch (*p) {
6470 case '|':
6471 {
6472 GtkWidget *sep = gtk_vseparator_new();
6473
6474 gdk_color_parse(XT_COLOR_SB_SEPARATOR, &color);
6475 gtk_widget_modify_bg(sep, GTK_STATE_NORMAL, &color);
6476 gtk_box_pack_start(GTK_BOX(t->statusbar_box), sep,
6477 FALSE, FALSE, FALSE);
6478 break;
6479 }
6480 case 'P':
6481 if (sbe_p) {
6482 warnx("flag \"%c\" specified more than "
6483 "once in statusbar_elems\n", *p);
6484 break;
6485 }
6486 sbe_p = 1;
6487 gtk_box_pack_start(GTK_BOX(t->statusbar_box),
6488 t->sbe.position, FALSE, FALSE, FALSE);
6489 break;
6490 case 'B':
6491 if (sbe_b) {
6492 warnx("flag \"%c\" specified more than "
6493 "once in statusbar_elems\n", *p);
6494 break;
6495 }
6496 sbe_b = 1;
6497 gtk_box_pack_start(GTK_BOX(t->statusbar_box),
6498 t->sbe.buffercmd, FALSE, FALSE, FALSE);
6499 break;
6500 case 'Z':
6501 if (sbe_z) {
6502 warnx("flag \"%c\" specified more than "
6503 "once in statusbar_elems\n", *p);
6504 break;
6505 }
6506 sbe_z = 1;
6507 gtk_box_pack_start(GTK_BOX(t->statusbar_box),
6508 t->sbe.zoom, FALSE, FALSE, FALSE);
6509 break;
6510 default:
6511 warnx("illegal flag \"%c\" in statusbar_elems\n", *p);
6512 break;
6513 }
6514 }
6515
6516 gtk_box_pack_end(GTK_BOX(t->vbox), t->statusbar_box, FALSE, FALSE, 0);
6517
6518 /* buffer list */
6519 t->buffers = create_buffers(t);
6520 gtk_box_pack_end(GTK_BOX(t->vbox), t->buffers, FALSE, FALSE, 0);
6521
6522 /* xtp meaning is normal by default */
6523 t->xtp_meaning = XT_XTP_TAB_MEANING_NORMAL;
6524
6525 /* set empty favicon */
6526 xt_icon_from_name(t, "text-html");
6527
6528 /* and show it all */
6529 gtk_widget_show_all(b);
6530 gtk_widget_show_all(t->vbox);
6531
6532 /* compact tab bar */
6533 t->tab_elems.label = gtk_label_new(title);
6534 gtk_label_set_width_chars(GTK_LABEL(t->tab_elems.label), 1.0);
6535 gtk_misc_set_alignment(GTK_MISC(t->tab_elems.label), 0.0, 0.0);
6536 gtk_misc_set_padding(GTK_MISC(t->tab_elems.label), 4.0, 4.0);
6537 gtk_widget_modify_font(GTK_WIDGET(t->tab_elems.label), tabbar_font);
6538
6539 t->tab_elems.eventbox = gtk_event_box_new();
6540 t->tab_elems.box = gtk_hbox_new(FALSE, 0);
6541 t->tab_elems.sep = gtk_vseparator_new();
6542
6543 gdk_color_parse(XT_COLOR_CT_BACKGROUND, &color);
6544 gtk_widget_modify_bg(t->tab_elems.eventbox, GTK_STATE_NORMAL, &color);
6545 gdk_color_parse(XT_COLOR_CT_INACTIVE, &color);
6546 gtk_widget_modify_fg(t->tab_elems.label, GTK_STATE_NORMAL, &color);
6547 gdk_color_parse(XT_COLOR_CT_SEPARATOR, &color);
6548 gtk_widget_modify_bg(t->tab_elems.sep, GTK_STATE_NORMAL, &color);
6549
6550 gtk_box_pack_start(GTK_BOX(t->tab_elems.box), t->tab_elems.label, TRUE,
6551 TRUE, 0);
6552 gtk_box_pack_start(GTK_BOX(t->tab_elems.box), t->tab_elems.sep, FALSE,
6553 FALSE, 0);
6554 gtk_container_add(GTK_CONTAINER(t->tab_elems.eventbox),
6555 t->tab_elems.box);
6556
6557 gtk_box_pack_start(GTK_BOX(tab_bar), t->tab_elems.eventbox, TRUE,
6558 TRUE, 0);
6559 gtk_widget_show_all(t->tab_elems.eventbox);
6560
6561 if (append_next == 0 || gtk_notebook_get_n_pages(notebook) == 0)
6562 append_tab(t);
6563 else {
6564 id = position >= 0 ? position :
6565 gtk_notebook_get_current_page(notebook) + 1;
6566 if (id > gtk_notebook_get_n_pages(notebook))
6567 append_tab(t);
6568 else {
6569 TAILQ_INSERT_TAIL(&tabs, t, entry);
6570 gtk_notebook_insert_page(notebook, t->vbox, b, id);
6571 gtk_box_reorder_child(GTK_BOX(tab_bar),
6572 t->tab_elems.eventbox, id);
6573 recalc_tabs();
6574 }
6575 }
6576
6577 #if GTK_CHECK_VERSION(2, 20, 0)
6578 /* turn spinner off if we are a new tab without uri */
6579 if (!load) {
6580 gtk_spinner_stop(GTK_SPINNER(t->spinner));
6581 gtk_widget_hide(t->spinner);
6582 }
6583 #endif
6584 /* make notebook tabs reorderable */
6585 gtk_notebook_set_tab_reorderable(notebook, t->vbox, TRUE);
6586
6587 /* compact tabs clickable */
6588 g_signal_connect(G_OBJECT(t->tab_elems.eventbox),
6589 "button_press_event", G_CALLBACK(tab_clicked_cb), t);
6590
6591 g_object_connect(G_OBJECT(t->cmd),
6592 "signal::key-press-event", G_CALLBACK(cmd_keypress_cb), t,
6593 "signal::key-release-event", G_CALLBACK(cmd_keyrelease_cb), t,
6594 "signal::focus-out-event", G_CALLBACK(cmd_focusout_cb), t,
6595 "signal::activate", G_CALLBACK(cmd_activate_cb), t,
6596 "signal::populate-popup", G_CALLBACK(cmd_popup_cb), t,
6597 (char *)NULL);
6598
6599 /* reuse wv_button_cb to hide oops */
6600 g_object_connect(G_OBJECT(t->oops),
6601 "signal::button_press_event", G_CALLBACK(wv_button_cb), t,
6602 (char *)NULL);
6603
6604 g_signal_connect(t->buffers,
6605 "row-activated", G_CALLBACK(row_activated_cb), t);
6606 g_object_connect(G_OBJECT(t->buffers),
6607 "signal::key-press-event", G_CALLBACK(wv_keypress_cb), t, (char *)NULL);
6608
6609 g_object_connect(G_OBJECT(t->wv),
6610 "signal::key-press-event", G_CALLBACK(wv_keypress_cb), t,
6611 "signal::hovering-over-link", G_CALLBACK(webview_hover_cb), t,
6612 "signal::download-requested", G_CALLBACK(webview_download_cb), t,
6613 "signal::mime-type-policy-decision-requested", G_CALLBACK(webview_mimetype_cb), t,
6614 "signal::navigation-policy-decision-requested", G_CALLBACK(webview_npd_cb), t,
6615 "signal::new-window-policy-decision-requested", G_CALLBACK(webview_npd_cb), t,
6616 "signal::create-web-view", G_CALLBACK(webview_cwv_cb), t,
6617 "signal::close-web-view", G_CALLBACK(webview_closewv_cb), t,
6618 "signal::event", G_CALLBACK(webview_event_cb), t,
6619 "signal::load-finished", G_CALLBACK(webview_load_finished_cb), t,
6620 "signal::load-progress-changed", G_CALLBACK(webview_progress_changed_cb), t,
6621 "signal::icon-loaded", G_CALLBACK(notify_icon_loaded_cb), t,
6622 "signal::button_press_event", G_CALLBACK(wv_button_cb), t,
6623 "signal::button_release_event", G_CALLBACK(wv_release_button_cb), t,
6624 "signal::populate-popup", G_CALLBACK(wv_popup_cb), t,
6625 (char *)NULL);
6626 g_signal_connect(t->wv,
6627 "notify::load-status", G_CALLBACK(notify_load_status_cb), t);
6628 g_signal_connect(t->wv,
6629 "notify::title", G_CALLBACK(notify_title_cb), t);
6630
6631 /* hijack the unused keys as if we were the browser */
6632 //g_object_connect(G_OBJECT(t->toolbar),
6633 // "signal-after::key-press-event", G_CALLBACK(wv_keypress_after_cb), t,
6634 // (char *)NULL);
6635
6636 g_signal_connect(G_OBJECT(bb), "button_press_event",
6637 G_CALLBACK(tab_close_cb), t);
6638
6639 /* setup history */
6640 t->bfl = webkit_web_view_get_back_forward_list(t->wv);
6641 /* restore the tab's history */
6642 if (u && u->history) {
6643 items = u->history;
6644 while (items) {
6645 item = items->data;
6646 webkit_web_back_forward_list_add_item(t->bfl, item);
6647 items = g_list_next(items);
6648 }
6649
6650 item = g_list_nth_data(u->history, u->back);
6651 if (item)
6652 webkit_web_view_go_to_back_forward_item(t->wv, item);
6653
6654 g_list_free(items);
6655 g_list_free(u->history);
6656 } else
6657 webkit_web_back_forward_list_clear(t->bfl);
6658
6659 /* hide stuff */
6660 hide_cmd(t);
6661 hide_oops(t);
6662 hide_buffers(t);
6663 url_set_visibility();
6664 statusbar_set_visibility();
6665
6666 if (focus) {
6667 set_current_tab(t->tab_id);
6668 DNPRINTF(XT_D_TAB, "create_new_tab: going to tab: %d\n",
6669 t->tab_id);
6670
6671 if (load) {
6672 gtk_entry_set_text(GTK_ENTRY(t->uri_entry), title);
6673 load_uri(t, title);
6674 } else {
6675 if (show_url == 1)
6676 gtk_widget_grab_focus(GTK_WIDGET(t->uri_entry));
6677 else
6678 focus_webview(t);
6679 }
6680 } else if (load)
6681 load_uri(t, title);
6682
6683 recolor_compact_tabs();
6684 setzoom_webkit(t, XT_ZOOM_NORMAL);
6685 return (t);
6686 }
6687
6688 void
6689 notebook_switchpage_cb(GtkNotebook *nb, GtkWidget *nbp, guint pn,
6690 gpointer *udata)
6691 {
6692 struct tab *t;
6693 const gchar *uri;
6694
6695 DNPRINTF(XT_D_TAB, "notebook_switchpage_cb: tab: %d\n", pn);
6696
6697 if (gtk_notebook_get_current_page(notebook) == -1)
6698 recalc_tabs();
6699
6700 TAILQ_FOREACH(t, &tabs, entry) {
6701 if (t->tab_id == pn) {
6702 DNPRINTF(XT_D_TAB, "notebook_switchpage_cb: going to "
6703 "%d\n", pn);
6704
6705 uri = get_title(t, TRUE);
6706 gtk_window_set_title(GTK_WINDOW(main_window), uri);
6707
6708 hide_cmd(t);
6709 hide_oops(t);
6710
6711 if (t->focus_wv) {
6712 /* can't use focus_webview here */
6713 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
6714 }
6715 }
6716 }
6717 }
6718
6719 void
6720 notebook_pagereordered_cb(GtkNotebook *nb, GtkWidget *nbp, guint pn,
6721 gpointer *udata)
6722 {
6723 struct tab *t = NULL, *tt;
6724
6725 recalc_tabs();
6726
6727 TAILQ_FOREACH(tt, &tabs, entry)
6728 if (tt->tab_id == pn) {
6729 t = tt;
6730 break;
6731 }
6732 if (t == NULL)
6733 return;
6734 DNPRINTF(XT_D_TAB, "page_reordered_cb: tab: %d\n", t->tab_id);
6735
6736 gtk_box_reorder_child(GTK_BOX(tab_bar), t->tab_elems.eventbox,
6737 t->tab_id);
6738 }
6739
6740 void
6741 menuitem_response(struct tab *t)
6742 {
6743 gtk_notebook_set_current_page(notebook, t->tab_id);
6744 }
6745
6746 gboolean
6747 arrow_cb(GtkWidget *w, GdkEventButton *event, gpointer user_data)
6748 {
6749 GtkWidget *menu, *menu_items;
6750 GdkEventButton *bevent;
6751 const gchar *uri;
6752 struct tab *ti;
6753
6754 if (event->type == GDK_BUTTON_PRESS) {
6755 bevent = (GdkEventButton *) event;
6756 menu = gtk_menu_new();
6757
6758 TAILQ_FOREACH(ti, &tabs, entry) {
6759 if ((uri = get_uri(ti)) == NULL)
6760 /* XXX make sure there is something to print */
6761 /* XXX add gui pages in here to look purdy */
6762 uri = "(untitled)";
6763 menu_items = gtk_menu_item_new_with_label(uri);
6764 gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
6765 gtk_widget_show(menu_items);
6766
6767 g_signal_connect_swapped((menu_items),
6768 "activate", G_CALLBACK(menuitem_response),
6769 (gpointer)ti);
6770 }
6771
6772 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
6773 bevent->button, bevent->time);
6774
6775 /* unref object so it'll free itself when popped down */
6776 #if !GTK_CHECK_VERSION(3, 0, 0)
6777 /* XXX does not need unref with gtk+3? */
6778 g_object_ref_sink(menu);
6779 g_object_unref(menu);
6780 #endif
6781
6782 return (TRUE /* eat event */);
6783 }
6784
6785 return (FALSE /* propagate */);
6786 }
6787
6788 int
6789 icon_size_map(int iconsz)
6790 {
6791 if (iconsz <= GTK_ICON_SIZE_INVALID ||
6792 iconsz > GTK_ICON_SIZE_DIALOG)
6793 return (GTK_ICON_SIZE_SMALL_TOOLBAR);
6794
6795 return (iconsz);
6796 }
6797
6798 GtkWidget *
6799 create_button(char *name, char *stockid, int size)
6800 {
6801 GtkWidget *button, *image;
6802 gchar *rcstring;
6803 int gtk_icon_size;
6804
6805 rcstring = g_strdup_printf(
6806 "style \"%s-style\"\n"
6807 "{\n"
6808 " GtkWidget::focus-padding = 0\n"
6809 " GtkWidget::focus-line-width = 0\n"
6810 " xthickness = 0\n"
6811 " ythickness = 0\n"
6812 "}\n"
6813 "widget \"*.%s\" style \"%s-style\"", name, name, name);
6814 gtk_rc_parse_string(rcstring);
6815 g_free(rcstring);
6816 button = gtk_button_new();
6817 gtk_button_set_focus_on_click(GTK_BUTTON(button), FALSE);
6818 gtk_icon_size = icon_size_map(size ? size : icon_size);
6819
6820 image = gtk_image_new_from_stock(stockid, gtk_icon_size);
6821 gtk_widget_set_size_request(GTK_WIDGET(image), -1, -1);
6822 gtk_container_set_border_width(GTK_CONTAINER(button), 1);
6823 gtk_container_add(GTK_CONTAINER(button), GTK_WIDGET(image));
6824 gtk_widget_set_name(button, name);
6825 gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
6826
6827 return (button);
6828 }
6829
6830 void
6831 button_set_stockid(GtkWidget *button, char *stockid)
6832 {
6833 GtkWidget *image;
6834
6835 image = gtk_image_new_from_stock(stockid, icon_size_map(icon_size));
6836 gtk_widget_set_size_request(GTK_WIDGET(image), -1, -1);
6837 gtk_button_set_image(GTK_BUTTON(button), image);
6838 }
6839
6840 void
6841 clipb_primary_cb(GtkClipboard *primary, GdkEvent *event, gpointer notused)
6842 {
6843 gchar *p = NULL;
6844 GdkAtom atom = gdk_atom_intern("CUT_BUFFER0", FALSE);
6845 gint len;
6846
6847 if (xterm_workaround == 0)
6848 return;
6849
6850 /*
6851 * xterm doesn't play nice with clipboards because it clears the
6852 * primary when clicked. We rely on primary being set to properly
6853 * handle middle mouse button clicks (paste). So when someone clears
6854 * primary copy whatever is in CUT_BUFFER0 into primary to simualte
6855 * other application behavior (as in DON'T clear primary).
6856 */
6857
6858 p = gtk_clipboard_wait_for_text(primary);
6859 if (p == NULL) {
6860 if (gdk_property_get(gdk_get_default_root_window(),
6861 atom,
6862 gdk_atom_intern("STRING", FALSE),
6863 0,
6864 1024 * 1024 /* picked out of my butt */,
6865 FALSE,
6866 NULL,
6867 NULL,
6868 &len,
6869 (guchar **)&p)) {
6870 /* yes sir, we need to NUL the string */
6871 p[len] = '\0';
6872 gtk_clipboard_set_text(primary, p, -1);
6873 }
6874 }
6875
6876 if (p)
6877 g_free(p);
6878 }
6879
6880 void
6881 create_canvas(void)
6882 {
6883 GtkWidget *vbox;
6884 GList *l = NULL;
6885 GdkPixbuf *pb;
6886 char file[PATH_MAX];
6887 int i;
6888
6889 vbox = gtk_vbox_new(FALSE, 0);
6890 gtk_box_set_spacing(GTK_BOX(vbox), 0);
6891 notebook = GTK_NOTEBOOK(gtk_notebook_new());
6892 #if !GTK_CHECK_VERSION(3, 0, 0)
6893 /* XXX seems to be needed with gtk+2 */
6894 gtk_notebook_set_tab_hborder(notebook, 0);
6895 gtk_notebook_set_tab_vborder(notebook, 0);
6896 #endif
6897 gtk_notebook_set_scrollable(notebook, TRUE);
6898 gtk_notebook_set_show_border(notebook, FALSE);
6899 gtk_widget_set_can_focus(GTK_WIDGET(notebook), FALSE);
6900
6901 abtn = gtk_button_new();
6902 arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE);
6903 gtk_widget_set_size_request(arrow, -1, -1);
6904 gtk_container_add(GTK_CONTAINER(abtn), arrow);
6905 gtk_widget_set_size_request(abtn, -1, 20);
6906
6907 #if GTK_CHECK_VERSION(2, 20, 0)
6908 gtk_notebook_set_action_widget(notebook, abtn, GTK_PACK_END);
6909 #endif
6910 gtk_widget_set_size_request(GTK_WIDGET(notebook), -1, -1);
6911
6912 /* compact tab bar */
6913 tab_bar = gtk_hbox_new(TRUE, 0);
6914
6915 gtk_box_pack_start(GTK_BOX(vbox), tab_bar, FALSE, FALSE, 0);
6916 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(notebook), TRUE, TRUE, 0);
6917 gtk_widget_set_size_request(vbox, -1, -1);
6918
6919 g_object_connect(G_OBJECT(notebook),
6920 "signal::switch-page", G_CALLBACK(notebook_switchpage_cb), NULL,
6921 (char *)NULL);
6922 g_object_connect(G_OBJECT(notebook),
6923 "signal::page-reordered", G_CALLBACK(notebook_pagereordered_cb),
6924 NULL, (char *)NULL);
6925 g_signal_connect(G_OBJECT(abtn), "button_press_event",
6926 G_CALLBACK(arrow_cb), NULL);
6927
6928 main_window = create_window("xxxterm");
6929 gtk_container_add(GTK_CONTAINER(main_window), vbox);
6930 g_signal_connect(G_OBJECT(main_window), "delete_event",
6931 G_CALLBACK(gtk_main_quit), NULL);
6932
6933 /* icons */
6934 for (i = 0; i < LENGTH(icons); i++) {
6935 snprintf(file, sizeof file, "%s/%s", resource_dir, icons[i]);
6936 pb = gdk_pixbuf_new_from_file(file, NULL);
6937 l = g_list_append(l, pb);
6938 }
6939 gtk_window_set_default_icon_list(l);
6940
6941 /* clipboard work around */
6942 if (xterm_workaround)
6943 g_signal_connect(
6944 G_OBJECT(gtk_clipboard_get(GDK_SELECTION_PRIMARY)),
6945 "owner-change", G_CALLBACK(clipb_primary_cb), NULL);
6946
6947 gtk_widget_show_all(abtn);
6948 gtk_widget_show_all(main_window);
6949 notebook_tab_set_visibility();
6950 }
6951
6952 int
6953 send_cmd_to_socket(char *cmd)
6954 {
6955 int s, len, rv = 1;
6956 struct sockaddr_un sa;
6957
6958 if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
6959 warnx("%s: socket", __func__);
6960 return (rv);
6961 }
6962
6963 sa.sun_family = AF_UNIX;
6964 snprintf(sa.sun_path, sizeof(sa.sun_path), "%s/%s",
6965 work_dir, XT_SOCKET_FILE);
6966 len = SUN_LEN(&sa);
6967
6968 if (connect(s, (struct sockaddr *)&sa, len) == -1) {
6969 warnx("%s: connect", __func__);
6970 goto done;
6971 }
6972
6973 if (send(s, cmd, strlen(cmd) + 1, 0) == -1) {
6974 warnx("%s: send", __func__);
6975 goto done;
6976 }
6977
6978 rv = 0;
6979 done:
6980 close(s);
6981 return (rv);
6982 }
6983
6984 gboolean
6985 socket_watcher(GIOChannel *source, GIOCondition condition, gpointer data)
6986 {
6987 int s, n;
6988 char str[XT_MAX_URL_LENGTH];
6989 socklen_t t = sizeof(struct sockaddr_un);
6990 struct sockaddr_un sa;
6991 struct passwd *p;
6992 uid_t uid;
6993 gid_t gid;
6994 struct tab *tt;
6995 gint fd = g_io_channel_unix_get_fd(source);
6996
6997 if ((s = accept(fd, (struct sockaddr *)&sa, &t)) == -1) {
6998 warn("accept");
6999 return (FALSE);
7000 }
7001
7002 if (getpeereid(s, &uid, &gid) == -1) {
7003 warn("getpeereid");
7004 return (FALSE);
7005 }
7006 if (uid != getuid() || gid != getgid()) {
7007 warnx("unauthorized user");
7008 return (FALSE);
7009 }
7010
7011 p = getpwuid(uid);
7012 if (p == NULL) {
7013 warnx("not a valid user");
7014 return (FALSE);
7015 }
7016
7017 n = recv(s, str, sizeof(str), 0);
7018 if (n <= 0)
7019 return (TRUE);
7020
7021 tt = TAILQ_LAST(&tabs, tab_list);
7022 cmd_execute(tt, str);
7023 return (TRUE);
7024 }
7025
7026 int
7027 is_running(void)
7028 {
7029 int s, len, rv = 1;
7030 struct sockaddr_un sa;
7031
7032 if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
7033 warn("is_running: socket");
7034 return (-1);
7035 }
7036
7037 sa.sun_family = AF_UNIX;
7038 snprintf(sa.sun_path, sizeof(sa.sun_path), "%s/%s",
7039 work_dir, XT_SOCKET_FILE);
7040 len = SUN_LEN(&sa);
7041
7042 /* connect to see if there is a listener */
7043 if (connect(s, (struct sockaddr *)&sa, len) == -1)
7044 rv = 0; /* not running */
7045 else
7046 rv = 1; /* already running */
7047
7048 close(s);
7049
7050 return (rv);
7051 }
7052
7053 int
7054 build_socket(void)
7055 {
7056 int s, len;
7057 struct sockaddr_un sa;
7058
7059 if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
7060 warn("build_socket: socket");
7061 return (-1);
7062 }
7063
7064 sa.sun_family = AF_UNIX;
7065 snprintf(sa.sun_path, sizeof(sa.sun_path), "%s/%s",
7066 work_dir, XT_SOCKET_FILE);
7067 len = SUN_LEN(&sa);
7068
7069 /* connect to see if there is a listener */
7070 if (connect(s, (struct sockaddr *)&sa, len) == -1) {
7071 /* no listener so we will */
7072 unlink(sa.sun_path);
7073
7074 if (bind(s, (struct sockaddr *)&sa, len) == -1) {
7075 warn("build_socket: bind");
7076 goto done;
7077 }
7078
7079 if (listen(s, 1) == -1) {
7080 warn("build_socket: listen");
7081 goto done;
7082 }
7083
7084 return (s);
7085 }
7086
7087 done:
7088 close(s);
7089 return (-1);
7090 }
7091
7092 gboolean
7093 completion_select_cb(GtkEntryCompletion *widget, GtkTreeModel *model,
7094 GtkTreeIter *iter, struct tab *t)
7095 {
7096 gchar *value;
7097
7098 gtk_tree_model_get(model, iter, 0, &value, -1);
7099 load_uri(t, value);
7100 g_free(value);
7101
7102 return (FALSE);
7103 }
7104
7105 gboolean
7106 completion_hover_cb(GtkEntryCompletion *widget, GtkTreeModel *model,
7107 GtkTreeIter *iter, struct tab *t)
7108 {
7109 gchar *value;
7110
7111 gtk_tree_model_get(model, iter, 0, &value, -1);
7112 gtk_entry_set_text(GTK_ENTRY(t->uri_entry), value);
7113 gtk_editable_set_position(GTK_EDITABLE(t->uri_entry), -1);
7114 g_free(value);
7115
7116 return (TRUE);
7117 }
7118
7119 void
7120 completion_add_uri(const gchar *uri)
7121 {
7122 GtkTreeIter iter;
7123
7124 /* add uri to list_store */
7125 gtk_list_store_append(completion_model, &iter);
7126 gtk_list_store_set(completion_model, &iter, 0, uri, -1);
7127 }
7128
7129 gboolean
7130 completion_match(GtkEntryCompletion *completion, const gchar *key,
7131 GtkTreeIter *iter, gpointer user_data)
7132 {
7133 gchar *value;
7134 gboolean match = FALSE;
7135
7136 gtk_tree_model_get(GTK_TREE_MODEL(completion_model), iter, 0, &value,
7137 -1);
7138
7139 if (value == NULL)
7140 return FALSE;
7141
7142 match = match_uri(value, key);
7143
7144 g_free(value);
7145 return (match);
7146 }
7147
7148 void
7149 completion_add(struct tab *t)
7150 {
7151 /* enable completion for tab */
7152 t->completion = gtk_entry_completion_new();
7153 gtk_entry_completion_set_text_column(t->completion, 0);
7154 gtk_entry_set_completion(GTK_ENTRY(t->uri_entry), t->completion);
7155 gtk_entry_completion_set_model(t->completion,
7156 GTK_TREE_MODEL(completion_model));
7157 gtk_entry_completion_set_match_func(t->completion, completion_match,
7158 NULL, NULL);
7159 gtk_entry_completion_set_minimum_key_length(t->completion, 1);
7160 gtk_entry_completion_set_inline_selection(t->completion, TRUE);
7161 g_signal_connect(G_OBJECT (t->completion), "match-selected",
7162 G_CALLBACK(completion_select_cb), t);
7163 g_signal_connect(G_OBJECT (t->completion), "cursor-on-match",
7164 G_CALLBACK(completion_hover_cb), t);
7165 }
7166
7167 void
7168 xxx_dir(char *dir)
7169 {
7170 struct stat sb;
7171
7172 if (stat(dir, &sb)) {
7173 if (mkdir(dir, S_IRWXU) == -1)
7174 err(1, "mkdir %s", dir);
7175 if (stat(dir, &sb))
7176 err(1, "stat %s", dir);
7177 }
7178 if (S_ISDIR(sb.st_mode) == 0)
7179 errx(1, "%s not a dir", dir);
7180 if (((sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO))) != S_IRWXU) {
7181 warnx("fixing invalid permissions on %s", dir);
7182 if (chmod(dir, S_IRWXU) == -1)
7183 err(1, "chmod %s", dir);
7184 }
7185 }
7186
7187 void
7188 usage(void)
7189 {
7190 fprintf(stderr,
7191 "%s [-nSTVt][-f file][-s session] url ...\n", __progname);
7192 exit(0);
7193 }
7194
7195 GStaticRecMutex my_gdk_mtx = G_STATIC_REC_MUTEX_INIT;
7196 volatile int mtx_depth;
7197 int mtx_complain;
7198
7199 /*
7200 * The linux flash plugin violates the gdk locking mechanism.
7201 * Work around the issue by using a recursive mutex with some match applied
7202 * to see if we hit a buggy condition.
7203 *
7204 * The following code is painful so just don't read it. It really doesn't
7205 * make much sense but seems to work.
7206 */
7207 void
7208 mtx_lock(void)
7209 {
7210 g_static_rec_mutex_lock(&my_gdk_mtx);
7211 mtx_depth++;
7212
7213 if (mtx_depth <= 0) {
7214 /* should not happen */
7215 show_oops(NULL, "negative mutex locking bug, trying to "
7216 "correct");
7217 fprintf(stderr, "negative mutex locking bug, trying to "
7218 "correct\n");
7219 g_static_rec_mutex_unlock_full(&my_gdk_mtx);
7220 g_static_rec_mutex_lock(&my_gdk_mtx);
7221 mtx_depth = 1;
7222 return;
7223 }
7224
7225 if (mtx_depth != 1) {
7226 /* decrease mutext depth to 1 */
7227 do {
7228 g_static_rec_mutex_unlock(&my_gdk_mtx);
7229 mtx_depth--;
7230 } while (mtx_depth > 1);
7231 }
7232 }
7233
7234 void
7235 mtx_unlock(void)
7236 {
7237 guint x;
7238
7239 /* if mutex depth isn't 1 then something went bad */
7240 if (mtx_depth != 1) {
7241 x = g_static_rec_mutex_unlock_full(&my_gdk_mtx);
7242 if (x != 1) {
7243 /* should not happen */
7244 show_oops(NULL, "mutex unlocking bug, trying to "
7245 "correct");
7246 fprintf(stderr, "mutex unlocking bug, trying to "
7247 "correct\n");
7248 }
7249 mtx_depth = 0;
7250 if (mtx_complain == 0) {
7251 show_oops(NULL, "buggy mutex implementation detected, "
7252 "work around implemented");
7253 fprintf(stderr, "buggy mutex implementation detected, "
7254 "work around implemented");
7255 mtx_complain = 1;
7256 }
7257 return;
7258 }
7259
7260 mtx_depth--;
7261 g_static_rec_mutex_unlock(&my_gdk_mtx);
7262 }
7263
7264 int
7265 main(int argc, char *argv[])
7266 {
7267 struct stat sb;
7268 int c, s, optn = 0, opte = 0, focus = 1;
7269 char conf[PATH_MAX] = { '\0' };
7270 char file[PATH_MAX];
7271 char *env_proxy = NULL;
7272 char *cmd = NULL;
7273 FILE *f = NULL;
7274 struct karg a;
7275 struct sigaction sact;
7276 GIOChannel *channel;
7277 struct rlimit rlp;
7278
7279 start_argv = argv;
7280
7281 /* prepare gtk */
7282 #ifdef USE_THREADS
7283 g_thread_init(NULL);
7284 gdk_threads_set_lock_functions(mtx_lock, mtx_unlock);
7285 gdk_threads_init();
7286 gdk_threads_enter();
7287
7288 gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
7289 #endif
7290 gtk_init(&argc, &argv);
7291
7292 gnutls_global_init();
7293
7294 strlcpy(named_session, XT_SAVED_TABS_FILE, sizeof named_session);
7295
7296 RB_INIT(&hl);
7297 RB_INIT(&js_wl);
7298 RB_INIT(&pl_wl);
7299 RB_INIT(&downloads);
7300
7301 TAILQ_INIT(&sessions);
7302 TAILQ_INIT(&tabs);
7303 TAILQ_INIT(&mtl);
7304 TAILQ_INIT(&aliases);
7305 TAILQ_INIT(&undos);
7306 TAILQ_INIT(&kbl);
7307 TAILQ_INIT(&spl);
7308 TAILQ_INIT(&chl);
7309 TAILQ_INIT(&shl);
7310
7311 /* fiddle with ulimits */
7312 if (getrlimit(RLIMIT_NOFILE, &rlp) == -1)
7313 warn("getrlimit");
7314 else {
7315 /* just use them all */
7316 rlp.rlim_cur = rlp.rlim_max;
7317 if (setrlimit(RLIMIT_NOFILE, &rlp) == -1)
7318 warn("setrlimit");
7319 if (getrlimit(RLIMIT_NOFILE, &rlp) == -1)
7320 warn("getrlimit");
7321 else if (rlp.rlim_cur <= 256)
7322 startpage_add("%s requires at least 256 file "
7323 "descriptors, currently it has up to %d available",
7324 __progname, rlp.rlim_cur);
7325 }
7326
7327 while ((c = getopt(argc, argv, "STVf:s:tne")) != -1) {
7328 switch (c) {
7329 case 'S':
7330 show_url = 0;
7331 break;
7332 case 'T':
7333 show_tabs = 0;
7334 break;
7335 case 'V':
7336 #ifdef XXXTERM_BUILDSTR
7337 errx(0 , "Version: %s Build: %s",
7338 version, XXXTERM_BUILDSTR);
7339 #else
7340 errx(0 , "Version: %s", version);
7341 #endif
7342 break;
7343 case 'f':
7344 strlcpy(conf, optarg, sizeof(conf));
7345 break;
7346 case 's':
7347 strlcpy(named_session, optarg, sizeof(named_session));
7348 break;
7349 case 't':
7350 tabless = 1;
7351 break;
7352 case 'n':
7353 optn = 1;
7354 break;
7355 case 'e':
7356 opte = 1;
7357 break;
7358 default:
7359 usage();
7360 /* NOTREACHED */
7361 }
7362 }
7363 argc -= optind;
7364 argv += optind;
7365
7366 init_keybindings();
7367
7368 xtp_generate_keys();
7369
7370 /* signals */
7371 bzero(&sact, sizeof(sact));
7372 sigemptyset(&sact.sa_mask);
7373 sact.sa_handler = sigchild;
7374 sact.sa_flags = SA_NOCLDSTOP;
7375 sigaction(SIGCHLD, &sact, NULL);
7376
7377 /* set download dir */
7378 pwd = getpwuid(getuid());
7379 if (pwd == NULL)
7380 errx(1, "invalid user %d", getuid());
7381 strlcpy(download_dir, pwd->pw_dir, sizeof download_dir);
7382
7383 /* compile buffer command regexes */
7384 buffercmd_init();
7385
7386 /* set default string settings */
7387 home = g_strdup("https://www.cyphertite.com");
7388 search_string = g_strdup("https://ssl.scroogle.org/cgi-bin/nbbwssl.cgi?Gw=%s");
7389 resource_dir = g_strdup("/usr/local/share/xxxterm/");
7390 strlcpy(runtime_settings, "runtime", sizeof runtime_settings);
7391 cmd_font_name = g_strdup("monospace normal 9");
7392 oops_font_name = g_strdup("monospace normal 9");
7393 statusbar_font_name = g_strdup("monospace normal 9");
7394 tabbar_font_name = g_strdup("monospace normal 9");
7395 statusbar_elems = g_strdup("BP");
7396 encoding = g_strdup("UTF-8");
7397
7398 /* read config file */
7399 if (strlen(conf) == 0)
7400 snprintf(conf, sizeof conf, "%s/.%s",
7401 pwd->pw_dir, XT_CONF_FILE);
7402 config_parse(conf, 0);
7403
7404 /* init fonts */
7405 cmd_font = pango_font_description_from_string(cmd_font_name);
7406 oops_font = pango_font_description_from_string(oops_font_name);
7407 statusbar_font = pango_font_description_from_string(statusbar_font_name);
7408 tabbar_font = pango_font_description_from_string(tabbar_font_name);
7409
7410 /* working directory */
7411 if (strlen(work_dir) == 0)
7412 snprintf(work_dir, sizeof work_dir, "%s/%s",
7413 pwd->pw_dir, XT_DIR);
7414 xxx_dir(work_dir);
7415
7416 /* icon cache dir */
7417 snprintf(cache_dir, sizeof cache_dir, "%s/%s", work_dir, XT_CACHE_DIR);
7418 xxx_dir(cache_dir);
7419
7420 /* certs dir */
7421 snprintf(certs_dir, sizeof certs_dir, "%s/%s", work_dir, XT_CERT_DIR);
7422 xxx_dir(certs_dir);
7423
7424 /* sessions dir */
7425 snprintf(sessions_dir, sizeof sessions_dir, "%s/%s",
7426 work_dir, XT_SESSIONS_DIR);
7427 xxx_dir(sessions_dir);
7428
7429 /* js dir */
7430 snprintf(js_dir, sizeof js_dir, "%s/%s", work_dir, XT_JS_DIR);
7431 xxx_dir(js_dir);
7432
7433 /* runtime settings that can override config file */
7434 if (runtime_settings[0] != '\0')
7435 config_parse(runtime_settings, 1);
7436
7437 /* download dir */
7438 if (!strcmp(download_dir, pwd->pw_dir))
7439 strlcat(download_dir, "/downloads", sizeof download_dir);
7440 xxx_dir(download_dir);
7441
7442 /* favorites file */
7443 snprintf(file, sizeof file, "%s/%s", work_dir, XT_FAVS_FILE);
7444 if (stat(file, &sb)) {
7445 warnx("favorites file doesn't exist, creating it");
7446 if ((f = fopen(file, "w")) == NULL)
7447 err(1, "favorites");
7448 fclose(f);
7449 }
7450
7451 /* quickmarks file */
7452 snprintf(file, sizeof file, "%s/%s", work_dir, XT_QMARKS_FILE);
7453 if (stat(file, &sb)) {
7454 warnx("quickmarks file doesn't exist, creating it");
7455 if ((f = fopen(file, "w")) == NULL)
7456 err(1, "quickmarks");
7457 fclose(f);
7458 }
7459
7460 /* search history */
7461 if (history_autosave) {
7462 snprintf(search_file, sizeof search_file, "%s/%s",
7463 work_dir, XT_SEARCH_FILE);
7464 if (stat(search_file, &sb)) {
7465 warnx("search history file doesn't exist, creating it");
7466 if ((f = fopen(search_file, "w")) == NULL)
7467 err(1, "search_history");
7468 fclose(f);
7469 }
7470 history_read(&shl, search_file, &search_history_count);
7471 }
7472
7473 /* command history */
7474 if (history_autosave) {
7475 snprintf(command_file, sizeof command_file, "%s/%s",
7476 work_dir, XT_COMMAND_FILE);
7477 if (stat(command_file, &sb)) {
7478 warnx("command history file doesn't exist, creating it");
7479 if ((f = fopen(command_file, "w")) == NULL)
7480 err(1, "command_history");
7481 fclose(f);
7482 }
7483 history_read(&chl, command_file, &cmd_history_count);
7484 }
7485
7486 /* cookies */
7487 session = webkit_get_default_session();
7488 setup_cookies();
7489
7490 /* certs */
7491 if (ssl_ca_file) {
7492 if (stat(ssl_ca_file, &sb)) {
7493 warnx("no CA file: %s", ssl_ca_file);
7494 g_free(ssl_ca_file);
7495 ssl_ca_file = NULL;
7496 } else
7497 g_object_set(session,
7498 SOUP_SESSION_SSL_CA_FILE, ssl_ca_file,
7499 SOUP_SESSION_SSL_STRICT, ssl_strict_certs,
7500 (void *)NULL);
7501 }
7502
7503 /* guess_search regex */
7504 if (url_regex == NULL)
7505 url_regex = g_strdup(XT_URL_REGEX);
7506 if (url_regex)
7507 if (regcomp(&url_re, url_regex, REG_EXTENDED | REG_NOSUB))
7508 startpage_add("invalid url regex %s", url_regex);
7509
7510 /* proxy */
7511 env_proxy = getenv("http_proxy");
7512 if (env_proxy)
7513 setup_proxy(env_proxy);
7514 else {
7515 env_proxy = getenv("HTTP_PROXY");
7516 if (env_proxy)
7517 setup_proxy(env_proxy);
7518 else
7519 setup_proxy(http_proxy);
7520 }
7521
7522 if (opte) {
7523 send_cmd_to_socket(argv[0]);
7524 exit(0);
7525 }
7526
7527 /* set some connection parameters */
7528 g_object_set(session, "max-conns", max_connections, (char *)NULL);
7529 g_object_set(session, "max-conns-per-host", max_host_connections,
7530 (char *)NULL);
7531
7532 /* see if there is already an xxxterm running */
7533 if (single_instance && is_running()) {
7534 optn = 1;
7535 warnx("already running");
7536 }
7537
7538 if (optn) {
7539 while (argc) {
7540 cmd = g_strdup_printf("%s %s", "tabnew", argv[0]);
7541 send_cmd_to_socket(cmd);
7542 if (cmd)
7543 g_free(cmd);
7544
7545 argc--;
7546 argv++;
7547 }
7548 exit(0);
7549 }
7550
7551 /* uri completion */
7552 completion_model = gtk_list_store_new(1, G_TYPE_STRING);
7553
7554 /* buffers */
7555 buffers_store = gtk_list_store_new
7556 (NUM_COLS, G_TYPE_UINT, G_TYPE_STRING);
7557
7558 qmarks_load();
7559
7560 /* go graphical */
7561 create_canvas();
7562 notebook_tab_set_visibility();
7563
7564 if (save_global_history)
7565 restore_global_history();
7566
7567 /* restore session list */
7568 restore_sessions_list();
7569
7570 if (!strcmp(named_session, XT_SAVED_TABS_FILE))
7571 restore_saved_tabs();
7572 else {
7573 a.s = named_session;
7574 a.i = XT_SES_DONOTHING;
7575 open_tabs(NULL, &a);
7576 }
7577
7578 /* see if we have an exception */
7579 if (!TAILQ_EMPTY(&spl)) {
7580 create_new_tab("about:startpage", NULL, focus, -1);
7581 focus = 0;
7582 }
7583
7584 while (argc) {
7585 create_new_tab(argv[0], NULL, focus, -1);
7586 focus = 0;
7587
7588 argc--;
7589 argv++;
7590 }
7591
7592 if (TAILQ_EMPTY(&tabs))
7593 create_new_tab(home, NULL, 1, -1);
7594
7595 if (enable_socket)
7596 if ((s = build_socket()) != -1) {
7597 channel = g_io_channel_unix_new(s);
7598 g_io_add_watch(channel, G_IO_IN, socket_watcher, NULL);
7599 }
7600
7601 gtk_main();
7602
7603 #ifdef USE_THREADS
7604 gdk_threads_leave();
7605 g_static_rec_mutex_unlock_full(&my_gdk_mtx); /* just in case */
7606 #endif
7607
7608 gnutls_global_deinit();
7609
7610 if (url_regex)
7611 regfree(&url_re);
7612
7613 return (0);
7614 }
XXXTerm