?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
762: Instead of setting a bare pointer for task.target.frame always
[elinks.git] / src / viewer / text / link.c
bloba9021b0fdc90ea33286b8dbf150793a86fe9ebff
1 /* Links viewing/manipulation handling */
2
3 #ifdef HAVE_CONFIG_H
4 #include "config.h"
5 #endif
6
7 #include <stdlib.h>
8 #include <string.h>
9
10 #include "elinks.h"
11
12 #include "bfu/listmenu.h"
13 #include "bfu/menu.h"
14 #include "bfu/style.h"
15 #include "dialogs/menu.h"
16 #include "dialogs/status.h"
17 #include "document/document.h"
18 #include "document/forms.h"
19 #include "document/options.h"
20 #include "document/view.h"
21 #include "ecmascript/ecmascript.h"
22 #include "intl/gettext/libintl.h"
23 #include "main/object.h"
24 #include "protocol/uri.h"
25 #include "session/session.h"
26 #include "session/task.h"
27 #include "terminal/color.h"
28 #include "terminal/draw.h"
29 #include "terminal/kbd.h"
30 #include "terminal/screen.h"
31 #include "terminal/tab.h"
32 #include "terminal/terminal.h"
33 #include "util/box.h"
34 #include "util/conv.h"
35 #include "util/error.h"
36 #include "util/memory.h"
37 #include "util/string.h"
38 #include "viewer/action.h"
39 #include "viewer/text/form.h"
40 #include "viewer/text/link.h"
41 #include "viewer/text/search.h"
42 #include "viewer/text/textarea.h"
43 #include "viewer/text/view.h"
44 #include "viewer/text/vs.h"
45
46
47 /* Perhaps some of these would be more fun to have in viewer/common/, dunno.
48 * --pasky */
49
50
51 static int
52 current_link_evhook(struct document_view *doc_view, enum script_event_hook_type type)
53 {
54 #ifdef CONFIG_ECMASCRIPT
55 struct link *link;
56 struct script_event_hook *evhook;
57
58 assert(doc_view && doc_view->vs);
59 link = get_current_link(doc_view);
60 if (!link) return -1;
61 if (!link->event_hooks) return -1;
62
63 if (!doc_view->vs->ecmascript) return -1;
64
65 foreach (evhook, *link->event_hooks) {
66 unsigned char *ret;
67
68 if (evhook->type != type) continue;
69 ret = evhook->src;
70 while ((ret = strstr(ret, "return ")))
71 while (*ret != ' ') *ret++ = ' ';
72 {
73 struct string src = INIT_STRING(evhook->src, strlen(evhook->src));
74 /* TODO: Some even handlers return a bool. */
75 if (!ecmascript_eval_boolback(doc_view->vs->ecmascript, &src))
76 return 0;
77 }
78 }
79
80 return 1;
81 #else
82 return -1;
83 #endif
84 }
85
86 #define current_link_hover(dv) \
87 do { \
88 current_link_evhook(dv, SEVHOOK_ONMOUSEOVER); \
89 current_link_evhook(dv, SEVHOOK_ONHOVER); \
90 current_link_evhook(dv, SEVHOOK_ONFOCUS); \
91 } while (0)
92 #define current_link_blur(dv) \
93 do { \
94 current_link_evhook(dv, SEVHOOK_ONMOUSEOUT); \
95 current_link_evhook(dv, SEVHOOK_ONBLUR); \
96 } while (0)
97
98
99 void
100 set_link(struct document_view *doc_view)
101 {
102 assert(doc_view);
103 if_assert_failed return;
104
105 if (current_link_is_visible(doc_view)) return;
106
107 find_link_page_down(doc_view);
108 }
109
110 static inline int
111 get_link_cursor_offset(struct document_view *doc_view, struct link *link)
112 {
113 struct form_control *fc;
114 struct form_state *fs;
115 #ifdef CONFIG_UTF8
116 /* The encoding of form fields depends on the terminal,
117 * rather than on the document. */
118 int utf8 = doc_view->session->tab->term->utf8_cp;
119 #endif /* CONFIG_UTF8 */
120
121 switch (link->type) {
122 case LINK_CHECKBOX:
123 return 1;
124
125 case LINK_BUTTON:
126 return 2;
127
128 case LINK_FIELD:
129 fc = get_link_form_control(link);
130 fs = find_form_state(doc_view, fc);
131 if (!fs || !fs->value)
132 return 0;
133 #ifdef CONFIG_UTF8
134 else if (utf8) {
135 unsigned char *scroll = fs->value + fs->vpos;
136 unsigned char *point = fs->value + fs->state;
137
138 if (fs->type == FC_PASSWORD)
139 return utf8_ptr2chars(scroll, point);
140 else
141 return utf8_ptr2cells(scroll, point);
142 }
143 #endif /* CONFIG_UTF8 */
144 else
145 return fs->state - fs->vpos;
146
147 case LINK_AREA:
148 fc = get_link_form_control(link);
149 fs = find_form_state(doc_view, fc);
150 #ifdef CONFIG_UTF8
151 return fs ? area_cursor(fc, fs, utf8) : 0;
152 #else
153 return fs ? area_cursor(fc, fs) : 0;
154 #endif /* CONFIG_UTF8 */
155
156 case LINK_HYPERTEXT:
157 case LINK_MAP:
158 case LINK_SELECT:
159 return 0;
160 }
161
162 return 0;
163 }
164
165 /** Initialise a static template character with the colour and attributes
166 * appropriate for an active link and return that character. */
167 static inline struct screen_char *
168 init_link_drawing(struct document_view *doc_view, struct link *link, int invert)
169 {
170 struct document_options *doc_opts;
171 static struct screen_char template;
172 enum color_flags color_flags;
173 enum color_mode color_mode;
174 struct color_pair colors;
175
176 template.attr = SCREEN_ATTR_STANDOUT;
177
178 doc_opts = &doc_view->document->options;
179
180 color_flags = (doc_opts->color_flags | COLOR_DECREASE_LIGHTNESS);
181 color_mode = doc_opts->color_mode;
182
183 if (doc_opts->active_link.underline)
184 template.attr |= SCREEN_ATTR_UNDERLINE;
185
186 if (doc_opts->active_link.bold)
187 template.attr |= SCREEN_ATTR_BOLD;
188
189 if (doc_opts->active_link.enable_color) {
190 colors.foreground = doc_opts->active_link.color.foreground;
191 colors.background = doc_opts->active_link.color.background;
192 } else {
193 colors.foreground = link->color.foreground;
194 colors.background = link->color.background;
195 }
196
197 if (invert && doc_opts->active_link.invert) {
198 swap_values(color_T, colors.foreground, colors.background);
199
200 /* Highlight text-input form-fields correctly if contrast
201 * correction is needed. */
202 if (link_is_textinput(link)) {
203 /* Make sure to use the options belonging to the
204 * current document when checking for fg and bg color
205 * usage. */
206 doc_opts = &doc_view->document->options;
207
208 /* Are we fallen angels who didn't want to believe that
209 * nothing /is/ nothing and so were born to lose our
210 * loved ones and dear friends one by one and finally
211 * our own life, to see it proved? --Kerouac */
212
213 /* Wipe out all default correction for 16 color mode */
214 color_flags = (color_flags & ~COLOR_INCREASE_CONTRAST);
215 /* Make contrast correction invert things properly */
216 color_flags |= COLOR_ENSURE_INVERTED_CONTRAST;
217 }
218 }
219
220 set_term_color(&template, &colors, color_flags, color_mode);
221
222 return &template;
223 }
224
225 /** Give the current link the appropriate colour and attributes. */
226 void
227 draw_current_link(struct session *ses, struct document_view *doc_view)
228 {
229 struct terminal *term = ses->tab->term;
230 struct screen_char *template;
231 struct link *link;
232 int cursor_offset;
233 int xpos, ypos;
234 int i;
235
236 assert(term && doc_view && doc_view->vs);
237 if_assert_failed return;
238
239 assert(ses->tab == get_current_tab(term));
240 if_assert_failed return;
241
242 link = get_current_link(doc_view);
243 if (!link) return;
244
245 i = !link_is_textinput(link) || ses->insert_mode == INSERT_MODE_OFF;
246 template = init_link_drawing(doc_view, link, i);
247 if (!template) return;
248
249 xpos = doc_view->box.x - doc_view->vs->x;
250 ypos = doc_view->box.y - doc_view->vs->y;
251
252 if (ses->insert_mode == INSERT_MODE_OFF
253 && ses->navigate_mode == NAVIGATE_CURSOR_ROUTING) {
254 /* If we are navigating using cursor routing and not editing a
255 * text-input form-field never set the cursor. */
256 cursor_offset = -1;
257 } else {
258 cursor_offset = get_link_cursor_offset(doc_view, link);
259 }
260
261 for (i = 0; i < link->npoints; i++) {
262 int x = link->points[i].x + xpos;
263 int y = link->points[i].y + ypos;
264 struct screen_char *co;
265
266 if (!is_in_box(&doc_view->box, x, y)) {
267 continue;
268 }
269
270 co = get_char(term, x, y);
271
272 if (i == cursor_offset) {
273 int blockable = (!link_is_textinput(link)
274 && co->color != template->color);
275
276 set_cursor(term, x, y, blockable);
277 set_window_ptr(ses->tab, x, y);
278 }
279
280 template->data = co->data;
281 copy_screen_chars(co, template, 1);
282 set_screen_dirty(term->screen, y, y);
283 }
284
285 doc_view->vs->old_current_link = doc_view->vs->current_link;
286 }
287
288 static void
289 draw_link(struct terminal *term, struct document_view *doc_view,
290 struct link *link)
291 {
292 int xpos = doc_view->box.x - doc_view->vs->x;
293 int ypos = doc_view->box.y - doc_view->vs->y;
294 int i;
295
296 for (i = 0; i < link->npoints; ++i) {
297 int x = link->points[i].x;
298 int y = link->points[i].y;
299
300 if (is_in_box(&doc_view->box, x + xpos, y + ypos)){
301 struct screen_char *ch;
302
303 ch = get_char(term, x + xpos, y + ypos);
304 copy_struct(ch, &doc_view->document->data[y].chars[x]);
305 set_screen_dirty(term->screen, y + ypos, y + ypos);
306 }
307 }
308 }
309
310 /** Restore the colours and attributes that the active link had
311 * before it was selected. */
312 void
313 clear_link(struct terminal *term, struct document_view *doc_view)
314 {
315 struct link *link = get_current_link(doc_view);
316 struct link *last = get_old_current_link(doc_view);
317
318 if (last && last != link) {
319 draw_link(term, doc_view, last);
320 }
321
322 doc_view->vs->old_current_link = doc_view->vs->current_link;
323 }
324
325 void
326 highlight_links_with_prefixes_that_start_with_n(struct terminal *term,
327 struct document_view *doc_view,
328 int n)
329 {
330 struct color_pair *color = get_bfu_color(term, "searched");
331 int xoffset = doc_view->box.x - doc_view->vs->x;
332 int yoffset = doc_view->box.y - doc_view->vs->y;
333 struct document *document = doc_view->document;
334 int m;
335
336 for (m = n + 1; n <= document->nlinks; n *= 10, m *= 10) {
337 int linkn;
338
339 for (linkn = n; linkn < m; ++linkn) {
340 struct link *link = &document->links[linkn - 1];
341 int i;
342
343 if (linkn > document->nlinks) break;
344
345 for (i = 0; i < link->npoints; ++i) {
346 int x = link->points[i].x + xoffset;
347 int y = link->points[i].y + yoffset;
348
349 if (is_in_box(&doc_view->box, x, y))
350 draw_char_color(term, x, y, color);
351 }
352 }
353 }
354 }
355
356 struct link *
357 get_first_link(struct document_view *doc_view)
358 {
359 struct link *link, *undef;
360 struct document *document;
361 int height;
362 int i;
363
364 assert(doc_view && doc_view->document);
365 if_assert_failed return NULL;
366
367 document = doc_view->document;
368
369 if (!document->lines1) return NULL;
370
371 height = doc_view->vs->y + doc_view->box.height;
372 link = undef = document->links + document->nlinks;
373
374 for (i = int_max(0, doc_view->vs->y);
375 i < int_min(height, document->height);
376 i++) {
377 if (document->lines1[i]
378 && document->lines1[i] < link)
379 link = document->lines1[i];
380 }
381
382 return (link == undef) ? NULL : link;
383 }
384
385 struct link *
386 get_last_link(struct document_view *doc_view)
387 {
388 struct link *link = NULL;
389 struct document *document;
390 int height;
391 int i;
392
393 assert(doc_view && doc_view->document);
394 if_assert_failed return NULL;
395
396 document = doc_view->document;
397
398 if (!document->lines2) return NULL;
399
400 height = doc_view->vs->y + doc_view->box.height;
401
402 for (i = int_max(0, doc_view->vs->y);
403 i < int_min(height, document->height);
404 i++)
405 if (document->lines2[i] > link)
406 link = document->lines2[i];
407
408 return link;
409 }
410
411 static int
412 link_in_view_x(struct document_view *doc_view, struct link *link)
413 {
414 int i, dx, width;
415
416 assert(doc_view && link);
417 if_assert_failed return 0;
418
419 dx = doc_view->vs->x;
420 width = doc_view->box.width;
421
422 for (i = 0; i < link->npoints; i++) {
423 int x = link->points[i].x - dx;
424
425 if (x >= 0 && x < width)
426 return 1;
427 }
428
429 return 0;
430 }
431
432 static int
433 link_in_view_y(struct document_view *doc_view, struct link *link)
434 {
435 int i, dy, height;
436
437 assert(doc_view && link);
438 if_assert_failed return 0;
439
440 dy = doc_view->vs->y;
441 height = doc_view->box.height;
442
443 for (i = 0; i < link->npoints; i++) {
444 int y = link->points[i].y - dy;
445
446 if (y >= 0 && y < height)
447 return 1;
448 }
449
450 return 0;
451 }
452
453 static int
454 link_in_view(struct document_view *doc_view, struct link *link)
455 {
456 assert(doc_view && link);
457 if_assert_failed return 0;
458 return link_in_view_y(doc_view, link) && link_in_view_x(doc_view, link);
459 }
460
461 int
462 current_link_is_visible(struct document_view *doc_view)
463 {
464 struct link *link;
465
466 assert(doc_view && doc_view->vs);
467 if_assert_failed return 0;
468
469 link = get_current_link(doc_view);
470 return (link && link_in_view(doc_view, link));
471 }
472
473 /** Look for the first and the last link currently visible in our
474 * viewport. */
475 static void
476 get_visible_links_range(struct document_view *doc_view, int *first, int *last)
477 {
478 struct document *document = doc_view->document;
479 int height = int_min(doc_view->vs->y + doc_view->box.height,
480 document->height);
481 int y;
482
483 *first = document->nlinks - 1;
484 *last = 0;
485
486 for (y = int_max(0, doc_view->vs->y); y < height; y++) {
487 if (document->lines1[y])
488 int_upper_bound(first, document->lines1[y]
489 - document->links);
490
491 if (document->lines2[y])
492 int_lower_bound(last, document->lines2[y]
493 - document->links);
494 }
495 }
496
497 static int
498 next_link_in_view_(struct document_view *doc_view, int current, int direction,
499 int (*fn)(struct document_view *, struct link *),
500 void (*cntr)(struct document_view *, struct link *))
501 {
502 struct document *document;
503 struct view_state *vs;
504 int start, end;
505
506 assert(doc_view && doc_view->document && doc_view->vs && fn);
507 if_assert_failed return 0;
508
509 document = doc_view->document;
510 vs = doc_view->vs;
511
512 get_visible_links_range(doc_view, &start, &end);
513
514 current_link_blur(doc_view);
515
516 /* Go from the @current link in @direction until either
517 * fn() is happy or we would leave the current viewport. */
518 while (current >= start && current <= end) {
519 if (fn(doc_view, &document->links[current])) {
520 vs->current_link = current;
521 if (cntr) cntr(doc_view, &document->links[current]);
522 current_link_hover(doc_view);
523 return 1;
524 }
525 current += direction;
526 }
527
528 vs->current_link = -1;
529 return 0;
530 }
531
532 int
533 next_link_in_view(struct document_view *doc_view, int current, int direction)
534 {
535 return next_link_in_view_(doc_view, current, direction, link_in_view, NULL);
536 }
537
538 int
539 next_link_in_view_y(struct document_view *doc_view, int current, int direction)
540 {
541 return next_link_in_view_(doc_view, current, direction, link_in_view_y, set_pos_x);
542 }
543
544 /** Get the bounding columns of @a link at line @a y (or all lines if
545 * @a y == -1). */
546 void
547 get_link_x_bounds(struct link *link, int y, int *min_x, int *max_x)
548 {
549 int point;
550
551 if (min_x) *min_x = INT_MAX;
552 if (max_x) *max_x = 0;
553
554 for (point = 0; point < link->npoints; point++) {
555 if (y >= 0 && link->points[point].y != y)
556 continue;
557 if (min_x) int_upper_bound(min_x, link->points[point].x);
558 if (max_x) int_lower_bound(max_x, link->points[point].x);
559 }
560 }
561
562 /** Check whether there is any point between @a min_x and @a max_x at
563 * the line @a y in link @a link. */
564 static int
565 get_link_x_intersect(struct link *link, int y, int min_x, int max_x)
566 {
567 int point;
568
569 for (point = 0; point < link->npoints; point++) {
570 if (link->points[point].y != y)
571 continue;
572 if (link->points[point].x >= min_x
573 && link->points[point].x <= max_x)
574 return link->points[point].x + 1;
575 }
576
577 return 0;
578 }
579
580 /** Check whether there is any point between @a min_y and @a max_y in
581 * the column @a x in link @a link. */
582 static int
583 get_link_y_intersect(struct link *link, int x, int min_y, int max_y)
584 {
585 int point;
586
587 for (point = 0; point < link->npoints; point++) {
588 if (link->points[point].x != x)
589 continue;
590 if (link->points[point].y >= min_y
591 && link->points[point].y <= max_y)
592 return link->points[point].y + 1;
593 }
594
595 return 0;
596 }
597
598 int
599 next_link_in_dir(struct document_view *doc_view, int dir_x, int dir_y)
600 {
601 struct document *document;
602 struct view_state *vs;
603 struct link *link;
604 int min_x = INT_MAX, max_x = 0;
605 int min_y, max_y;
606
607 assert(doc_view && doc_view->document && doc_view->vs);
608 if_assert_failed return 0;
609 assert(dir_x || dir_y);
610 if_assert_failed return 0;
611
612 document = doc_view->document;
613 vs = doc_view->vs;
614
615 link = get_current_link(doc_view);
616 if (!link) return 0;
617
618 /* Find the link's "bounding box" coordinates. */
619
620 get_link_x_bounds(link, -1, &min_x, &max_x);
621
622 min_y = link->points[0].y;
623 max_y = link->points[link->npoints - 1].y;
624
625 /* Now go from the bounding box edge in the appropriate
626 * direction and find the nearest link. */
627
628 if (dir_y) {
629 /* Vertical movement */
630
631 /* The current line number */
632 int y = (dir_y > 0 ? max_y : min_y) + dir_y;
633 /* The bounding line numbers */
634 int top = int_max(0, doc_view->vs->y);
635 int bottom = int_min(doc_view->vs->y + doc_view->box.height,
636 document->height);
637
638 for (; dir_y > 0 ? y < bottom : y >= top; y += dir_y) {
639 /* @backup points to the nearest link from the left
640 * to the desired position. */
641 struct link *backup = NULL;
642
643 link = document->lines1[y];
644 if (!link) continue;
645
646 /* Go through all the links on line. */
647 for (; link <= document->lines2[y]; link++) {
648 int l_min_x, l_max_x;
649
650 /* Some links can be totally out of order here,
651 * ie. in tables or when using tabindex. */
652 if (y < link->points[0].y
653 || y > link->points[link->npoints - 1].y)
654 continue;
655
656 get_link_x_bounds(link, y, &l_min_x, &l_max_x);
657 if (l_min_x > max_x) {
658 /* This link is too at the right. */
659 if (!backup)
660 backup = link;
661 continue;
662 }
663 if (l_max_x < min_x) {
664 /* This link is too at the left. */
665 backup = link;
666 continue;
667 }
668 /* This link is aligned with the current one. */
669 goto chose_link;
670 }
671
672 if (backup) {
673 link = backup;
674 goto chose_link;
675 }
676 }
677
678 if (!y || y == document->height) {
679 /* We just stay at the same place, do not invalidate
680 * the link number. */
681 return 0;
682 }
683
684 } else {
685 /* Horizontal movement */
686
687 /* The current column number */
688 int x = (dir_x > 0 ? max_x : min_x) + dir_x;
689 /* How many lines are already past their last link */
690 int last = 0;
691
692 while ((last < max_y - min_y + 1) && (x += dir_x) >= 0) {
693 int y;
694
695 last = 0;
696
697 /* Go through all the lines */
698 for (y = min_y; y <= max_y; y++) {
699 link = document->lines1[y];
700 if (!link) continue;
701
702 /* Go through all the links on line. */
703 while (link <= document->lines2[y]) {
704 if (get_link_y_intersect(link, x,
705 min_y,
706 max_y))
707 goto chose_link;
708 link++;
709 }
710
711 /* Check if we already aren't past the last
712 * link on this line. */
713 if (!get_link_x_intersect(document->lines2[y],
714 y, x, INT_MAX))
715 last++;
716 }
717 }
718
719 /* We just stay */
720 return 0;
721 }
722
723 current_link_blur(doc_view);
724 vs->current_link = -1;
725 return 0;
726
727 chose_link:
728 /* The link is in bounds, take it. */
729 current_link_blur(doc_view);
730 vs->current_link = get_link_index(document, link);
731 set_pos_x(doc_view, link);
732 current_link_hover(doc_view);
733 return 1;
734 }
735
736 void
737 set_pos_x(struct document_view *doc_view, struct link *link)
738 {
739 int xm = 0;
740 int xl = INT_MAX;
741 int i;
742
743 assert(doc_view && link);
744 if_assert_failed return;
745
746 for (i = 0; i < link->npoints; i++) {
747 int y = link->points[i].y - doc_view->vs->y;
748
749 if (y >= 0 && y < doc_view->box.height) {
750 int_lower_bound(&xm, link->points[i].x + 1);
751 int_upper_bound(&xl, link->points[i].x);
752 }
753 }
754
755 if (xl != INT_MAX)
756 int_bounds(&doc_view->vs->x, xm - doc_view->box.width, xl);
757 }
758
759 void
760 set_pos_y(struct document_view *doc_view, struct link *link)
761 {
762 int ym = 0;
763 int height;
764 int i;
765
766 assert(doc_view && doc_view->document && doc_view->vs && link);
767 if_assert_failed return;
768
769 height = doc_view->document->height;
770 for (i = 0; i < link->npoints; i++) {
771 int_lower_bound(&ym, link->points[i].y + 1);
772 int_upper_bound(&height, link->points[i].y);
773 }
774 doc_view->vs->y = (ym + height - doc_view->box.height) / 2;
775 int_bounds(&doc_view->vs->y, 0,
776 doc_view->document->height - doc_view->box.height);
777 }
778
779 /** Focus the next link in the specified direction.
780 * @a direction == 1 -> DOWN;
781 * @a direction == -1 -> UP */
782 static void
783 find_link(struct document_view *doc_view, int direction, int page_mode)
784 {
785 struct link **line;
786 struct link *link = NULL;
787 int link_pos;
788 int y, ymin, ymax;
789
790 assert(doc_view && doc_view->document && doc_view->vs);
791 if_assert_failed return;
792
793 if (direction == -1) {
794 /* UP */
795 line = doc_view->document->lines2;
796 if (!line) goto nolink;
797 y = doc_view->vs->y + doc_view->box.height - 1;
798 int_upper_bound(&y, doc_view->document->height - 1);
799 if (y < 0) goto nolink;
800 } else {
801 /* DOWN */
802 line = doc_view->document->lines1;
803 if (!line) goto nolink;
804 y = doc_view->vs->y;
805 int_lower_bound(&y, 0);
806 if (y >= doc_view->document->height) goto nolink;
807 }
808
809 ymin = int_max(0, doc_view->vs->y);
810 ymax = int_min(doc_view->document->height,
811 doc_view->vs->y + doc_view->box.height);
812
813 if (direction == -1) {
814 /* UP */
815 do {
816 struct link *cur = line[y--];
817
818 if (cur && (!link || cur > link))
819 link = cur;
820 } while (y >= ymin && y < ymax);
821
822 } else {
823 /* DOWN */
824 do {
825 struct link *cur = line[y++];
826
827 if (cur && (!link || cur < link))
828 link = cur;
829 } while (y >= ymin && y < ymax);
830 }
831
832 if (!link) goto nolink;
833
834 link_pos = link - doc_view->document->links;
835 if (page_mode) {
836 /* PAGE */
837 next_link_in_view(doc_view, link_pos, direction);
838 return;
839 }
840 current_link_blur(doc_view);
841 doc_view->vs->current_link = link_pos;
842 set_pos_x(doc_view, link);
843 current_link_hover(doc_view);
844 return;
845
846 nolink:
847 current_link_blur(doc_view);
848 doc_view->vs->current_link = -1;
849 }
850
851 void
852 find_link_up(struct document_view *doc_view)
853 {
854 find_link(doc_view, -1, 0);
855 }
856
857 void
858 find_link_page_up(struct document_view *doc_view)
859 {
860 find_link(doc_view, -1, 1);
861 }
862
863 void
864 find_link_down(struct document_view *doc_view)
865 {
866 find_link(doc_view, 1, 0);
867 }
868
869 void
870 find_link_page_down(struct document_view *doc_view)
871 {
872 find_link(doc_view, 1, 1);
873 }
874
875 struct uri *
876 get_link_uri(struct session *ses, struct document_view *doc_view,
877 struct link *link)
878 {
879 assert(ses && doc_view && link);
880 if_assert_failed return NULL;
881
882 switch (link->type) {
883 case LINK_HYPERTEXT:
884 case LINK_MAP:
885 if (link->where) return get_uri(link->where, 0);
886 return get_uri(link->where_img, 0);
887
888 case LINK_BUTTON:
889 case LINK_FIELD:
890 return get_form_uri(ses, doc_view,
891 get_link_form_control(link));
892
893 default:
894 return NULL;
895 }
896 }
897
898 static int
899 call_onsubmit_and_submit(struct session *ses, struct document_view *doc_view,
900 struct form_control *fc, int do_reload)
901 {
902 struct uri *uri = NULL;
903 enum cache_mode mode = do_reload ? CACHE_MODE_FORCE_RELOAD : CACHE_MODE_NORMAL;
904
905 assert(fc->form); /* regardless of whether there is a FORM element */
906 if_assert_failed return 0;
907
908 #ifdef CONFIG_ECMASCRIPT
909 /* If the form has multiple submit buttons, this does not
910 * explicitly tell the ECMAScript code which of them was
911 * pressed. W3C DOM Level 3 doesn't seem to include such a
912 * feature. */
913 if (fc->type != FC_RESET && fc->form->onsubmit) {
914 struct string code;
915
916 if (init_string(&code)) {
917 struct view_state *vs = doc_view->vs;
918 struct ecmascript_interpreter *interpreter;
919 int res;
920
921 if (vs->ecmascript_fragile)
922 ecmascript_reset_state(vs);
923 interpreter = vs->ecmascript;
924 assert(interpreter);
925
926 add_to_string(&code, fc->form->onsubmit);
927 res = ecmascript_eval_boolback(interpreter, &code);
928 done_string(&code);
929 /* If the user presses Enter in a text field,
930 * and document.browse.forms.auto_submit is
931 * true, and the form has an onsubmit script
932 * that returns false, then insert mode should
933 * end, so return 1 here rather than 0. */
934 if (!res) return 1;
935 }
936 }
937 #endif /* CONFIG_ECMASCRIPT */
938
939 uri = get_form_uri(ses, doc_view, fc);
940 if (!uri) return 0;
941 goto_uri_frame(ses, uri, fc->form->target, mode);
942 done_uri(uri);
943 return 1;
944 }
945
946 struct link *
947 goto_current_link(struct session *ses, struct document_view *doc_view, int do_reload)
948 {
949 struct link *link;
950 struct uri *uri;
951
952 assert(doc_view && ses);
953 if_assert_failed return NULL;
954
955 link = get_current_link(doc_view);
956 if (!link) return NULL;
957
958 if (link_is_form(link)) {
959 struct form_control *fc = link->data.form_control;
960
961 if (fc->type != FC_BUTTON
962 && !call_onsubmit_and_submit(ses, doc_view, fc, do_reload))
963 return NULL;
964 else
965 return link;
966 } else
967 uri = get_link_uri(ses, doc_view, link);
968
969 if (!uri) return NULL;
970
971 if (link->type == LINK_MAP) {
972 /* TODO: Test reload? */
973 goto_imgmap(ses, uri, link->target);
974
975 } else {
976 enum cache_mode mode = do_reload ? CACHE_MODE_FORCE_RELOAD
977 : CACHE_MODE_NORMAL;
978
979 goto_uri_frame(ses, uri, link->target, mode);
980 }
981
982 done_uri(uri);
983 return link;
984 }
985
986 static enum frame_event_status
987 activate_link(struct session *ses, struct document_view *doc_view,
988 struct link *link, int do_reload)
989 {
990 struct form_control *link_fc;
991 struct form_state *fs;
992 struct form *form;
993
994 switch (link->type) {
995 case LINK_HYPERTEXT:
996 case LINK_MAP:
997 case LINK_FIELD:
998 case LINK_AREA:
999 case LINK_BUTTON:
1000 if (goto_current_link(ses, doc_view, do_reload))
1001 return FRAME_EVENT_OK;
1002 break;
1003 case LINK_CHECKBOX:
1004 link_fc = get_link_form_control(link);
1005
1006 if (form_field_is_readonly(link_fc))
1007 return FRAME_EVENT_OK;
1008
1009 fs = find_form_state(doc_view, link_fc);
1010 if (!fs) return FRAME_EVENT_OK;
1011
1012 if (link_fc->type == FC_CHECKBOX) {
1013 fs->state = !fs->state;
1014
1015 return FRAME_EVENT_REFRESH;
1016 }
1017
1018 /* @link_fc->type must be FC_RADIO, then. First turn
1019 * this one on, and then turn off all the other radio
1020 * buttons in the group. Do it in this order because
1021 * further @find_form_state calls may reallocate
1022 * @doc_view->vs->form_info[] and thereby make the @fs
1023 * pointer invalid. This also allows us to re-use
1024 * @fs in the loop. */
1025 fs->state = 1;
1026 foreach (form, doc_view->document->forms) {
1027 struct form_control *fc;
1028
1029 if (form != link_fc->form)
1030 continue;
1031
1032 foreach (fc, form->items) {
1033 if (fc->type == FC_RADIO
1034 && !xstrcmp(fc->name, link_fc->name)
1035 && fc != link_fc) {
1036 fs = find_form_state(doc_view, fc);
1037 if (fs) fs->state = 0;
1038 }
1039 }
1040 }
1041
1042 break;
1043
1044 case LINK_SELECT:
1045 link_fc = get_link_form_control(link);
1046
1047 if (form_field_is_readonly(link_fc))
1048 return FRAME_EVENT_OK;
1049
1050 object_lock(doc_view->document);
1051 add_empty_window(ses->tab->term,
1052 (void (*)(void *)) release_document,
1053 doc_view->document);
1054 do_select_submenu(ses->tab->term, link_fc->menu, ses);
1055
1056 break;
1057
1058 default:
1059 INTERNAL("bad link type %d", link->type);
1060 }
1061
1062 return FRAME_EVENT_REFRESH;
1063 }
1064
1065 enum frame_event_status
1066 enter(struct session *ses, struct document_view *doc_view, int do_reload)
1067 {
1068 struct link *link;
1069
1070 assert(ses && doc_view && doc_view->vs && doc_view->document);
1071 if_assert_failed return FRAME_EVENT_REFRESH;
1072
1073 link = get_current_link(doc_view);
1074 if (!link) return FRAME_EVENT_REFRESH;
1075
1076
1077 if (!current_link_evhook(doc_view, SEVHOOK_ONCLICK))
1078 return FRAME_EVENT_REFRESH;
1079 return activate_link(ses, doc_view, link, do_reload);
1080 }
1081
1082 /** Get the link at the coordinates @a x and @a y, or NULL if none.
1083 * The coordinates are relative to the document view; not to the
1084 * terminal, nor to the document. So (0, 0) means whatever part of
1085 * the document has been scrolled to the top left corner of the
1086 * document view. */
1087 struct link *
1088 get_link_at_coordinates(struct document_view *doc_view, int x, int y)
1089 {
1090 struct link *l1, *l2, *link;
1091 int i, height;
1092
1093 assert(doc_view && doc_view->vs && doc_view->document);
1094 if_assert_failed return NULL;
1095
1096 /* If there are no links in in document, there is nothing to do. */
1097 if (!doc_view->document->nlinks) return NULL;
1098
1099 /* If the coordinates are outside document view, no need to go further. */
1100 if (x < 0 || x >= doc_view->box.width) return NULL;
1101 if (y < 0 || y >= doc_view->box.height) return NULL;
1102
1103 /* FIXME: This doesn't work. --Zas
1104 if (!check_mouse_position(ev, &doc_view->box))
1105 return NULL;
1106 */
1107
1108 /* Find link candidates. */
1109 l1 = doc_view->document->links + doc_view->document->nlinks;
1110 l2 = doc_view->document->links;
1111 height = int_min(doc_view->document->height,
1112 doc_view->vs->y + doc_view->box.height);
1113
1114 for (i = doc_view->vs->y; i < height; i++) {
1115 if (doc_view->document->lines1[i]
1116 && doc_view->document->lines1[i] < l1)
1117 l1 = doc_view->document->lines1[i];
1118
1119 if (doc_view->document->lines2[i]
1120 && doc_view->document->lines2[i] > l2)
1121 l2 = doc_view->document->lines2[i];
1122 }
1123
1124 /* Is there a link at the given coordinates? */
1125 x += doc_view->vs->x;
1126 y += doc_view->vs->y;
1127
1128 for (link = l1; link <= l2; link++) {
1129 for (i = 0; i < link->npoints; i++)
1130 if (link->points[i].x == x
1131 && link->points[i].y == y)
1132 return link;
1133 }
1134
1135 return NULL;
1136 }
1137
1138 /** This is backend of the backend goto_link_number_do() below ;)). */
1139 void
1140 jump_to_link_number(struct session *ses, struct document_view *doc_view, int n)
1141 {
1142 assert(ses && doc_view && doc_view->vs && doc_view->document);
1143 if_assert_failed return;
1144
1145 if (n < 0 || n >= doc_view->document->nlinks) return;
1146 current_link_blur(doc_view);
1147 doc_view->vs->current_link = n;
1148 if (ses->navigate_mode == NAVIGATE_CURSOR_ROUTING) {
1149 struct link *link = get_current_link(doc_view);
1150 int offset = get_link_cursor_offset(doc_view, link);
1151
1152 if (link->npoints > offset) {
1153 int x = link->points[offset].x
1154 + doc_view->box.x - doc_view->vs->x;
1155 int y = link->points[offset].y
1156 + doc_view->box.y - doc_view->vs->y;
1157
1158 move_cursor(ses, doc_view, x, y);
1159 }
1160 }
1161 check_vs(doc_view);
1162 current_link_hover(doc_view);
1163 }
1164
1165 /** This is common backend for goto_link_number() and try_document_key(). */
1166 static void
1167 goto_link_number_do(struct session *ses, struct document_view *doc_view, int n)
1168 {
1169 struct link *link;
1170
1171 assert(ses && doc_view && doc_view->document);
1172 if_assert_failed return;
1173 if (n < 0 || n >= doc_view->document->nlinks) return;
1174 jump_to_link_number(ses, doc_view, n);
1175
1176 link = &doc_view->document->links[n];
1177 if (!link_is_textinput(link)
1178 && get_opt_bool("document.browse.accesskey.auto_follow", ses))
1179 enter(ses, doc_view, 0);
1180 }
1181
1182 void
1183 goto_link_number(struct session *ses, unsigned char *num)
1184 {
1185 struct document_view *doc_view;
1186
1187 assert(ses && num);
1188 if_assert_failed return;
1189 doc_view = current_frame(ses);
1190 assert(doc_view);
1191 if_assert_failed return;
1192 goto_link_number_do(ses, doc_view, atoi(num) - 1);
1193 }
1194
1195 /** See if this document is interested in the key user pressed. */
1196 enum frame_event_status
1197 try_document_key(struct session *ses, struct document_view *doc_view,
1198 struct term_event *ev)
1199 {
1200 unicode_val_T key;
1201 int i; /* GOD I HATE C! --FF */ /* YEAH, BRAINFUCK RULEZ! --pasky */
1202
1203 assert(ses && doc_view && doc_view->document && doc_view->vs && ev);
1204 if_assert_failed return FRAME_EVENT_IGNORED;
1205
1206 if (!check_kbd_modifier(ev, KBD_MOD_ALT)
1207 || !is_kbd_character(get_kbd_key(ev))) {
1208 /* We accept only alt-character combos. */
1209 return FRAME_EVENT_IGNORED;
1210 }
1211
1212 /* The key is a character. Convert it to Unicode so that it
1213 * can be compared with link.accesskey. */
1214 #ifdef CONFIG_UTF8
1215 key = get_kbd_key(ev);
1216 #else /* !CONFIG_UTF8 */
1217 key = cp2u(get_terminal_codepage(ses->tab->term),
1218 get_kbd_key(ev));
1219 #endif /* !CONFIG_UTF8 */
1220 /* If @key now is 0 (which is used in link.accesskey if there
1221 * is no access key) or UCS_REPLACEMENT_CHARACTER, then the
1222 * results may be a little odd, but not really harmful. */
1223
1224 /* Run through all the links and see if one of them is bound to the
1225 * key we test.. */
1226
1227 i = doc_view->vs->current_link + 1;
1228 for (; i < doc_view->document->nlinks; i++) {
1229 struct link *link = &doc_view->document->links[i];
1230
1231 if (key == link->accesskey) {
1232 ses->kbdprefix.repeat_count = 0;
1233 goto_link_number_do(ses, doc_view, i);
1234 return FRAME_EVENT_REFRESH;
1235 }
1236 }
1237 for (i = 0; i <= doc_view->vs->current_link; i++) {
1238 struct link *link = &doc_view->document->links[i];
1239
1240 if (key == link->accesskey) {
1241 ses->kbdprefix.repeat_count = 0;
1242 goto_link_number_do(ses, doc_view, i);
1243 return FRAME_EVENT_REFRESH;
1244 }
1245 }
1246
1247 return FRAME_EVENT_IGNORED;
1248 }
1249
1250 /** Open a contextual menu on a link, form or image element.
1251 * @todo TODO: This should be completely configurable. */
1252 void
1253 link_menu(struct terminal *term, void *xxx, void *ses_)
1254 {
1255 struct session *ses = ses_;
1256 struct document_view *doc_view;
1257 struct link *link;
1258 struct menu_item *mi;
1259 struct form_control *fc;
1260
1261 assert(term && ses);
1262 if_assert_failed return;
1263
1264 doc_view = current_frame(ses);
1265 mi = new_menu(FREE_LIST);
1266 if (!mi) return;
1267 if (!doc_view) goto end;
1268
1269 assert(doc_view->vs && doc_view->document);
1270 if_assert_failed return;
1271
1272 link = get_current_link(doc_view);
1273 if (!link) goto end;
1274
1275 if (link->where && !link_is_form(link)) {
1276 if (link->type == LINK_MAP) {
1277 /* [gettext_accelerator_context(link_menu.map)] */
1278 add_to_menu(&mi, N_("Display ~usemap"), NULL, ACT_MAIN_LINK_FOLLOW,
1279 NULL, NULL, SUBMENU);
1280 /* [gettext_accelerator_context()] */
1281 } else {
1282 /* [gettext_accelerator_context(link_menu.std)] */
1283 add_menu_action(&mi, N_("~Follow link"), ACT_MAIN_LINK_FOLLOW);
1284
1285 add_menu_action(&mi, N_("Follow link and r~eload"), ACT_MAIN_LINK_FOLLOW_RELOAD);
1286
1287 add_menu_action(&mi, N_("~Link info"), ACT_MAIN_LINK_INFO);
1288
1289 add_menu_separator(&mi);
1290
1291 add_new_win_to_menu(&mi, N_("Open in new ~window"), term);
1292
1293 add_menu_action(&mi, N_("Open in new ~tab"), ACT_MAIN_OPEN_LINK_IN_NEW_TAB);
1294
1295 add_menu_action(&mi, N_("Open in new tab in ~background"),
1296 ACT_MAIN_OPEN_LINK_IN_NEW_TAB_IN_BACKGROUND);
1297
1298 if (!get_cmd_opt_bool("anonymous")) {
1299 add_menu_separator(&mi);
1300 add_menu_action(&mi, N_("~Download link"), ACT_MAIN_LINK_DOWNLOAD);
1301
1302 #ifdef CONFIG_BOOKMARKS
1303 add_menu_action(&mi, N_("~Add link to bookmarks"),
1304 ACT_MAIN_ADD_BOOKMARK_LINK);
1305 #endif
1306 add_uri_command_to_menu(&mi, PASS_URI_LINK,
1307 N_("Pass link URI to e~xternal command"));
1308 }
1309 /* [gettext_accelerator_context()] */
1310 }
1311 }
1312
1313 fc = get_link_form_control(link);
1314 if (fc) {
1315 switch (fc->type) {
1316 case FC_RESET:
1317 /* [gettext_accelerator_context(link_menu.reset)] */
1318 add_menu_action(&mi, N_("~Reset form"), ACT_MAIN_RESET_FORM);
1319 /* [gettext_accelerator_context()] */
1320 break;
1321
1322 case FC_TEXTAREA:
1323 /* [gettext_accelerator_context(link_menu.textarea)] */
1324 if (!form_field_is_readonly(fc)) {
1325 struct string keystroke;
1326
1327 if (init_string(&keystroke))
1328 add_keystroke_action_to_string(
1329 &keystroke,
1330 ACT_EDIT_OPEN_EXTERNAL,
1331 KEYMAP_EDIT);
1332
1333 add_to_menu(&mi, N_("Open in ~external editor"),
1334 keystroke.source, ACT_MAIN_NONE,
1335 menu_textarea_edit, NULL, FREE_RTEXT);
1336 }
1337 /* [gettext_accelerator_context()] */
1338 /* Fall through */
1339 default:
1340 /* [gettext_accelerator_context(link_menu.textarea, link_menu.form)] */
1341 add_menu_action(&mi, N_("~Submit form"), ACT_MAIN_SUBMIT_FORM);
1342 add_menu_action(&mi, N_("Submit form and rel~oad"), ACT_MAIN_SUBMIT_FORM_RELOAD);
1343
1344 assert(fc->form);
1345 if (fc->form->method == FORM_METHOD_GET) {
1346 add_new_win_to_menu(&mi, N_("Submit form and open in new ~window"), term);
1347
1348 add_menu_action(&mi, N_("Submit form and open in new ~tab"),
1349 ACT_MAIN_OPEN_LINK_IN_NEW_TAB);
1350
1351 add_menu_action(&mi, N_("Submit form and open in new tab in ~background"),
1352 ACT_MAIN_OPEN_LINK_IN_NEW_TAB_IN_BACKGROUND);
1353 }
1354
1355 if (!get_cmd_opt_bool("anonymous"))
1356 add_menu_action(&mi, N_("Submit form and ~download"), ACT_MAIN_LINK_DOWNLOAD);
1357
1358 add_menu_action(&mi, N_("~Reset form"), ACT_MAIN_RESET_FORM);
1359 /* [gettext_accelerator_context()] */
1360 }
1361
1362 /* [gettext_accelerator_context(link_menu.reset, link_menu.textarea, link_menu.form)] */
1363 add_to_menu(&mi, N_("Form f~ields"), NULL, ACT_MAIN_LINK_FORM_MENU,
1364 NULL, NULL, SUBMENU);
1365 /* [gettext_accelerator_context()] */
1366 }
1367
1368 if (link->where_img) {
1369 /* [gettext_accelerator_context(link_menu.map, link_menu.std, link_menu.form)] */
1370 add_menu_action(&mi, N_("V~iew image"), ACT_MAIN_VIEW_IMAGE);
1371 if (!get_cmd_opt_bool("anonymous"))
1372 add_menu_action(&mi, N_("Download ima~ge"), ACT_MAIN_LINK_DOWNLOAD_IMAGE);
1373 /* [gettext_accelerator_context()] */
1374 }
1375
1376 /** @todo TODO: Make it possible to trigger any script event
1377 * hooks associated to the link. --pasky */
1378
1379 end:
1380 if (!mi->text) {
1381 add_to_menu(&mi, N_("No link selected"), NULL, ACT_MAIN_NONE,
1382 NULL, NULL, NO_SELECT);
1383 }
1384
1385 do_menu(term, mi, ses, 1);
1386 }
1387
1388 /** Return current link's title. */
1389 unsigned char *
1390 get_current_link_title(struct document_view *doc_view)
1391 {
1392 struct link *link;
1393
1394 assert(doc_view && doc_view->document && doc_view->vs);
1395 if_assert_failed return NULL;
1396
1397 if (doc_view->document->frame_desc)
1398 return NULL;
1399
1400 link = get_current_link(doc_view);
1401
1402 if (link && link->title && *link->title) {
1403 unsigned char *link_title, *src;
1404 struct conv_table *convert_table;
1405
1406 convert_table = get_translation_table(doc_view->document->cp,
1407 doc_view->document->options.cp);
1408
1409 link_title = convert_string(convert_table, link->title,
1410 strlen(link->title),
1411 doc_view->document->options.cp,
1412 CSM_DEFAULT, NULL, NULL, NULL);
1413 /* Remove illicit chars. */
1414 #ifdef CONFIG_UTF8
1415 if (link_title && !doc_view->document->options.utf8)
1416 #endif /* CONFIG_UTF8 */
1417 for (src = link_title; *src; src++)
1418 if (!isprint(*src) || iscntrl(*src))
1419 *src = '*';
1420
1421 return link_title;
1422 }
1423
1424 return NULL;
1425 }
1426
1427 unsigned char *
1428 get_current_link_info(struct session *ses, struct document_view *doc_view)
1429 {
1430 struct link *link;
1431
1432 assert(ses && doc_view && doc_view->document && doc_view->vs);
1433 if_assert_failed return NULL;
1434
1435 if (doc_view->document->frame_desc)
1436 return NULL;
1437
1438 link = get_current_link(doc_view);
1439 if (!link) return NULL;
1440
1441 /** @todo TODO: Provide info about script event hooks too. --pasky */
1442
1443 if (!link_is_form(link)) {
1444 struct terminal *term = ses->tab->term;
1445 struct string str;
1446 unsigned char *uristring = link->where;
1447
1448 if (!init_string(&str)) return NULL;
1449
1450 if (!link->where && link->where_img) {
1451 add_to_string(&str, _("Image", term));
1452 add_char_to_string(&str, ' ');
1453 uristring = link->where_img;
1454
1455 } else if (link->type == LINK_MAP) {
1456 add_to_string(&str, _("Usemap", term));
1457 add_char_to_string(&str, ' ');
1458 }
1459
1460 /* Add the uri with password and post info stripped */
1461 add_string_uri_to_string(&str, uristring, URI_PUBLIC);
1462 if (link->accesskey > 0
1463 && get_opt_bool("document.browse.accesskey.display",
1464 ses)) {
1465 add_to_string(&str, " (");
1466 add_accesskey_to_string(&str, link->accesskey);
1467 add_char_to_string(&str, ')');
1468 }
1469
1470 #ifdef CONFIG_UTF8
1471 if (term->utf8_cp)
1472 decode_uri_string(&str);
1473 else
1474 #endif /* CONFIG_UTF8 */
1475 decode_uri_string_for_display(&str);
1476 return str.source;
1477 }
1478
1479 if (!get_link_form_control(link)) return NULL;
1480
1481 return get_form_info(ses, doc_view);
1482 }
The ultimate text WWW browser