?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add search with / and n and N
[xxxterm.git] / xxxterm.c
blob2c4a1ca49b568e65e7cbfab513b643cccb570bb6
1 /* $xxxterm$ */
2 /*
3 * Copyright (c) 2010 Marco Peereboom <marco@peereboom.us>
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 /*
19 * TODO:
20 * inverse color browsing
21 * favs
22 * download files status
23 * multi letter commands
24 * pre and post counts for commands
25 * search on page
26 * search on engines
27 * fav icon
28 * close tab X
29 * autocompletion on various inputs
30 */
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <err.h>
35 #include <pwd.h>
36 #include <string.h>
37 #include <unistd.h>
38 #include <util.h>
39
40 #include <sys/queue.h>
41 #include <sys/types.h>
42 #include <sys/stat.h>
43
44 #include <gtk/gtk.h>
45 #include <gdk/gdkkeysyms.h>
46 #include <webkit/webkit.h>
47 #include <libsoup/soup.h>
48 #include <JavaScriptCore/JavaScript.h>
49
50 static char *version = "$xxxterm$";
51
52 #define XT_DEBUG
53 /* #define XT_DEBUG */
54 #ifdef XT_DEBUG
55 #define DPRINTF(x...) do { if (swm_debug) fprintf(stderr, x); } while (0)
56 #define DNPRINTF(n,x...) do { if (swm_debug & n) fprintf(stderr, x); } while (0)
57 #define XT_D_MOVE 0x0001
58 #define XT_D_KEY 0x0002
59 #define XT_D_TAB 0x0004
60 #define XT_D_URL 0x0008
61 #define XT_D_CMD 0x0010
62 #define XT_D_NAV 0x0020
63 #define XT_D_DOWNLOAD 0x0040
64 #define XT_D_CONFIG 0x0080
65 u_int32_t swm_debug = 0
66 | XT_D_MOVE
67 | XT_D_KEY
68 | XT_D_TAB
69 | XT_D_URL
70 | XT_D_CMD
71 | XT_D_NAV
72 | XT_D_DOWNLOAD
73 | XT_D_CONFIG
74 ;
75 #else
76 #define DPRINTF(x...)
77 #define DNPRINTF(n,x...)
78 #endif
79
80 #define LENGTH(x) (sizeof x / sizeof x[0])
81 #define CLEAN(mask) (mask & ~(GDK_MOD2_MASK) & \
82 ~(GDK_BUTTON1_MASK) & \
83 ~(GDK_BUTTON2_MASK) & \
84 ~(GDK_BUTTON3_MASK) & \
85 ~(GDK_BUTTON4_MASK) & \
86 ~(GDK_BUTTON5_MASK))
87
88 struct tab {
89 TAILQ_ENTRY(tab) entry;
90 GtkWidget *vbox;
91 GtkWidget *label;
92 GtkWidget *uri_entry;
93 GtkWidget *search_entry;
94 GtkWidget *toolbar;
95 GtkWidget *browser_win;
96 GtkWidget *cmd;
97 GtkToolItem *backward;
98 GtkToolItem *forward;
99 GtkToolItem *stop;
100 guint tab_id;
101
102 /* adjustments for browser */
103 GtkScrollbar *sb_h;
104 GtkScrollbar *sb_v;
105 GtkAdjustment *adjust_h;
106 GtkAdjustment *adjust_v;
107
108 /* flags */
109 int focus_wv;
110 int ctrl_click;
111 gchar *hover;
112
113 /* search */
114 char *search_text;
115
116 WebKitWebView *wv;
117 WebKitWebSettings *settings;
118 };
119 TAILQ_HEAD(tab_list, tab);
120
121 struct karg {
122 int i;
123 char *s;
124 };
125
126 /* defines */
127 #define XT_DIR (".xxxterm")
128 #define XT_CONF_FILE ("xxxterm.conf")
129 #define XT_CB_HANDLED (TRUE)
130 #define XT_CB_PASSTHROUGH (FALSE)
131
132 /* actions */
133 #define XT_MOVE_INVALID (0)
134 #define XT_MOVE_DOWN (1)
135 #define XT_MOVE_UP (2)
136 #define XT_MOVE_BOTTOM (3)
137 #define XT_MOVE_TOP (4)
138 #define XT_MOVE_PAGEDOWN (5)
139 #define XT_MOVE_PAGEUP (6)
140 #define XT_MOVE_LEFT (7)
141 #define XT_MOVE_FARLEFT (8)
142 #define XT_MOVE_RIGHT (9)
143 #define XT_MOVE_FARRIGHT (10)
144
145 #define XT_TAB_PREV (-2)
146 #define XT_TAB_NEXT (-1)
147 #define XT_TAB_INVALID (0)
148 #define XT_TAB_NEW (1)
149 #define XT_TAB_DELETE (2)
150 #define XT_TAB_DELQUIT (3)
151 #define XT_TAB_OPEN (4)
152
153 #define XT_NAV_INVALID (0)
154 #define XT_NAV_BACK (1)
155 #define XT_NAV_FORWARD (2)
156 #define XT_NAV_RELOAD (3)
157
158 #define XT_FOCUS_INVALID (0)
159 #define XT_FOCUS_URI (1)
160
161 #define XT_SEARCH_INVALID (0)
162 #define XT_SEARCH_NEXT (1)
163 #define XT_SEARCH_PREV (2)
164
165 /* globals */
166 extern char *__progname;
167 struct passwd *pwd;
168 GtkWidget *main_window;
169 GtkNotebook *notebook;
170 struct tab_list tabs;
171
172 /* settings */
173 int showtabs = 1; /* show tabs on notebook */
174 int showurl = 1; /* show url toolbar on notebook */
175 int tabless = 0; /* allow only 1 tab */
176 int ctrl_click_focus = 0; /* ctrl click gets focus */
177 int cookies_enabled = 1; /* enable cookies */
178 int read_only_cookies = 0; /* enable to not write cookies */
179 int enable_scripts = 1;
180 int enable_plugins = 1;
181 int default_font_size = 12;
182 int fancy_bar = 1; /* fancy toolbar */
183
184 char *home = "http://www.peereboom.us";
185 char *search_string = NULL;
186 char *http_proxy = NULL;
187 SoupURI *proxy_uri = NULL;
188 char work_dir[PATH_MAX];
189 char cookie_file[PATH_MAX];
190 char download_dir[PATH_MAX];
191 SoupSession *session;
192 SoupCookieJar *cookiejar;
193
194 /* protos */
195 void create_new_tab(char *, int);
196 void delete_tab(struct tab *);
197
198 struct valid_url_types {
199 char *type;
200 } vut[] = {
201 { "http://" },
202 { "https://" },
203 { "ftp://" },
204 { "file://" },
205 };
206
207 int
208 valid_url_type(char *url)
209 {
210 int i;
211
212 for (i = 0; i < LENGTH(vut); i++)
213 if (!strncasecmp(vut[i].type, url, strlen(vut[i].type)))
214 return (0);
215
216 return (1);
217 }
218
219 char *
220 guess_url_type(char *url_in)
221 {
222 struct stat sb;
223 char *url_out = NULL;
224
225 /* XXX not sure about this heuristic */
226 if (stat(url_in, &sb) == 0) {
227 if (asprintf(&url_out, "file://%s", url_in) == -1)
228 err(1, "aprintf file");
229 } else {
230 /* guess http */
231 if (asprintf(&url_out, "http://%s", url_in) == -1)
232 err(1, "aprintf http");
233 }
234
235 if (url_out == NULL)
236 err(1, "asprintf pointer");
237
238 DNPRINTF(XT_D_URL, "guess_url_type: guessed %s\n", url_out);
239
240 return (url_out);
241 }
242
243 #define WS "\n= \t"
244 void
245 config_parse(char *filename)
246 {
247 FILE *config;
248 char *line, *cp, *var, *val;
249 size_t len, lineno = 0;
250
251 DNPRINTF(XT_D_CONFIG, "config_parse: filename %s\n", filename);
252
253 if (filename == NULL)
254 return;
255
256 if ((config = fopen(filename, "r")) == NULL) {
257 warn("config_parse: cannot open %s", filename);
258 return;
259 }
260
261 for (;;) {
262 if ((line = fparseln(config, &len, &lineno, NULL, 0)) == NULL)
263 if (feof(config))
264 break;
265
266 cp = line;
267 cp += (long)strspn(cp, WS);
268 if (cp[0] == '\0') {
269 /* empty line */
270 free(line);
271 continue;
272 }
273
274 if ((var = strsep(&cp, WS)) == NULL || cp == NULL)
275 break;
276
277 cp += (long)strspn(cp, WS);
278
279 if ((val = strsep(&cp, "\0")) == NULL)
280 break;
281
282 DNPRINTF(XT_D_CONFIG, "config_parse: %s=%s\n",var ,val);
283
284 /* get settings */
285 if (!strcmp(var, "home"))
286 home = strdup(val);
287 else if (!strcmp(var, "ctrl_click_focus"))
288 ctrl_click_focus = atoi(val);
289 else if (!strcmp(var, "read_only_cookies"))
290 read_only_cookies = atoi(val);
291 else if (!strcmp(var, "cookies_enabled"))
292 cookies_enabled = atoi(val);
293 else if (!strcmp(var, "enable_scripts"))
294 enable_scripts = atoi(val);
295 else if (!strcmp(var, "enable_plugins"))
296 enable_plugins = atoi(val);
297 else if (!strcmp(var, "default_font_size"))
298 default_font_size = atoi(val);
299 else if (!strcmp(var, "fancy_bar"))
300 fancy_bar = atoi(val);
301 else if (!strcmp(var, "http_proxy")) {
302 http_proxy = strdup(val);
303 if (http_proxy == NULL)
304 err(1, "http_proxy");
305 } else if (!strcmp(var, "search_string")) {
306 search_string = strdup(val);
307 if (search_string == NULL)
308 err(1, "search_string");
309 } else if (!strcmp(var, "download_dir")) {
310 if (val[0] == '~')
311 snprintf(download_dir, sizeof download_dir,
312 "%s/%s", pwd->pw_dir, &val[1]);
313 else
314 strlcpy(download_dir, val, sizeof download_dir);
315 fprintf(stderr, "download dir: %s\n", download_dir);
316 } else
317 errx(1, "invalid conf file entry: %s=%s", var, val);
318
319 free(line);
320 }
321
322 fclose(config);
323 }
324 int
325 quit(struct tab *t, struct karg *args)
326 {
327 gtk_main_quit();
328
329 return (1);
330 }
331
332 int
333 focus(struct tab *t, struct karg *args)
334 {
335 if (t == NULL)
336 errx(1, "focus");
337
338 if (args->i == XT_FOCUS_URI)
339 gtk_widget_grab_focus(GTK_WIDGET(t->uri_entry));
340
341 return (0);
342 }
343
344 int
345 help(struct tab *t, struct karg *args)
346 {
347 if (t == NULL)
348 errx(1, "help");
349
350 webkit_web_view_load_string(t->wv,
351 "<html><body><h1>XXXTerm</h1></body></html>",
352 NULL,
353 NULL,
354 NULL);
355
356 return (0);
357 }
358
359 int
360 navaction(struct tab *t, struct karg *args)
361 {
362 DNPRINTF(XT_D_NAV, "navaction: tab %d opcode %d\n",
363 t->tab_id, args->i);
364
365 switch (args->i) {
366 case XT_NAV_BACK:
367 webkit_web_view_go_back(t->wv);
368 break;
369 case XT_NAV_FORWARD:
370 webkit_web_view_go_forward(t->wv);
371 break;
372 case XT_NAV_RELOAD:
373 webkit_web_view_reload(t->wv);
374 break;
375 }
376 return (XT_CB_PASSTHROUGH);
377 }
378
379 int
380 move(struct tab *t, struct karg *args)
381 {
382 GtkAdjustment *adjust;
383 double pi, si, pos, ps, upper, lower, max;
384
385 switch (args->i) {
386 case XT_MOVE_DOWN:
387 case XT_MOVE_UP:
388 case XT_MOVE_BOTTOM:
389 case XT_MOVE_TOP:
390 case XT_MOVE_PAGEDOWN:
391 case XT_MOVE_PAGEUP:
392 adjust = t->adjust_v;
393 break;
394 default:
395 adjust = t->adjust_h;
396 break;
397 }
398
399 pos = gtk_adjustment_get_value(adjust);
400 ps = gtk_adjustment_get_page_size(adjust);
401 upper = gtk_adjustment_get_upper(adjust);
402 lower = gtk_adjustment_get_lower(adjust);
403 si = gtk_adjustment_get_step_increment(adjust);
404 pi = gtk_adjustment_get_page_increment(adjust);
405 max = upper - ps;
406
407 DNPRINTF(XT_D_MOVE, "move: opcode %d %s pos %f ps %f upper %f lower %f "
408 "max %f si %f pi %f\n",
409 args->i, adjust == t->adjust_h ? "horizontal" : "vertical",
410 pos, ps, upper, lower, max, si, pi);
411
412 switch (args->i) {
413 case XT_MOVE_DOWN:
414 case XT_MOVE_RIGHT:
415 pos += si;
416 gtk_adjustment_set_value(adjust, MIN(pos, max));
417 break;
418 case XT_MOVE_UP:
419 case XT_MOVE_LEFT:
420 pos -= si;
421 gtk_adjustment_set_value(adjust, MAX(pos, lower));
422 break;
423 case XT_MOVE_BOTTOM:
424 case XT_MOVE_FARRIGHT:
425 gtk_adjustment_set_value(adjust, max);
426 break;
427 case XT_MOVE_TOP:
428 case XT_MOVE_FARLEFT:
429 gtk_adjustment_set_value(adjust, lower);
430 break;
431 case XT_MOVE_PAGEDOWN:
432 pos += pi;
433 gtk_adjustment_set_value(adjust, MIN(pos, max));
434 break;
435 case XT_MOVE_PAGEUP:
436 pos -= pi;
437 gtk_adjustment_set_value(adjust, MAX(pos, lower));
438 break;
439 default:
440 return (XT_CB_PASSTHROUGH);
441 }
442
443 DNPRINTF(XT_D_MOVE, "move: new pos %f %f\n", pos, MIN(pos, max));
444
445 return (XT_CB_HANDLED);
446 }
447
448 char *
449 getparams(char *cmd, char *cmp)
450 {
451 char *rv = NULL;
452
453 if (cmd && cmp) {
454 if (!strncmp(cmd, cmp, strlen(cmp))) {
455 rv = cmd + strlen(cmp);
456 while (*rv == ' ')
457 rv++;
458 if (strlen(rv) == 0)
459 rv = NULL;
460 }
461 }
462
463 return (rv);
464 }
465
466 int
467 tabaction(struct tab *t, struct karg *args)
468 {
469 int rv = XT_CB_HANDLED;
470 char *url = NULL, *newuri = NULL;
471
472 DNPRINTF(XT_D_TAB, "tabaction: %p %d %d\n", t, args->i, t->focus_wv);
473
474 if (t == NULL)
475 return (XT_CB_PASSTHROUGH);
476
477 switch (args->i) {
478 case XT_TAB_NEW:
479 if ((url = getparams(args->s, "tabnew")))
480 create_new_tab(url, 1);
481 else
482 create_new_tab(NULL, 1);
483 break;
484 case XT_TAB_DELETE:
485 delete_tab(t);
486 break;
487 case XT_TAB_DELQUIT:
488 if (gtk_notebook_get_n_pages(notebook) > 1)
489 delete_tab(t);
490 else
491 quit(t, args);
492 break;
493 case XT_TAB_OPEN:
494 if ((url = getparams(args->s, "open")) ||
495 ((url = getparams(args->s, "op"))) ||
496 ((url = getparams(args->s, "o"))))
497 ;
498 else {
499 rv = XT_CB_PASSTHROUGH;
500 goto done;
501 }
502
503 if (valid_url_type(url)) {
504 newuri = guess_url_type(url);
505 url = newuri;
506 }
507 webkit_web_view_load_uri(t->wv, url);
508 if (newuri)
509 free(newuri);
510 break;
511 default:
512 rv = XT_CB_PASSTHROUGH;
513 goto done;
514 }
515
516 done:
517 if (args->s) {
518 free(args->s);
519 args->s = NULL;
520 }
521
522 return (rv);
523 }
524
525 int
526 movetab(struct tab *t, struct karg *args)
527 {
528 struct tab *tt;
529 int x;
530
531 DNPRINTF(XT_D_TAB, "movetab: %p %d\n", t, args->i);
532
533 if (t == NULL)
534 return (XT_CB_PASSTHROUGH);
535
536 if (args->i == XT_TAB_INVALID)
537 return (XT_CB_PASSTHROUGH);
538
539 if (args->i < XT_TAB_INVALID) {
540 /* next or previous tab */
541 if (TAILQ_EMPTY(&tabs))
542 return (XT_CB_PASSTHROUGH);
543
544 if (args->i == XT_TAB_NEXT)
545 gtk_notebook_next_page(notebook);
546 else
547 gtk_notebook_prev_page(notebook);
548
549 return (XT_CB_HANDLED);
550 }
551
552 /* jump to tab */
553 x = args->i - 1;
554 if (t->tab_id == x) {
555 DNPRINTF(XT_D_TAB, "movetab: do nothing\n");
556 return (XT_CB_HANDLED);
557 }
558
559 TAILQ_FOREACH(tt, &tabs, entry) {
560 if (tt->tab_id == x) {
561 gtk_notebook_set_current_page(notebook, x);
562 DNPRINTF(XT_D_TAB, "movetab: going to %d\n", x);
563 if (tt->focus_wv)
564 gtk_widget_grab_focus(GTK_WIDGET(tt->wv));
565 }
566 }
567
568 return (XT_CB_HANDLED);
569 }
570
571 int
572 command(struct tab *t, struct karg *args)
573 {
574 char *s = NULL;
575 GdkColor color;
576
577 if (t == NULL || args == NULL)
578 errx(1, "command");
579
580 if (args->i == '/')
581 s = "/";
582 else if (args->i == ':')
583 s = ":";
584 else {
585 warnx("invalid command %c\n", args->i);
586 return (XT_CB_PASSTHROUGH);
587 }
588
589 DNPRINTF(XT_D_CMD, "command: type %s\n", s);
590
591 gtk_entry_set_text(GTK_ENTRY(t->cmd), s);
592 gdk_color_parse("white", &color);
593 gtk_widget_modify_base(t->cmd, GTK_STATE_NORMAL, &color);
594 gtk_widget_show(t->cmd);
595 gtk_widget_grab_focus(GTK_WIDGET(t->cmd));
596 gtk_editable_set_position(GTK_EDITABLE(t->cmd), -1);
597
598 return (XT_CB_HANDLED);
599 }
600
601 int
602 search(struct tab *t, struct karg *args)
603 {
604 gboolean d;
605
606 if (t == NULL || args == NULL)
607 errx(1, "search");
608 if (t->search_text == NULL)
609 return (XT_CB_PASSTHROUGH);
610
611 DNPRINTF(XT_D_CMD, "search: tab %d opc %d text %s\n",
612 t->tab_id, args->i, t->search_text);
613
614 switch (args->i) {
615 case XT_SEARCH_NEXT:
616 d = TRUE;
617 break;
618 case XT_SEARCH_PREV:
619 d = FALSE;
620 break;
621 default:
622 return (XT_CB_PASSTHROUGH);
623 }
624
625 webkit_web_view_search_text(t->wv, t->search_text, FALSE, d, TRUE);
626
627 return (XT_CB_HANDLED);
628 }
629
630 /* inherent to GTK not all keys will be caught at all times */
631 struct key {
632 guint mask;
633 guint modkey;
634 guint key;
635 int (*func)(struct tab *, struct karg *);
636 struct karg arg;
637 } keys[] = {
638 { 0, 0, GDK_slash, command, {.i = '/'} },
639 { GDK_SHIFT_MASK, 0, GDK_colon, command, {.i = ':'} },
640 { GDK_CONTROL_MASK, 0, GDK_q, quit, {0} },
641
642 /* search */
643 { 0, 0, GDK_n, search, {.i = XT_SEARCH_NEXT} },
644 { GDK_SHIFT_MASK, 0, GDK_N, search, {.i = XT_SEARCH_PREV} },
645
646 /* focus */
647 { 0, 0, GDK_F6, focus, {.i = XT_FOCUS_URI} },
648
649 /* navigation */
650 { 0, 0, GDK_BackSpace, navaction, {.i = XT_NAV_BACK} },
651 { GDK_MOD1_MASK, 0, GDK_Left, navaction, {.i = XT_NAV_BACK} },
652 { GDK_SHIFT_MASK, 0, GDK_BackSpace, navaction, {.i = XT_NAV_FORWARD} },
653 { GDK_MOD1_MASK, 0, GDK_Right, navaction, {.i = XT_NAV_FORWARD} },
654 { 0, 0, GDK_F5, navaction, {.i = XT_NAV_RELOAD} },
655
656 /* vertical movement */
657 { 0, 0, GDK_j, move, {.i = XT_MOVE_DOWN} },
658 { 0, 0, GDK_Down, move, {.i = XT_MOVE_DOWN} },
659 { 0, 0, GDK_Up, move, {.i = XT_MOVE_UP} },
660 { 0, 0, GDK_k, move, {.i = XT_MOVE_UP} },
661 { GDK_SHIFT_MASK, 0, GDK_G, move, {.i = XT_MOVE_BOTTOM} },
662 { 0, 0, GDK_End, move, {.i = XT_MOVE_BOTTOM} },
663 { 0, 0, GDK_Home, move, {.i = XT_MOVE_TOP} },
664 { 0, GDK_g, GDK_g, move, {.i = XT_MOVE_TOP} }, /* XXX make this work */
665 { 0, 0, GDK_space, move, {.i = XT_MOVE_PAGEDOWN} },
666 { 0, 0, GDK_Page_Down, move, {.i = XT_MOVE_PAGEDOWN} },
667 { 0, 0, GDK_Page_Up, move, {.i = XT_MOVE_PAGEUP} },
668 /* horizontal movement */
669 { 0, 0, GDK_l, move, {.i = XT_MOVE_RIGHT} },
670 { 0, 0, GDK_Right, move, {.i = XT_MOVE_RIGHT} },
671 { 0, 0, GDK_Left, move, {.i = XT_MOVE_LEFT} },
672 { 0, 0, GDK_h, move, {.i = XT_MOVE_LEFT} },
673 { GDK_SHIFT_MASK, 0, GDK_dollar, move, {.i = XT_MOVE_FARRIGHT} },
674 { 0, 0, GDK_0, move, {.i = XT_MOVE_FARLEFT} },
675
676 /* tabs */
677 { GDK_CONTROL_MASK, 0, GDK_t, tabaction, {.i = XT_TAB_NEW} },
678 { GDK_CONTROL_MASK, 0, GDK_w, tabaction, {.i = XT_TAB_DELETE} },
679 { GDK_CONTROL_MASK, 0, GDK_1, movetab, {.i = 1} },
680 { GDK_CONTROL_MASK, 0, GDK_2, movetab, {.i = 2} },
681 { GDK_CONTROL_MASK, 0, GDK_3, movetab, {.i = 3} },
682 { GDK_CONTROL_MASK, 0, GDK_4, movetab, {.i = 4} },
683 { GDK_CONTROL_MASK, 0, GDK_5, movetab, {.i = 5} },
684 { GDK_CONTROL_MASK, 0, GDK_6, movetab, {.i = 6} },
685 { GDK_CONTROL_MASK, 0, GDK_7, movetab, {.i = 7} },
686 { GDK_CONTROL_MASK, 0, GDK_8, movetab, {.i = 8} },
687 { GDK_CONTROL_MASK, 0, GDK_9, movetab, {.i = 9} },
688 { GDK_CONTROL_MASK, 0, GDK_0, movetab, {.i = 10} },
689 };
690
691 struct cmd {
692 char *cmd;
693 int params;
694 int (*func)(struct tab *, struct karg *);
695 struct karg arg;
696 } cmds[] = {
697 { "q!", 0, quit, {0} },
698 { "qa", 0, quit, {0} },
699 { "qa!", 0, quit, {0} },
700 { "help", 0, help, {0} },
701
702 /* tabs */
703 { "o", 1, tabaction, {.i = XT_TAB_OPEN} },
704 { "op", 1, tabaction, {.i = XT_TAB_OPEN} },
705 { "open", 1, tabaction, {.i = XT_TAB_OPEN} },
706 { "tabnew", 1, tabaction, {.i = XT_TAB_NEW} },
707 { "tabedit", 1, tabaction, {.i = XT_TAB_NEW} },
708 { "tabe", 1, tabaction, {.i = XT_TAB_NEW} },
709 { "tabclose", 0, tabaction, {.i = XT_TAB_DELETE} },
710 { "tabc", 0, tabaction, {.i = XT_TAB_DELETE} },
711 { "quit", 0, tabaction, {.i = XT_TAB_DELQUIT} },
712 { "q", 0, tabaction, {.i = XT_TAB_DELQUIT} },
713 /* XXX add count to these commands and add tabl and friends */
714 { "tabprevious", 0, movetab, {.i = XT_TAB_PREV} },
715 { "tabp", 0, movetab, {.i = XT_TAB_PREV} },
716 { "tabnext", 0, movetab, {.i = XT_TAB_NEXT} },
717 { "tabn", 0, movetab, {.i = XT_TAB_NEXT} },
718 };
719
720 void
721 focus_uri_entry_cb(GtkWidget* w, GtkDirectionType direction, struct tab *t)
722 {
723 DNPRINTF(XT_D_URL, "focus_uri_entry_cb: tab %d focus_wv %d\n",
724 t->tab_id, t->focus_wv);
725
726 if (t == NULL)
727 errx(1, "focus_uri_entry_cb");
728
729 /* focus on wv instead */
730 if (t->focus_wv)
731 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
732 }
733
734 void
735 activate_uri_entry_cb(GtkWidget* entry, struct tab *t)
736 {
737 const gchar *uri = gtk_entry_get_text(GTK_ENTRY(entry));
738 char *newuri = NULL;
739
740 DNPRINTF(XT_D_URL, "activate_uri_entry_cb: %s\n", uri);
741
742 if (t == NULL)
743 errx(1, "activate_uri_entry_cb");
744
745 if (uri == NULL)
746 errx(1, "uri");
747
748 if (valid_url_type((char *)uri)) {
749 newuri = guess_url_type((char *)uri);
750 uri = newuri;
751 }
752
753 webkit_web_view_load_uri(t->wv, uri);
754 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
755
756 if (newuri)
757 free(newuri);
758 }
759
760 void
761 activate_search_entry_cb(GtkWidget* entry, struct tab *t)
762 {
763 const gchar *search = gtk_entry_get_text(GTK_ENTRY(entry));
764 char *newuri = NULL;
765
766 DNPRINTF(XT_D_URL, "activate_search_entry_cb: %s\n", search);
767
768 if (t == NULL)
769 errx(1, "activate_search_entry_cb");
770
771 if (search_string == NULL) {
772 warnx("no search_string");
773 return;
774 }
775
776 if (asprintf(&newuri, search_string, search) == -1)
777 err(1, "activate_search_entry_cb");
778
779 webkit_web_view_load_uri(t->wv, newuri);
780 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
781
782 if (newuri)
783 free(newuri);
784 }
785
786 void
787 notify_load_status_cb(WebKitWebView* wview, GParamSpec* pspec, struct tab *t)
788 {
789 WebKitWebFrame *frame;
790 const gchar *uri;
791
792 if (t == NULL)
793 errx(1, "notify_load_status_cb");
794
795 switch (webkit_web_view_get_load_status(wview)) {
796 case WEBKIT_LOAD_COMMITTED:
797 frame = webkit_web_view_get_main_frame(wview);
798 uri = webkit_web_frame_get_uri(frame);
799 if (uri)
800 gtk_entry_set_text(GTK_ENTRY(t->uri_entry), uri);
801
802 gtk_widget_set_sensitive(GTK_WIDGET(t->stop), TRUE);
803 t->focus_wv = 1;
804
805 /* take focus if we are visible */
806 if (gtk_notebook_get_current_page(notebook) == t->tab_id)
807 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
808 break;
809 case WEBKIT_LOAD_FIRST_VISUALLY_NON_EMPTY_LAYOUT:
810 uri = webkit_web_view_get_title(wview);
811 if (uri == NULL) {
812 frame = webkit_web_view_get_main_frame(wview);
813 uri = webkit_web_frame_get_uri(frame);
814 }
815 gtk_label_set_text(GTK_LABEL(t->label), uri);
816 break;
817 case WEBKIT_LOAD_PROVISIONAL:
818 case WEBKIT_LOAD_FINISHED:
819 case WEBKIT_LOAD_FAILED:
820 gtk_widget_set_sensitive(GTK_WIDGET(t->stop), FALSE);
821 default:
822 break;
823 }
824
825 gtk_widget_set_sensitive(GTK_WIDGET(t->backward),
826 webkit_web_view_can_go_back(wview));
827
828 gtk_widget_set_sensitive(GTK_WIDGET(t->forward),
829 webkit_web_view_can_go_forward(wview));
830 }
831
832 int
833 webview_npd_cb(WebKitWebView *wv, WebKitWebFrame *wf,
834 WebKitNetworkRequest *request, WebKitWebNavigationAction *na,
835 WebKitWebPolicyDecision *pd, struct tab *t)
836 {
837 char *uri;
838
839 if (t == NULL)
840 errx(1, "webview_npd_cb");
841
842 DNPRINTF(XT_D_NAV, "webview_npd_cb: %s\n",
843 webkit_network_request_get_uri(request));
844
845 if (t->ctrl_click) {
846 uri = (char *)webkit_network_request_get_uri(request);
847 create_new_tab(uri, ctrl_click_focus);
848 t->ctrl_click = 0;
849 webkit_web_policy_decision_ignore(pd);
850
851 return (TRUE); /* we made the decission */
852 }
853
854 return (FALSE);
855 }
856
857 int
858 webview_event_cb(GtkWidget *w, GdkEventButton *e, struct tab *t)
859 {
860 /* we can not eat the event without throwing gtk off so defer it */
861
862 /* catch ctrl click */
863 if (e->type == GDK_BUTTON_RELEASE &&
864 CLEAN(e->state) == GDK_CONTROL_MASK)
865 t->ctrl_click = 1;
866 else
867 t->ctrl_click = 0;
868
869 return (XT_CB_PASSTHROUGH);
870 }
871
872 int
873 webview_mimetype_cb(WebKitWebView *wv, WebKitWebFrame *frame,
874 WebKitNetworkRequest *request, char *mime_type,
875 WebKitWebPolicyDecision *decision, struct tab *t)
876 {
877 if (t == NULL)
878 errx(1, "webview_mimetype_cb");
879
880 DNPRINTF(XT_D_DOWNLOAD, "webview_mimetype_cb: tab %d mime %s\n",
881 t->tab_id, mime_type);
882
883 if (webkit_web_view_can_show_mime_type(wv, mime_type) == FALSE) {
884 webkit_web_policy_decision_download(decision);
885 return (TRUE);
886 }
887
888 return (FALSE);
889 }
890
891 int
892 webview_download_cb(WebKitWebView *wv, WebKitDownload *download, struct tab *t)
893 {
894 const gchar *filename;
895 char *uri = NULL;
896
897 if (download == NULL || t == NULL)
898 errx(1, "webview_download_cb: invalid pointers");
899
900 filename = webkit_download_get_suggested_filename(download);
901 if (filename == NULL)
902 return (FALSE); /* abort download */
903
904 if (asprintf(&uri, "file://%s/%s", download_dir, filename) == -1)
905 err(1, "aprintf uri");
906
907 DNPRINTF(XT_D_DOWNLOAD, "webview_download_cb: tab %d filename %s "
908 "local %s\n",
909 t->tab_id, filename, uri);
910
911 webkit_download_set_destination_uri(download, uri);
912
913 if (uri)
914 free(uri);
915
916 webkit_download_start(download);
917
918 return (TRUE); /* start download */
919 }
920
921 /* XXX currently unused */
922 void
923 webview_hover_cb(WebKitWebView *wv, gchar *title, gchar *uri, struct tab *t)
924 {
925 DNPRINTF(XT_D_KEY, "webview_hover_cb: %s %s\n", title, uri);
926
927 if (t == NULL)
928 errx(1, "webview_hover_cb");
929
930 if (uri) {
931 if (t->hover) {
932 free(t->hover);
933 t->hover = NULL;
934 }
935 t->hover = strdup(uri);
936 } else if (t->hover) {
937 free(t->hover);
938 t->hover = NULL;
939 }
940 }
941
942 int
943 webview_keypress_cb(GtkWidget *w, GdkEventKey *e, struct tab *t)
944 {
945 int i;
946
947 /* don't use w directly; use t->whatever instead */
948
949 if (t == NULL)
950 errx(1, "webview_keypress_cb");
951
952 DNPRINTF(XT_D_KEY, "webview_keypress_cb: keyval 0x%x mask 0x%x t %p\n",
953 e->keyval, e->state, t);
954
955 for (i = 0; i < LENGTH(keys); i++)
956 if (e->keyval == keys[i].key && CLEAN(e->state) ==
957 keys[i].mask) {
958 keys[i].func(t, &keys[i].arg);
959 return (XT_CB_HANDLED);
960 }
961
962 return (XT_CB_PASSTHROUGH);
963 }
964
965 int
966 cmd_keyrelease_cb(GtkEntry *w, GdkEventKey *e, struct tab *t)
967 {
968 const gchar *c = gtk_entry_get_text(w);
969 GdkColor color;
970
971 DNPRINTF(XT_D_CMD, "cmd_keyrelease_cb: keyval 0x%x mask 0x%x t %p\n",
972 e->keyval, e->state, t);
973
974 if (t == NULL)
975 errx(1, "cmd_keyrelease_cb");
976
977 DNPRINTF(XT_D_CMD, "cmd_keyrelease_cb: keyval 0x%x mask 0x%x t %p\n",
978 e->keyval, e->state, t);
979
980 if (c[0] == ':')
981 goto done;
982 if (!strcmp(c, "/"))
983 goto done;
984
985 /* search */
986 if (webkit_web_view_search_text(t->wv, &c[1], FALSE, TRUE, TRUE) == FALSE) {
987 /* not found, mark red */
988 gdk_color_parse("red", &color);
989 gtk_widget_modify_base(t->cmd, GTK_STATE_NORMAL, &color);
990 /* unmark and remove selection */
991 webkit_web_view_unmark_text_matches(t->wv);
992 /* my kingdom for a way to unselect text in webview */
993 } else {
994 /* found, highlight all */
995 webkit_web_view_unmark_text_matches(t->wv);
996 webkit_web_view_mark_text_matches(t->wv, &c[1], FALSE, 0);
997 webkit_web_view_set_highlight_text_matches(t->wv, TRUE);
998 gdk_color_parse("white", &color);
999 gtk_widget_modify_base(t->cmd, GTK_STATE_NORMAL, &color);
1000 }
1001 done:
1002 return (XT_CB_PASSTHROUGH);
1003 }
1004
1005 int
1006 cmd_keypress_cb(GtkEntry *w, GdkEventKey *e, struct tab *t)
1007 {
1008 int rv = XT_CB_HANDLED;
1009 const gchar *c = gtk_entry_get_text(w);
1010
1011 if (t == NULL)
1012 errx(1, "cmd_keypress_cb");
1013
1014 DNPRINTF(XT_D_CMD, "cmd_keypress_cb: keyval 0x%x mask 0x%x t %p\n",
1015 e->keyval, e->state, t);
1016
1017 /* sanity */
1018 if (c == NULL)
1019 e->keyval = GDK_Escape;
1020 else if (!(c[0] == ':' || c[0] == '/'))
1021 e->keyval = GDK_Escape;
1022
1023 switch (e->keyval) {
1024 case GDK_BackSpace:
1025 if (!(!strcmp(c, ":") || !strcmp(c, "/")))
1026 break;
1027 /* FALLTHROUGH */
1028 case GDK_Escape:
1029 gtk_widget_hide(t->cmd);
1030 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
1031 goto done;
1032 }
1033
1034 rv = XT_CB_PASSTHROUGH;
1035 done:
1036 return (rv);
1037 }
1038
1039 int
1040 cmd_focusout_cb(GtkWidget *w, GdkEventFocus *e, struct tab *t)
1041 {
1042 if (t == NULL)
1043 errx(1, "cmd_focusout_cb");
1044
1045 DNPRINTF(XT_D_CMD, "cmd_focusout_cb: tab %d focus_wv %d\n",
1046 t->tab_id, t->focus_wv);
1047
1048 /* abort command when losing focus */
1049 gtk_widget_hide(t->cmd);
1050 if (t->focus_wv)
1051 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
1052 else
1053 gtk_widget_grab_focus(GTK_WIDGET(t->uri_entry));
1054
1055 return (XT_CB_PASSTHROUGH);
1056 }
1057
1058 void
1059 cmd_activate_cb(GtkEntry *entry, struct tab *t)
1060 {
1061 int i;
1062 char *s;
1063 const gchar *c = gtk_entry_get_text(entry);
1064
1065 if (t == NULL)
1066 errx(1, "cmd_activate_cb");
1067
1068 DNPRINTF(XT_D_CMD, "cmd_activate_cb: tab %d %s\n", t->tab_id, c);
1069
1070 /* sanity */
1071 if (c == NULL)
1072 goto done;
1073 else if (!(c[0] == ':' || c[0] == '/'))
1074 goto done;
1075 if (strlen(c) < 2)
1076 goto done;
1077 s = (char *)&c[1];
1078
1079 if (c[0] == '/') {
1080 if (t->search_text) {
1081 free(t->search_text);
1082 t->search_text = NULL;
1083 }
1084
1085 t->search_text = strdup(s);
1086 if (t->search_text == NULL)
1087 err(1, "search_text");
1088
1089 goto done;
1090 }
1091
1092 for (i = 0; i < LENGTH(cmds); i++)
1093 if (cmds[i].params) {
1094 if (!strncmp(s, cmds[i].cmd, strlen(cmds[i].cmd))) {
1095 cmds[i].arg.s = strdup(s);
1096 cmds[i].func(t, &cmds[i].arg);
1097 }
1098 } else {
1099 if (!strcmp(s, cmds[i].cmd))
1100 cmds[i].func(t, &cmds[i].arg);
1101 }
1102
1103 done:
1104 gtk_widget_hide(t->cmd);
1105 }
1106
1107 void
1108 backward_cb(GtkWidget *w, struct tab *t)
1109 {
1110 if (t == NULL)
1111 errx(1, "backward_cb");
1112
1113 DNPRINTF(XT_D_NAV, "backward_cb: tab %d\n", t->tab_id);
1114
1115 webkit_web_view_go_back(t->wv);
1116 }
1117
1118 void
1119 forward_cb(GtkWidget *w, struct tab *t)
1120 {
1121 if (t == NULL)
1122 errx(1, "forward_cb");
1123
1124 DNPRINTF(XT_D_NAV, "forward_cb: tab %d\n", t->tab_id);
1125
1126 webkit_web_view_go_forward(t->wv);
1127 }
1128
1129 void
1130 stop_cb(GtkWidget *w, struct tab *t)
1131 {
1132 WebKitWebFrame *frame;
1133
1134 if (t == NULL)
1135 errx(1, "stop_cb");
1136
1137 DNPRINTF(XT_D_NAV, "stop_cb: tab %d\n", t->tab_id);
1138
1139 frame = webkit_web_view_get_main_frame(t->wv);
1140 if (frame == NULL) {
1141 warnx("stop_cb: no frame");
1142 return;
1143 }
1144
1145 webkit_web_frame_stop_loading(frame);
1146 }
1147
1148 GtkWidget *
1149 create_browser(struct tab *t)
1150 {
1151 GtkWidget *w;
1152
1153 if (t == NULL)
1154 errx(1, "create_browser");
1155
1156 t->sb_h = GTK_SCROLLBAR(gtk_hscrollbar_new(NULL));
1157 t->sb_v = GTK_SCROLLBAR(gtk_vscrollbar_new(NULL));
1158 t->adjust_h = gtk_range_get_adjustment(GTK_RANGE(t->sb_h));
1159 t->adjust_v = gtk_range_get_adjustment(GTK_RANGE(t->sb_v));
1160
1161 w = gtk_scrolled_window_new(t->adjust_h, t->adjust_v);
1162 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w),
1163 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1164
1165 t->wv = WEBKIT_WEB_VIEW(webkit_web_view_new());
1166 gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(t->wv));
1167
1168 g_signal_connect(t->wv, "notify::load-status",
1169 G_CALLBACK(notify_load_status_cb), t);
1170
1171 return (w);
1172 }
1173
1174 GtkWidget *
1175 create_window(void)
1176 {
1177 GtkWidget *w;
1178
1179 w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1180 gtk_window_set_default_size(GTK_WINDOW(w), 800, 600);
1181 gtk_widget_set_name(w, "xxxterm");
1182 gtk_window_set_wmclass(GTK_WINDOW(w), "xxxterm", "XXXTerm");
1183
1184 return (w);
1185 }
1186
1187 GtkWidget *
1188 create_toolbar(struct tab *t)
1189 {
1190 GtkWidget *toolbar = gtk_toolbar_new();
1191 GtkToolItem *i;
1192
1193 #if GTK_CHECK_VERSION(2,15,0)
1194 gtk_orientable_set_orientation(GTK_ORIENTABLE(toolbar),
1195 GTK_ORIENTATION_HORIZONTAL);
1196 #else
1197 gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar),
1198 GTK_ORIENTATION_HORIZONTAL);
1199 #endif
1200 gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH_HORIZ);
1201
1202 if (fancy_bar) {
1203 /* backward button */
1204 t->backward = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
1205 gtk_widget_set_sensitive(GTK_WIDGET(t->backward), FALSE);
1206 g_signal_connect(G_OBJECT(t->backward), "clicked",
1207 G_CALLBACK(backward_cb), t);
1208 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), t->backward, -1);
1209
1210 /* forward button */
1211 t->forward =
1212 gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
1213 gtk_widget_set_sensitive(GTK_WIDGET(t->forward), FALSE);
1214 g_signal_connect(G_OBJECT(t->forward), "clicked",
1215 G_CALLBACK(forward_cb), t);
1216 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), t->forward, -1);
1217
1218 /* stop button */
1219 t->stop = gtk_tool_button_new_from_stock(GTK_STOCK_STOP);
1220 gtk_widget_set_sensitive(GTK_WIDGET(t->stop), FALSE);
1221 g_signal_connect(G_OBJECT(t->stop), "clicked",
1222 G_CALLBACK(stop_cb), t);
1223 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), t->stop, -1);
1224 }
1225
1226 /* uri entry */
1227 i = gtk_tool_item_new();
1228 gtk_tool_item_set_expand(i, TRUE);
1229 t->uri_entry = gtk_entry_new();
1230 gtk_container_add(GTK_CONTAINER(i), t->uri_entry);
1231 g_signal_connect(G_OBJECT(t->uri_entry), "activate",
1232 G_CALLBACK(activate_uri_entry_cb), t);
1233 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), i, -1);
1234
1235 /* search entry */
1236 if (fancy_bar && search_string) {
1237 i = gtk_tool_item_new();
1238 t->search_entry = gtk_entry_new();
1239 gtk_entry_set_width_chars(GTK_ENTRY(t->search_entry), 30);
1240 gtk_container_add(GTK_CONTAINER(i), t->search_entry);
1241 g_signal_connect(G_OBJECT(t->search_entry), "activate",
1242 G_CALLBACK(activate_search_entry_cb), t);
1243 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), i, -1);
1244 }
1245
1246 return (toolbar);
1247 }
1248
1249 void
1250 delete_tab(struct tab *t)
1251 {
1252 DNPRINTF(XT_D_TAB, "delete_tab: %p\n", t);
1253
1254 if (t == NULL)
1255 return;
1256
1257 TAILQ_REMOVE(&tabs, t, entry);
1258 if (TAILQ_EMPTY(&tabs))
1259 create_new_tab(NULL, 1);
1260
1261 gtk_widget_destroy(t->vbox);
1262 g_free(t);
1263 }
1264
1265 void
1266 setup_webkit(struct tab *t)
1267 {
1268 gchar *strval;
1269 gchar *ua;
1270
1271 /* XXX this can't be called over and over; fix it */
1272 t->settings = webkit_web_settings_new();
1273 g_object_get((GObject *)t->settings, "user-agent", &strval, NULL);
1274 if (strval == NULL) {
1275 warnx("setup_webkit: can't get user-agent property");
1276 return;
1277 }
1278
1279 if (asprintf(&ua, "%s %s+", strval, version) == -1)
1280 err(1, "aprintf user-agent");
1281
1282 g_object_set((GObject *)t->settings,
1283 "user-agent", ua, NULL);
1284 g_object_set((GObject *)t->settings,
1285 "enable-scripts", enable_scripts, NULL);
1286 g_object_set((GObject *)t->settings,
1287 "enable-plugins", enable_plugins, NULL);
1288 g_object_set((GObject *)t->settings,
1289 "default-font-size", default_font_size, NULL);
1290
1291 webkit_web_view_set_settings(t->wv, t->settings);
1292
1293 g_free (strval);
1294 free(ua);
1295 }
1296
1297 void
1298 create_new_tab(char *title, int focus)
1299 {
1300 struct tab *t;
1301 int load = 1;
1302 char *newuri = NULL;
1303
1304 DNPRINTF(XT_D_TAB, "create_new_tab: title %s focus %d\n", title, focus);
1305
1306 if (tabless && !TAILQ_EMPTY(&tabs)) {
1307 DNPRINTF(XT_D_TAB, "create_new_tab: new tab rejected\n");
1308 return;
1309 }
1310
1311 t = g_malloc0(sizeof *t);
1312 TAILQ_INSERT_TAIL(&tabs, t, entry);
1313
1314 if (title == NULL) {
1315 title = "(untitled)";
1316 load = 0;
1317 } else {
1318 if (valid_url_type(title)) {
1319 newuri = guess_url_type(title);
1320 title = newuri;
1321 }
1322 }
1323
1324 t->vbox = gtk_vbox_new(FALSE, 0);
1325
1326 /* label for tab */
1327 t->label = gtk_label_new(title);
1328 gtk_widget_set_size_request(t->label, 100, -1);
1329
1330 /* toolbar */
1331 t->toolbar = create_toolbar(t);
1332 gtk_box_pack_start(GTK_BOX(t->vbox), t->toolbar, FALSE, FALSE, 0);
1333
1334 /* browser */
1335 t->browser_win = create_browser(t);
1336 gtk_box_pack_start(GTK_BOX(t->vbox), t->browser_win, TRUE, TRUE, 0);
1337 setup_webkit(t);
1338
1339 /* command entry */
1340 t->cmd = gtk_entry_new();
1341 gtk_entry_set_inner_border(GTK_ENTRY(t->cmd), NULL);
1342 gtk_entry_set_has_frame(GTK_ENTRY(t->cmd), FALSE);
1343 gtk_box_pack_end(GTK_BOX(t->vbox), t->cmd, FALSE, FALSE, 0);
1344
1345 /* and show it all */
1346 gtk_widget_show_all(t->vbox);
1347 t->tab_id = gtk_notebook_append_page(notebook, t->vbox,
1348 t->label);
1349
1350 g_object_connect((GObject*)t->cmd,
1351 "signal::key-press-event", (GCallback)cmd_keypress_cb, t,
1352 "signal::key-release-event", (GCallback)cmd_keyrelease_cb, t,
1353 "signal::focus-out-event", (GCallback)cmd_focusout_cb, t,
1354 "signal::activate", (GCallback)cmd_activate_cb, t,
1355 NULL);
1356
1357 g_object_connect((GObject*)t->wv,
1358 "signal-after::key-press-event", (GCallback)webview_keypress_cb, t,
1359 /* "signal::hovering-over-link", (GCallback)webview_hover_cb, t, */
1360 "signal::download-requested", (GCallback)webview_download_cb, t,
1361 "signal::mime-type-policy-decision-requested", (GCallback)webview_mimetype_cb, t,
1362 "signal::navigation-policy-decision-requested", (GCallback)webview_npd_cb, t,
1363 "signal::event", (GCallback)webview_event_cb, t,
1364 NULL);
1365
1366 /* hijack the unused keys as if we were the browser */
1367 g_object_connect((GObject*)t->toolbar,
1368 "signal-after::key-press-event", (GCallback)webview_keypress_cb, t,
1369 NULL);
1370
1371 g_signal_connect(G_OBJECT(t->uri_entry), "focus",
1372 G_CALLBACK(focus_uri_entry_cb), t);
1373
1374 /* hide stuff */
1375 gtk_widget_hide(t->cmd);
1376 if (showurl == 0)
1377 gtk_widget_hide(t->toolbar);
1378
1379 if (focus) {
1380 gtk_notebook_set_current_page(notebook, t->tab_id);
1381 DNPRINTF(XT_D_TAB, "create_new_tab: going to tab: %d\n",
1382 t->tab_id);
1383 }
1384
1385 if (load)
1386 webkit_web_view_load_uri(t->wv, title);
1387 else
1388 gtk_widget_grab_focus(GTK_WIDGET(t->uri_entry));
1389
1390 if (newuri)
1391 free(newuri);
1392 }
1393
1394 void
1395 notebook_switchpage_cb(GtkNotebook *nb, GtkNotebookPage *nbp, guint pn,
1396 gpointer *udata)
1397 {
1398 struct tab *t;
1399
1400 DNPRINTF(XT_D_TAB, "notebook_switchpage_cb: tab: %d\n", pn);
1401
1402 TAILQ_FOREACH(t, &tabs, entry) {
1403 if (t->tab_id == pn) {
1404 DNPRINTF(XT_D_TAB, "notebook_switchpage_cb: going to "
1405 "%d\n", pn);
1406 gtk_widget_hide(t->cmd);
1407 }
1408 }
1409 }
1410
1411 void
1412 create_canvas(void)
1413 {
1414 GtkWidget *vbox;
1415
1416 vbox = gtk_vbox_new(FALSE, 0);
1417 notebook = GTK_NOTEBOOK(gtk_notebook_new());
1418 if (showtabs == 0)
1419 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
1420 gtk_notebook_set_scrollable(notebook, TRUE);
1421
1422 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(notebook), TRUE, TRUE, 0);
1423
1424 g_object_connect((GObject*)notebook,
1425 "signal::switch-page", (GCallback)notebook_switchpage_cb, NULL,
1426 NULL);
1427
1428 main_window = create_window();
1429 gtk_container_add(GTK_CONTAINER(main_window), vbox);
1430 gtk_widget_show_all(main_window);
1431 }
1432
1433 void
1434 setup_cookies(void)
1435 {
1436 if (cookiejar) {
1437 soup_session_remove_feature(session,
1438 (SoupSessionFeature*)cookiejar);
1439 g_object_unref(cookiejar);
1440 cookiejar = NULL;
1441 }
1442
1443 if (cookies_enabled == 0)
1444 return;
1445
1446 cookiejar = soup_cookie_jar_text_new(cookie_file, read_only_cookies);
1447 soup_session_add_feature(session, (SoupSessionFeature*)cookiejar);
1448 }
1449
1450 void
1451 setup_proxy(char *uri)
1452 {
1453 if (proxy_uri) {
1454 g_object_set(session, "proxy_uri", NULL, NULL);
1455 soup_uri_free(proxy_uri);
1456 proxy_uri = NULL;
1457 }
1458 if (http_proxy) {
1459 free(http_proxy);
1460 http_proxy = strdup(uri);
1461 if (http_proxy == NULL)
1462 err(1, "http_proxy");
1463 }
1464
1465 if (uri == NULL)
1466 return;
1467
1468 DNPRINTF(XT_D_CONFIG, "setup_proxy: %s\n", uri);
1469 proxy_uri = soup_uri_new(uri);
1470 if (proxy_uri)
1471 g_object_set(session, "proxy-uri", proxy_uri, NULL);
1472 }
1473
1474 void
1475 usage(void)
1476 {
1477 fprintf(stderr,
1478 "%s [-STVt][-f file] url ...\n", __progname);
1479 exit(0);
1480 }
1481
1482 int
1483 main(int argc, char *argv[])
1484 {
1485 struct stat sb;
1486 int c, focus = 1;
1487 char conf[PATH_MAX] = { '\0' };
1488 char *env_proxy = NULL;
1489
1490 while ((c = getopt(argc, argv, "STVf:t")) != -1) {
1491 switch (c) {
1492 case 'S':
1493 showurl = 0;
1494 break;
1495 case 'T':
1496 showtabs = 0;
1497 break;
1498 case 'V':
1499 errx(0 , "Version: %s", version);
1500 break;
1501 case 'f':
1502 strlcpy(conf, optarg, sizeof(conf));
1503 break;
1504 case 't':
1505 tabless = 1;
1506 break;
1507 default:
1508 usage();
1509 /* NOTREACHED */
1510 }
1511 }
1512 argc -= optind;
1513 argv += optind;
1514
1515 TAILQ_INIT(&tabs);
1516
1517 /* prepare gtk */
1518 gtk_init(&argc, &argv);
1519 if (!g_thread_supported())
1520 g_thread_init(NULL);
1521
1522 pwd = getpwuid(getuid());
1523 if (pwd == NULL)
1524 errx(1, "invalid user %d", getuid());
1525
1526 /* set download dir */
1527 strlcpy(download_dir, pwd->pw_dir, sizeof download_dir);
1528
1529 /* read config file */
1530 if (strlen(conf) == 0)
1531 snprintf(conf, sizeof conf, "%s/.%s",
1532 pwd->pw_dir, XT_CONF_FILE);
1533 config_parse(conf);
1534
1535 if (stat(download_dir, &sb))
1536 errx(1, "must specify a valid download_dir");
1537
1538 /* working directory */
1539 snprintf(work_dir, sizeof work_dir, "%s/%s", pwd->pw_dir, XT_DIR);
1540 if (stat(work_dir, &sb)) {
1541 if (mkdir(work_dir, S_IRWXU) == -1)
1542 err(1, "mkdir");
1543 } else if (((sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO))) != S_IRWXU) {
1544 warnx("fixing invalid permissions on %s", work_dir);
1545 if (chmod(work_dir, S_IRWXU) == -1)
1546 err(1, "chmod");
1547 }
1548
1549 /* cookies */
1550 session = webkit_get_default_session();
1551 snprintf(cookie_file, sizeof cookie_file, "%s/cookies.txt", work_dir);
1552 setup_cookies();
1553
1554 /* proxy */
1555 env_proxy = getenv("http_proxy");
1556 if (env_proxy) {
1557 http_proxy = strdup(env_proxy);
1558 if (http_proxy == NULL)
1559 err(1, "http_proxy");
1560 }
1561 setup_proxy(http_proxy);
1562
1563 create_canvas();
1564
1565 while (argc) {
1566 create_new_tab(argv[0], focus);
1567 focus = 0;
1568
1569 argc--;
1570 argv++;
1571 }
1572 if (focus == 1)
1573 create_new_tab(home, 1);
1574
1575 gtk_main();
1576
1577 return (0);
1578 }
XXXTerm