NetSurf
browser_window.c
Go to the documentation of this file.
1/*
2 * Copyright 2008 Michael Drake <tlsa@netsurf-browser.org>
3 * Copyright 2010 Daniel Silverstone <dsilvers@digital-scurf.org>
4 * Copyright 2010-2020 Vincent Sanders <vince@netsurf-browser.org>
5 *
6 * This file is part of NetSurf, http://www.netsurf-browser.org/
7 *
8 * NetSurf is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; version 2 of the License.
11 *
12 * NetSurf is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21/**
22 * \file
23 *
24 * Browser window creation and manipulation implementation.
25 */
26
27#include "utils/config.h"
28
29#include <stdlib.h>
30#include <string.h>
31#include <math.h>
32#include <nsutils/time.h>
33
34#include "utils/errors.h"
35#include "utils/log.h"
36#include "utils/corestrings.h"
37#include "utils/messages.h"
38#include "utils/nsoption.h"
39#include "netsurf/types.h"
40#include "netsurf/browser_window.h"
41#include "netsurf/window.h"
42#include "netsurf/misc.h"
43#include "netsurf/content.h"
44#include "netsurf/search.h"
45#include "netsurf/plotters.h"
46#include "content/content.h"
47#include "content/hlcache.h"
48#include "content/urldb.h"
49#include "content/content_debug.h"
50
51#include "html/html.h"
52#include "html/form_internal.h"
53#include "javascript/js.h"
54
55#include "desktop/browser_private.h"
56#include "desktop/scrollbar.h"
57#include "desktop/gui_internal.h"
58#include "desktop/download.h"
59#include "desktop/frames.h"
60#include "desktop/global_history.h"
61#include "desktop/textinput.h"
62#include "desktop/hotlist.h"
63#include "desktop/knockout.h"
64#include "desktop/browser_history.h"
65#include "desktop/theme.h"
66
67#ifdef WITH_THEME_INSTALL
68#include "desktop/theme.h"
69#endif
70
71/**
72 * smallest scale that can be applied to a browser window
73 */
74#define SCALE_MINIMUM 0.2
75
76/**
77 * largests scale that can be applied to a browser window
78 */
79#define SCALE_MAXIMUM 10.0
80
81/**
82 * maximum frame depth
83 */
84#define FRAME_DEPTH 8
85
86/* Forward declare internal navigation function */
87static nserror browser_window__navigate_internal(
88 struct browser_window *bw, struct browser_fetch_parameters *params);
89
90
91/**
92 * Close and destroy all child browser window.
93 *
94 * \param bw browser window
95 */
96static void browser_window_destroy_children(struct browser_window *bw)
97{
98 int i;
99
100 if (bw->children) {
101 for (i = 0; i < (bw->rows * bw->cols); i++) {
102 browser_window_destroy_internal(&bw->children[i]);
103 }
104 free(bw->children);
105 bw->children = NULL;
106 bw->rows = 0;
107 bw->cols = 0;
108 }
109}
110
111
112/**
113 * Free the stored fetch parameters
114 *
115 * \param bw The browser window
116 */
117static void
118browser_window__free_fetch_parameters(struct browser_fetch_parameters *params)
119{
120 if (params->url != NULL) {
121 nsurl_unref(params->url);
122 params->url = NULL;
123 }
124 if (params->referrer != NULL) {
125 nsurl_unref(params->referrer);
126 params->referrer = NULL;
127 }
128 if (params->post_urlenc != NULL) {
129 free(params->post_urlenc);
130 params->post_urlenc = NULL;
131 }
132 if (params->post_multipart != NULL) {
133 fetch_multipart_data_destroy(params->post_multipart);
134 params->post_multipart = NULL;
135 }
136 if (params->parent_charset != NULL) {
137 free(params->parent_charset);
138 params->parent_charset = NULL;
139 }
140}
141
142
143/**
144 * Get position of scrollbar widget within browser window.
145 *
146 * \param bw The browser window
147 * \param horizontal Whether to get position of horizontal scrollbar
148 * \param x Updated to x-coord of top left of scrollbar widget
149 * \param y Updated to y-coord of top left of scrollbar widget
150 */
151static inline void
152browser_window_get_scrollbar_pos(struct browser_window *bw,
153 bool horizontal,
154 int *x, int *y)
155{
156 if (horizontal) {
157 *x = 0;
158 *y = bw->height - SCROLLBAR_WIDTH;
159 } else {
160 *x = bw->width - SCROLLBAR_WIDTH;
161 *y = 0;
162 }
163}
164
165
166/**
167 * Get browser window horizontal scrollbar widget length
168 *
169 * \param bw The browser window
170 * \return the scrollbar's length
171 */
172static inline int get_horz_scrollbar_len(struct browser_window *bw)
173{
174 if (bw->scroll_y == NULL) {
175 return bw->width;
176 }
177 return bw->width - SCROLLBAR_WIDTH;
178}
179
180
181/**
182 * Get browser window vertical scrollbar widget length
183 *
184 * \param bw The browser window
185 * \return the scrollbar's length
186 */
187static inline int get_vert_scrollbar_len(struct browser_window *bw)
188{
189 return bw->height;
190}
191
192
193/**
194 * Set or remove a selection.
195 *
196 * \param bw browser window with selection
197 * \param selection true if bw has a selection, false if removing selection
198 * \param read_only true iff selection is read only (e.g. can't cut it)
199 */
200static void
201browser_window_set_selection(struct browser_window *bw,
202 bool selection,
203 bool read_only)
204{
205 struct browser_window *top;
206
207 assert(bw != NULL);
208
209 top = browser_window_get_root(bw);
210
211 assert(top != NULL);
212
213 if (bw != top->selection.bw &&
214 top->selection.bw != NULL &&
215 top->selection.bw->current_content != NULL) {
216 /* clear old selection */
217 content_clear_selection(top->selection.bw->current_content);
218 }
219
220 if (selection) {
221 top->selection.bw = bw;
222 } else {
223 top->selection.bw = NULL;
224 }
225
226 top->selection.read_only = read_only;
227}
228
229
230/**
231 * Set the scroll position of a browser window.
232 *
233 * scrolls the viewport to ensure the specified rectangle of the
234 * content is shown.
235 *
236 * \param bw window to scroll
237 * \param rect The rectangle to ensure is shown.
238 * \return NSERROR_OK on success or apropriate error code.
239 */
240static nserror
241browser_window_set_scroll(struct browser_window *bw, const struct rect *rect)
242{
243 if (bw->window != NULL) {
244 return guit->window->set_scroll(bw->window, rect);
245 }
246
247 if (bw->scroll_x != NULL) {
248 scrollbar_set(bw->scroll_x, rect->x0, false);
249 }
250 if (bw->scroll_y != NULL) {
251 scrollbar_set(bw->scroll_y, rect->y0, false);
252 }
253
254 return NSERROR_OK;
255}
256
257
258/**
259 * Internal helper for getting the positional features
260 *
261 * \param[in] bw browser window to examine.
262 * \param[in] x x-coordinate of point of interest
263 * \param[in] y y-coordinate of point of interest
264 * \param[out] data Feature structure to update.
265 * \return NSERROR_OK or appropriate error code on faliure.
266 */
267static nserror
268browser_window__get_contextual_content(struct browser_window *bw,
269 int x, int y,
270 struct browser_window_features *data)
271{
272 nserror ret = NSERROR_OK;
273
274 /* Handle (i)frame scroll offset (core-managed browser windows only) */
275 x += scrollbar_get_offset(bw->scroll_x);
276 y += scrollbar_get_offset(bw->scroll_y);
277
278 if (bw->children) {
279 /* Browser window has children, so pass request on to
280 * appropriate child.
281 */
282 struct browser_window *bwc;
283 int cur_child;
284 int children = bw->rows * bw->cols;
285
286 /* Loop through all children of bw */
287 for (cur_child = 0; cur_child < children; cur_child++) {
288 /* Set current child */
289 bwc = &bw->children[cur_child];
290
291 /* Skip this frame if (x, y) coord lies outside */
292 if ((x < bwc->x) ||
293 (bwc->x + bwc->width < x) ||
294 (y < bwc->y) ||
295 (bwc->y + bwc->height < y)) {
296 continue;
297 }
298
299 /* Pass request into this child */
300 return browser_window__get_contextual_content(bwc,
301 (x - bwc->x), (y - bwc->y), data);
302 }
303
304 /* Coordinate not contained by any frame */
305
306 } else if (bw->current_content != NULL) {
307 /* Pass request to content */
308 ret = content_get_contextual_content(bw->current_content,
309 x, y, data);
310 data->main = bw->current_content;
311 }
312
313 return ret;
314}
315
316
317/**
318 * implements the download operation of a window navigate
319 */
320static nserror
321browser_window_download(struct browser_window *bw,
322 nsurl *url,
323 nsurl *nsref,
324 uint32_t fetch_flags,
325 bool fetch_is_post,
326 llcache_post_data *post)
327{
328 llcache_handle *l;
329 struct browser_window *root;
330 nserror error;
331
332 root = browser_window_get_root(bw);
333 assert(root != NULL);
334
335 fetch_flags |= LLCACHE_RETRIEVE_FORCE_FETCH;
336 fetch_flags |= LLCACHE_RETRIEVE_STREAM_DATA;
337
338 error = llcache_handle_retrieve(url, fetch_flags, nsref,
339 fetch_is_post ? post : NULL,
340 NULL, NULL, &l);
341 if (error == NSERROR_NO_FETCH_HANDLER) {
342 /* no internal handler for this type, call out to frontend */
343 error = guit->misc->launch_url(url);
344 } else if (error != NSERROR_OK) {
345 NSLOG(netsurf, INFO, "Failed to fetch download: %d", error);
346 } else {
347 error = download_context_create(l, root->window);
348 if (error != NSERROR_OK) {
349 NSLOG(netsurf, INFO,
350 "Failed creating download context: %d", error);
351 llcache_handle_abort(l);
352 llcache_handle_release(l);
353 }
354 }
355
356 return error;
357}
358
359
360/**
361 * recursively check browser windows for activity
362 *
363 * \param bw browser window to start checking from.
364 */
365static bool browser_window_check_throbber(struct browser_window *bw)
366{
367 int children, index;
368
369 if (bw->throbbing)
370 return true;
371
372 if (bw->children) {
373 children = bw->rows * bw->cols;
374 for (index = 0; index < children; index++) {
375 if (browser_window_check_throbber(&bw->children[index]))
376 return true;
377 }
378 }
379
380 if (bw->iframes) {
381 for (index = 0; index < bw->iframe_count; index++) {
382 if (browser_window_check_throbber(&bw->iframes[index]))
383 return true;
384 }
385 }
386
387 return false;
388}
389
390
391/**
392 * Start the busy indicator.
393 *
394 * \param bw browser window
395 */
396static nserror browser_window_start_throbber(struct browser_window *bw)
397{
398 bw->throbbing = true;
399
400 while (bw->parent)
401 bw = bw->parent;
402
403 return guit->window->event(bw->window, GW_EVENT_START_THROBBER);
404}
405
406
407/**
408 * Stop the busy indicator.
409 *
410 * \param bw browser window
411 */
412static nserror browser_window_stop_throbber(struct browser_window *bw)
413{
414 nserror res = NSERROR_OK;
415
416 bw->throbbing = false;
417
418 while (bw->parent) {
419 bw = bw->parent;
420 }
421
422 if (!browser_window_check_throbber(bw)) {
423 res = guit->window->event(bw->window, GW_EVENT_STOP_THROBBER);
424 }
425 return res;
426}
427
428
429/**
430 * Callback for fetchcache() for browser window favicon fetches.
431 *
432 * \param c content handle of favicon
433 * \param event The event to process
434 * \param pw a context containing the browser window
435 * \return NSERROR_OK on success else appropriate error code.
436 */
437static nserror
438browser_window_favicon_callback(hlcache_handle *c,
439 const hlcache_event *event,
440 void *pw)
441{
442 struct browser_window *bw = pw;
443
444 switch (event->type) {
445 case CONTENT_MSG_DONE:
446 if (bw->favicon.current != NULL) {
447 content_close(bw->favicon.current);
448 hlcache_handle_release(bw->favicon.current);
449 }
450
451 bw->favicon.current = c;
452 bw->favicon.loading = NULL;
453
454 /* content_get_bitmap on the hlcache_handle should give
455 * the favicon bitmap at this point
456 */
457 guit->window->set_icon(bw->window, c);
458 break;
459
460 case CONTENT_MSG_ERROR:
461
462 /* clean up after ourselves */
463 if (c == bw->favicon.loading) {
464 bw->favicon.loading = NULL;
465 } else if (c == bw->favicon.current) {
466 bw->favicon.current = NULL;
467 }
468
469 hlcache_handle_release(c);
470
471 if (bw->favicon.failed == false) {
472 nsurl *nsref = NULL;
473 nsurl *nsurl;
474 nserror error;
475
476 bw->favicon.failed = true;
477
478 error = nsurl_create("resource:favicon.ico", &nsurl);
479 if (error != NSERROR_OK) {
480 NSLOG(netsurf, INFO,
481 "Unable to create default location url");
482 } else {
483 hlcache_handle_retrieve(nsurl,
484 HLCACHE_RETRIEVE_SNIFF_TYPE,
485 nsref, NULL,
486 browser_window_favicon_callback,
487 bw, NULL, CONTENT_IMAGE,
488 &bw->favicon.loading);
489
490 nsurl_unref(nsurl);
491 }
492
493 }
494 break;
495
496 default:
497 break;
498
499 }
500 return NSERROR_OK;
501}
502
503
504/**
505 * update the favicon associated with the browser window
506 *
507 * \param c the page content handle.
508 * \param bw A top level browser window.
509 * \param link A link context or NULL to attempt fallback scanning.
510 */
511static nserror
512browser_window_update_favicon(hlcache_handle *c,
513 struct browser_window *bw,
514 struct content_rfc5988_link *link)
515{
516 nsurl *nsref = NULL;
517 nsurl *nsurl;
518 nserror res;
519
520 assert(c != NULL);
521 assert(bw !=NULL);
522
523 if (bw->window == NULL) {
524 /* Not top-level browser window; not interested */
525 return NSERROR_OK;
526 }
527
528 /* already fetching the favicon - use that */
529 if (bw->favicon.loading != NULL) {
530 return NSERROR_OK;
531 }
532
533 bw->favicon.failed = false;
534
535 if (link == NULL) {
536 /* Look for "icon" */
537 link = content_find_rfc5988_link(c, corestring_lwc_icon);
538 }
539
540 if (link == NULL) {
541 /* Look for "shortcut icon" */
542 link = content_find_rfc5988_link(c, corestring_lwc_shortcut_icon);
543 }
544
545 if (link == NULL) {
546 lwc_string *scheme;
547 bool speculative_default = false;
548 bool match;
549
550 nsurl = hlcache_handle_get_url(c);
551
552 scheme = nsurl_get_component(nsurl, NSURL_SCHEME);
553
554 /* If the document was fetched over http(s), then speculate
555 * that there's a favicon living at /favicon.ico */
556 if ((lwc_string_caseless_isequal(scheme,
557 corestring_lwc_http,
558 &match) == lwc_error_ok &&
559 match) ||
560 (lwc_string_caseless_isequal(scheme,
561 corestring_lwc_https,
562 &match) == lwc_error_ok &&
563 match)) {
564 speculative_default = true;
565 }
566
567 lwc_string_unref(scheme);
568
569 if (speculative_default) {
570 /* no favicon via link, try for the default location */
571 res = nsurl_join(nsurl, "/favicon.ico", &nsurl);
572 } else {
573 bw->favicon.failed = true;
574 res = nsurl_create("resource:favicon.ico", &nsurl);
575 }
576 if (res != NSERROR_OK) {
577 NSLOG(netsurf, INFO,
578 "Unable to create default location url");
579 return res;
580 }
581 } else {
582 nsurl = nsurl_ref(link->href);
583 }
584
585 if (link == NULL) {
586 NSLOG(netsurf, INFO,
587 "fetching general favicon from '%s'",
588 nsurl_access(nsurl));
589 } else {
590 NSLOG(netsurf, INFO,
591 "fetching favicon rel:%s '%s'",
592 lwc_string_data(link->rel),
593 nsurl_access(nsurl));
594 }
595
596 res = hlcache_handle_retrieve(nsurl,
597 HLCACHE_RETRIEVE_SNIFF_TYPE,
598 nsref,
599 NULL,
600 browser_window_favicon_callback,
601 bw,
602 NULL,
603 CONTENT_IMAGE,
604 &bw->favicon.loading);
605
606 nsurl_unref(nsurl);
607
608 return res;
609}
610
611
612/**
613 * Handle meta http-equiv refresh time elapsing by loading a new page.
614 *
615 * \param p browser window to refresh with new page
616 */
617static void browser_window_refresh(void *p)
618{
619 struct browser_window *bw = p;
620 nsurl *url;
621 nsurl *refresh;
622 hlcache_handle *parent = NULL;
623 enum browser_window_nav_flags flags = BW_NAVIGATE_UNVERIFIABLE;
624
625 assert(bw->current_content != NULL &&
626 (content_get_status(bw->current_content) ==
627 CONTENT_STATUS_READY ||
628 content_get_status(bw->current_content) ==
629 CONTENT_STATUS_DONE));
630
631 /* Ignore if the refresh URL has gone
632 * (may happen if a fetch error occurred) */
633 refresh = content_get_refresh_url(bw->current_content);
634 if (refresh == NULL)
635 return;
636
637 /* mark this content as invalid so it gets flushed from the cache */
638 content_invalidate_reuse_data(bw->current_content);
639
640 url = hlcache_handle_get_url(bw->current_content);
641 if ((url == NULL) || (nsurl_compare(url, refresh, NSURL_COMPLETE))) {
642 flags |= BW_NAVIGATE_HISTORY;
643 }
644
645 /* Treat an (almost) immediate refresh in a top-level browser window as
646 * if it were an HTTP redirect, and thus make the resulting fetch
647 * verifiable.
648 *
649 * See fetchcache.c for why redirected fetches should be verifiable at
650 * all.
651 */
652 if (bw->refresh_interval <= 100 && bw->parent == NULL) {
653 flags &= ~BW_NAVIGATE_UNVERIFIABLE;
654 } else {
655 parent = bw->current_content;
656 }
657
658 browser_window_navigate(bw,
659 refresh,
660 url,
661 flags,
662 NULL,
663 NULL,
664 parent);
665
666}
667
668
669/**
670 * Transfer the loading_content to a new download window.
671 */
672static void
673browser_window_convert_to_download(struct browser_window *bw,
674 llcache_handle *stream)
675{
676 struct browser_window *root = browser_window_get_root(bw);
677 nserror error;
678
679 assert(root != NULL);
680
681 error = download_context_create(stream, root->window);
682 if (error != NSERROR_OK) {
683 llcache_handle_abort(stream);
684 llcache_handle_release(stream);
685 }
686
687 /* remove content from browser window */
688 hlcache_handle_release(bw->loading_content);
689 bw->loading_content = NULL;
690
691 browser_window_stop_throbber(bw);
692}
693
694
695/**
696 * scroll to a fragment if present
697 *
698 * \param bw browser window
699 * \return true if the scroll was sucessful
700 */
701static bool frag_scroll(struct browser_window *bw)
702{
703 struct rect rect;
704
705 if (bw->frag_id == NULL) {
706 return false;
707 }
708
709 if (!html_get_id_offset(bw->current_content,
710 bw->frag_id,
711 &rect.x0,
712 &rect.y0)) {
713 return false;
714 }
715
716 rect.x1 = rect.x0;
717 rect.y1 = rect.y0;
718 if (browser_window_set_scroll(bw, &rect) == NSERROR_OK) {
719 if (bw->current_content != NULL &&
720 bw->history != NULL &&
721 bw->history->current != NULL) {
722 browser_window_history_update(bw, bw->current_content);
723 }
724 return true;
725 }
726 return false;
727}
728
729
730/**
731 * Redraw browser window, set extent to content, and update title.
732 *
733 * \param bw browser_window
734 * \param scroll_to_top move view to top of page
735 */
736static void browser_window_update(struct browser_window *bw, bool scroll_to_top)
737{
738 static const struct rect zrect = {
739 .x0 = 0,
740 .y0 = 0,
741 .x1 = 0,
742 .y1 = 0
743 };
744
745 if (bw->current_content == NULL) {
746 return;
747 }
748
749 switch (bw->browser_window_type) {
750
751 case BROWSER_WINDOW_NORMAL:
752 /* Root browser window, constituting a front end window/tab */
753 guit->window->set_title(bw->window,
754 content_get_title(bw->current_content));
755
756 browser_window_update_extent(bw);
757
758 /* if frag_id exists, then try to scroll to it */
759 /** @todo don't do this if the user has scrolled */
760 if (!frag_scroll(bw)) {
761 if (scroll_to_top) {
762 browser_window_set_scroll(bw, &zrect);
763 }
764 }
765
766 guit->window->invalidate(bw->window, NULL);
767
768 break;
769
770 case BROWSER_WINDOW_IFRAME:
771 /* Internal iframe browser window */
772 assert(bw->parent != NULL);
773 assert(bw->parent->current_content != NULL);
774
775 browser_window_update_extent(bw);
776
777 if (scroll_to_top) {
778 browser_window_set_scroll(bw, &zrect);
779 }
780
781 /* if frag_id exists, then try to scroll to it */
782 /** @todo don't do this if the user has scrolled */
783 frag_scroll(bw);
784
785 browser_window_invalidate_iframe(bw);
786
787 break;
788
789 case BROWSER_WINDOW_FRAME:
790 {
791 struct rect rect;
792 browser_window_update_extent(bw);
793
794 if (scroll_to_top) {
795 browser_window_set_scroll(bw, &zrect);
796 }
797
798 /* if frag_id exists, then try to scroll to it */
799 /** @todo don't do this if the user has scrolled */
800 frag_scroll(bw);
801
802 rect.x0 = scrollbar_get_offset(bw->scroll_x);
803 rect.y0 = scrollbar_get_offset(bw->scroll_y);
804 rect.x1 = rect.x0 + bw->width;
805 rect.y1 = rect.y0 + bw->height;
806
807 browser_window_invalidate_rect(bw, &rect);
808 }
809 break;
810
811 default:
812 case BROWSER_WINDOW_FRAMESET:
813 /* Nothing to do */
814 break;
815 }
816}
817
818
819/**
820 * handle message for content ready on browser window
821 */
822static nserror browser_window_content_ready(struct browser_window *bw)
823{
824 int width, height;
825 nserror res = NSERROR_OK;
826
827 /* close and release the current window content */
828 if (bw->current_content != NULL) {
829 content_close(bw->current_content);
830 hlcache_handle_release(bw->current_content);
831 }
832
833 bw->current_content = bw->loading_content;
834 bw->loading_content = NULL;
835
836 if (!bw->internal_nav) {
837 /* Transfer the fetch parameters */
838 browser_window__free_fetch_parameters(&bw->current_parameters);
839 bw->current_parameters = bw->loading_parameters;
840 memset(&bw->loading_parameters, 0, sizeof(bw->loading_parameters));
841 /* Transfer the certificate chain */
842 cert_chain_free(bw->current_cert_chain);
843 bw->current_cert_chain = bw->loading_cert_chain;
844 bw->loading_cert_chain = NULL;
845 }
846
847 /* Format the new content to the correct dimensions */
848 browser_window_get_dimensions(bw, &width, &height);
849 width /= bw->scale;
850 height /= bw->scale;
851 content_reformat(bw->current_content, false, width, height);
852
853 /* history */
854 if (bw->history_add && bw->history && !bw->internal_nav) {
855 nsurl *url = hlcache_handle_get_url(bw->current_content);
856
857 if (urldb_add_url(url)) {
858 urldb_set_url_title(url, content_get_title(bw->current_content));
859 urldb_update_url_visit_data(url);
860 urldb_set_url_content_type(url,
861 content_get_type(bw->current_content));
862
863 /* This is safe as we've just added the URL */
864 global_history_add(urldb_get_url(url));
865 }
866 /**
867 * \todo Urldb / Thumbnails / Local history brokenness
868 *
869 * We add to local history after calling urldb_add_url rather
870 * than in the block above. If urldb_add_url fails (as it
871 * will for urls like "about:about", "about:config" etc),
872 * there would be no local history node, and later calls to
873 * history_update will either explode or overwrite the node
874 * for the previous URL.
875 *
876 * We call it after, rather than before urldb_add_url because
877 * history_add calls bitmap render, which tries to register
878 * the thumbnail with urldb. That thumbnail registration
879 * fails if the url doesn't exist in urldb already, and only
880 * urldb-registered thumbnails get freed. So if we called
881 * history_add before urldb_add_url we would leak thumbnails
882 * for all newly visited URLs. With the history_add call
883 * after, we only leak the thumbnails when urldb does not add
884 * the URL.
885 *
886 * Also, since browser_window_history_add can create a
887 * thumbnail (content_redraw), we need to do it after
888 * content_reformat.
889 */
890 browser_window_history_add(bw, bw->current_content, bw->frag_id);
891 }
892
893 browser_window_remove_caret(bw, false);
894
895 if (bw->window != NULL) {
896 guit->window->event(bw->window, GW_EVENT_NEW_CONTENT);
897
898 browser_window_refresh_url_bar(bw);
899 }
900
901 /* new content; set scroll_to_top */
902 browser_window_update(bw, true);
903 content_open(bw->current_content, bw, 0, 0);
904 browser_window_set_status(bw, content_get_status_message(bw->current_content));
905
906 /* frames */
907 res = browser_window_create_frameset(bw);
908
909 /* iframes */
910 res = browser_window_create_iframes(bw);
911
912 /* Indicate page status may have changed */
913 if (res == NSERROR_OK) {
914 struct browser_window *root = browser_window_get_root(bw);
915 res = guit->window->event(root->window, GW_EVENT_PAGE_INFO_CHANGE);
916 }
917
918 return res;
919}
920
921
922/**
923 * handle message for content done on browser window
924 */
925static nserror
926browser_window_content_done(struct browser_window *bw)
927{
928 float sx, sy;
929 struct rect rect;
930 int scrollx;
931 int scrolly;
932
933 if (bw->window == NULL) {
934 /* Updated browser window's scrollbars. */
935 /**
936 * \todo update browser window scrollbars before CONTENT_MSG_DONE
937 */
938 browser_window_reformat(bw, true, bw->width, bw->height);
939 browser_window_handle_scrollbars(bw);
940 }
941
942 browser_window_update(bw, false);
943 browser_window_set_status(bw, content_get_status_message(bw->current_content));
944 browser_window_stop_throbber(bw);
945 browser_window_update_favicon(bw->current_content, bw, NULL);
946
947 if (browser_window_history_get_scroll(bw, &sx, &sy) == NSERROR_OK) {
948 scrollx = (int)((float)content_get_width(bw->current_content) * sx);
949 scrolly = (int)((float)content_get_height(bw->current_content) * sy);
950 rect.x0 = rect.x1 = scrollx;
951 rect.y0 = rect.y1 = scrolly;
952 if (browser_window_set_scroll(bw, &rect) != NSERROR_OK) {
953 NSLOG(netsurf, WARNING,
954 "Unable to set browser scroll offsets to %d by %d",
955 scrollx, scrolly);
956 }
957 }
958
959 if (!bw->internal_nav) {
960 browser_window_history_update(bw, bw->current_content);
961 hotlist_update_url(hlcache_handle_get_url(bw->current_content));
962 }
963
964 if (bw->refresh_interval != -1) {
965 guit->misc->schedule(bw->refresh_interval * 10,
966 browser_window_refresh, bw);
967 }
968
969 return NSERROR_OK;
970}
971
972
973/**
974 * Handle query responses from SSL requests
975 */
976static nserror
977browser_window__handle_ssl_query_response(bool proceed, void *pw)
978{
979 struct browser_window *bw = (struct browser_window *)pw;
980
981 /* If we're in the process of loading, stop the load */
982 if (bw->loading_content != NULL) {
983 /* We had a loading content (maybe auth page?) */
984 browser_window_stop(bw);
985 browser_window_remove_caret(bw, false);
986 browser_window_destroy_children(bw);
987 browser_window_destroy_iframes(bw);
988 }
989
990 if (!proceed) {
991 /* We're processing a "back to safety", do a rough-and-ready
992 * nav to the old 'current' parameters, with any post data
993 * stripped away
994 */
995 return browser_window__reload_current_parameters(bw);
996 }
997
998 /* We're processing a "proceed" attempt from the form */
999 /* First, we permit the SSL */
1000 urldb_set_cert_permissions(bw->loading_parameters.url, true);
1001
1002 /* And then we navigate to the original loading parameters */
1003 bw->internal_nav = false;
1004
1005 return browser_window__navigate_internal(bw, &bw->loading_parameters);
1006}
1007
1008
1009/**
1010 * Unpack a "username:password" to components.
1011 *
1012 * \param[in] userpass The input string to split.
1013 * \param[in] username_out Returns username on success. Owned by caller.
1014 * \param[out] password_out Returns password on success. Owned by caller.
1015 * \return NSERROR_OK, or appropriate error code.
1016 */
1017static nserror
1018browser_window__unpack_userpass(const char *userpass,
1019 char **username_out,
1020 char **password_out)
1021{
1022 const char *tmp;
1023 char *username;
1024 char *password;
1025 size_t len;
1026
1027 if (userpass == NULL) {
1028 username = malloc(1);
1029 password = malloc(1);
1030 if (username == NULL || password == NULL) {
1031 free(username);
1032 free(password);
1033 return NSERROR_NOMEM;
1034 }
1035 username[0] = '\0';
1036 password[0] = '\0';
1037
1038 *username_out = username;
1039 *password_out = password;
1040 return NSERROR_OK;
1041 }
1042
1043 tmp = strchr(userpass, ':');
1044 if (tmp == NULL) {
1045 return NSERROR_BAD_PARAMETER;
1046 } else {
1047 size_t len2;
1048 len = tmp - userpass;
1049 len2 = strlen(++tmp);
1050
1051 username = malloc(len + 1);
1052 password = malloc(len2 + 1);
1053 if (username == NULL || password == NULL) {
1054 free(username);
1055 free(password);
1056 return NSERROR_NOMEM;
1057 }
1058 memcpy(username, userpass, len);
1059 username[len] = '\0';
1060 memcpy(password, tmp, len2 + 1);
1061 }
1062
1063 *username_out = username;
1064 *password_out = password;
1065 return NSERROR_OK;
1066}
1067
1068
1069/**
1070 * Build a "username:password" from components.
1071 *
1072 * \param[in] username The username component.
1073 * \param[in] password The password component.
1074 * \param[out] userpass_out Returns combined string on success.
1075 * Owned by caller.
1076 * \return NSERROR_OK, or appropriate error code.
1077 */
1078static nserror
1079browser_window__build_userpass(const char *username,
1080 const char *password,
1081 char **userpass_out)
1082{
1083 char *userpass;
1084 size_t len;
1085
1086 len = strlen(username) + 1 + strlen(password) + 1;
1087
1088 userpass = malloc(len);
1089 if (userpass == NULL) {
1090 return NSERROR_NOMEM;
1091 }
1092
1093 snprintf(userpass, len, "%s:%s", username, password);
1094
1095 *userpass_out = userpass;
1096 return NSERROR_OK;
1097}
1098
1099
1100/**
1101 * Handle a response from the UI when prompted for credentials
1102 */
1103static nserror
1104browser_window__handle_userpass_response(nsurl *url,
1105 const char *realm,
1106 const char *username,
1107 const char *password,
1108 void *pw)
1109{
1110 struct browser_window *bw = (struct browser_window *)pw;
1111 char *userpass;
1112 nserror err;
1113
1114 err = browser_window__build_userpass(username, password, &userpass);
1115 if (err != NSERROR_OK) {
1116 return err;
1117 }
1118
1119 urldb_set_auth_details(url, realm, userpass);
1120
1121 free(userpass);
1122
1123 /**
1124 * \todo QUERY - Eventually this should fill out the form *NOT* nav
1125 * to the original location
1126 */
1127 /* Finally navigate to the original loading parameters */
1128 if (bw->loading_content != NULL) {
1129 /* We had a loading content (maybe auth page?) */
1130 browser_window_stop(bw);
1131 browser_window_remove_caret(bw, false);
1132 browser_window_destroy_children(bw);
1133 browser_window_destroy_iframes(bw);
1134 }
1135 bw->internal_nav = false;
1136 return browser_window__navigate_internal(bw, &bw->loading_parameters);
1137}
1138
1139
1140/**
1141 * Handle login request (BAD_AUTH) during fetch
1142 *
1143 */
1144static nserror
1145browser_window__handle_login(struct browser_window *bw,
1146 const char *realm,
1147 nsurl *url) {
1148 char *username = NULL, *password = NULL;
1149 nserror err = NSERROR_OK;
1150 struct browser_fetch_parameters params;
1151
1152 memset(&params, 0, sizeof(params));
1153
1154 /* Step one, retrieve what we have */
1155 err = browser_window__unpack_userpass(
1156 urldb_get_auth_details(url, realm),
1157 &username, &password);
1158 if (err != NSERROR_OK) {
1159 goto out;
1160 }
1161
1162 /* Step two, construct our fetch parameters */
1163 params.url = nsurl_ref(corestring_nsurl_about_query_auth);
1164 params.referrer = nsurl_ref(url);
1165 params.flags = BW_NAVIGATE_HISTORY | BW_NAVIGATE_NO_TERMINAL_HISTORY_UPDATE | BW_NAVIGATE_INTERNAL;
1166
1167 err = fetch_multipart_data_new_kv(&params.post_multipart,
1168 "siteurl",
1169 nsurl_access(url));
1170 if (err != NSERROR_OK) {
1171 goto out;
1172 }
1173
1174 err = fetch_multipart_data_new_kv(&params.post_multipart,
1175 "realm",
1176 realm);
1177 if (err != NSERROR_OK) {
1178 goto out;
1179 }
1180
1181 err = fetch_multipart_data_new_kv(&params.post_multipart,
1182 "username",
1183 username);
1184 if (err != NSERROR_OK) {
1185 goto out;
1186 }
1187
1188 err = fetch_multipart_data_new_kv(&params.post_multipart,
1189 "password",
1190 password);
1191 if (err != NSERROR_OK) {
1192 goto out;
1193 }
1194
1195 /* Now we issue the fetch */
1196 bw->internal_nav = true;
1197 err = browser_window__navigate_internal(bw, &params);
1198
1199 if (err != NSERROR_OK) {
1200 goto out;
1201 }
1202
1203 err = guit->misc->login(url, realm, username, password,
1204 browser_window__handle_userpass_response, bw);
1205
1206 if (err == NSERROR_NOT_IMPLEMENTED) {
1207 err = NSERROR_OK;
1208 }
1209 out:
1210 if (username != NULL) {
1211 free(username);
1212 }
1213 if (password != NULL) {
1214 free(password);
1215 }
1216 browser_window__free_fetch_parameters(&params);
1217 return err;
1218}
1219
1220
1221/**
1222 * Handle a certificate verification request (BAD_CERTS) during a fetch
1223 */
1224static nserror
1225browser_window__handle_bad_certs(struct browser_window *bw,
1226 nsurl *url)
1227{
1228 struct browser_fetch_parameters params;
1229 nserror err;
1230 /* Initially we don't know WHY the SSL cert was bad */
1231 const char *reason = messages_get_sslcode(SSL_CERT_ERR_UNKNOWN);
1232 size_t depth;
1233 nsurl *chainurl = NULL;
1234
1235 memset(&params, 0, sizeof(params));
1236
1237 params.url = nsurl_ref(corestring_nsurl_about_query_ssl);
1238 params.referrer = nsurl_ref(url);
1239 params.flags = BW_NAVIGATE_HISTORY | BW_NAVIGATE_NO_TERMINAL_HISTORY_UPDATE | BW_NAVIGATE_INTERNAL;
1240
1241 err = fetch_multipart_data_new_kv(&params.post_multipart,
1242 "siteurl",
1243 nsurl_access(url));
1244 if (err != NSERROR_OK) {
1245 goto out;
1246 }
1247
1248 if (bw->loading_cert_chain != NULL) {
1249 for (depth = 0; depth < bw->loading_cert_chain->depth; ++depth) {
1250 size_t idx = bw->loading_cert_chain->depth - (depth + 1);
1251 ssl_cert_err err = bw->loading_cert_chain->certs[idx].err;
1252 if (err != SSL_CERT_ERR_OK) {
1253 reason = messages_get_sslcode(err);
1254 break;
1255 }
1256 }
1257
1258 err = cert_chain_to_query(bw->loading_cert_chain, &chainurl);
1259 if (err != NSERROR_OK) {
1260 goto out;
1261 }
1262
1263 err = fetch_multipart_data_new_kv(&params.post_multipart,
1264 "chainurl",
1265 nsurl_access(chainurl));
1266 if (err != NSERROR_OK) {
1267 goto out;
1268 }
1269 }
1270
1271 err = fetch_multipart_data_new_kv(&params.post_multipart,
1272 "reason",
1273 reason);
1274 if (err != NSERROR_OK) {
1275 goto out;
1276 }
1277
1278 /* Now we issue the fetch */
1279 bw->internal_nav = true;
1280 err = browser_window__navigate_internal(bw, &params);
1281 if (err != NSERROR_OK) {
1282 goto out;
1283 }
1284
1285 out:
1286 browser_window__free_fetch_parameters(&params);
1287 if (chainurl != NULL)
1288 nsurl_unref(chainurl);
1289 return err;
1290}
1291
1292
1293/**
1294 * Handle a timeout during a fetch
1295 */
1296static nserror
1297browser_window__handle_timeout(struct browser_window *bw, nsurl *url)
1298{
1299 struct browser_fetch_parameters params;
1300 nserror err;
1301
1302 memset(&params, 0, sizeof(params));
1303
1304 params.url = nsurl_ref(corestring_nsurl_about_query_timeout);
1305 params.referrer = nsurl_ref(url);
1306 params.flags = BW_NAVIGATE_HISTORY | BW_NAVIGATE_NO_TERMINAL_HISTORY_UPDATE | BW_NAVIGATE_INTERNAL;
1307
1308 err = fetch_multipart_data_new_kv(&params.post_multipart,
1309 "siteurl",
1310 nsurl_access(url));
1311 if (err != NSERROR_OK) {
1312 goto out;
1313 }
1314
1315 /* Now we issue the fetch */
1316 bw->internal_nav = true;
1317 err = browser_window__navigate_internal(bw, &params);
1318 if (err != NSERROR_OK) {
1319 goto out;
1320 }
1321
1322 out:
1323 browser_window__free_fetch_parameters(&params);
1324 return err;
1325}
1326
1327
1328/**
1329 * Handle non specific errors during a fetch
1330 */
1331static nserror
1332browser_window__handle_fetcherror(struct browser_window *bw,
1333 const char *reason,
1334 nsurl *url)
1335{
1336 struct browser_fetch_parameters params;
1337 nserror err;
1338
1339 memset(&params, 0, sizeof(params));
1340
1341 params.url = nsurl_ref(corestring_nsurl_about_query_fetcherror);
1342 params.referrer = nsurl_ref(url);
1343 params.flags = BW_NAVIGATE_HISTORY | BW_NAVIGATE_NO_TERMINAL_HISTORY_UPDATE | BW_NAVIGATE_INTERNAL;
1344
1345 err = fetch_multipart_data_new_kv(&params.post_multipart,
1346 "siteurl",
1347 nsurl_access(url));
1348 if (err != NSERROR_OK) {
1349 goto out;
1350 }
1351
1352 err = fetch_multipart_data_new_kv(&params.post_multipart,
1353 "reason",
1354 reason);
1355 if (err != NSERROR_OK) {
1356 goto out;
1357 }
1358
1359 /* Now we issue the fetch */
1360 bw->internal_nav = true;
1361 err = browser_window__navigate_internal(bw, &params);
1362 if (err != NSERROR_OK) {
1363 goto out;
1364 }
1365
1366 out:
1367 browser_window__free_fetch_parameters(&params);
1368 return err;
1369}
1370
1371
1372/**
1373 * Handle errors during content fetch
1374 */
1375static nserror
1376browser_window__handle_error(struct browser_window *bw,
1377 hlcache_handle *c,
1378 const hlcache_event *event)
1379{
1380 const char *message = event->data.errordata.errormsg;
1381 nserror code = event->data.errordata.errorcode;
1382 nserror res;
1383 nsurl *url = hlcache_handle_get_url(c);
1384
1385 /* Unexpected OK? */
1386 assert(code != NSERROR_OK);
1387
1388 if (message == NULL) {
1389 message = messages_get_errorcode(code);
1390 } else {
1391 message = messages_get(message);
1392 }
1393
1394 if (c == bw->loading_content) {
1395 bw->loading_content = NULL;
1396 } else if (c == bw->current_content) {
1397 bw->current_content = NULL;
1398 browser_window_remove_caret(bw, false);
1399 }
1400
1401 hlcache_handle_release(c);
1402
1403 switch (code) {
1404 case NSERROR_BAD_AUTH:
1405 res = browser_window__handle_login(bw, message, url);
1406 break;
1407
1408 case NSERROR_BAD_CERTS:
1409 res = browser_window__handle_bad_certs(bw, url);
1410 break;
1411
1412 case NSERROR_TIMEOUT:
1413 res = browser_window__handle_timeout(bw, url);
1414 break;
1415
1416 default:
1417 res = browser_window__handle_fetcherror(bw, message, url);
1418 break;
1419 }
1420
1421 return res;
1422}
1423
1424
1425/**
1426 * Update URL bar for a given browser window to given URL
1427 *
1428 * \param bw Browser window to update URL bar for.
1429 * \param url URL for content displayed by bw including any fragment.
1430 */
1431static inline nserror
1432browser_window_refresh_url_bar_internal(struct browser_window *bw, nsurl *url)
1433{
1434 assert(bw);
1435 assert(url);
1436
1437 if ((bw->parent != NULL) || (bw->window == NULL)) {
1438 /* Not root window or no gui window so do not set a URL */
1439 return NSERROR_OK;
1440 }
1441
1442 return guit->window->set_url(bw->window, url);
1443}
1444
1445
1446/**
1447 * Browser window content event callback handler.
1448 */
1449static nserror
1450browser_window_callback(hlcache_handle *c, const hlcache_event *event, void *pw)
1451{
1452 struct browser_window *bw = pw;
1453 nserror res = NSERROR_OK;
1454
1455 switch (event->type) {
1456 case CONTENT_MSG_SSL_CERTS:
1457 /* SSL certificate information has arrived, store it */
1458 cert_chain_free(bw->loading_cert_chain);
1459 cert_chain_dup(event->data.chain, &bw->loading_cert_chain);
1460 break;
1461
1462 case CONTENT_MSG_LOG:
1463 browser_window_console_log(bw,
1464 event->data.log.src,
1465 event->data.log.msg,
1466 event->data.log.msglen,
1467 event->data.log.flags);
1468 break;
1469
1470 case CONTENT_MSG_DOWNLOAD:
1471 assert(bw->loading_content == c);
1472
1473 browser_window_convert_to_download(bw, event->data.download);
1474
1475 if (bw->current_content != NULL) {
1476 browser_window_refresh_url_bar(bw);
1477 }
1478 break;
1479
1480 case CONTENT_MSG_LOADING:
1481 assert(bw->loading_content == c);
1482
1483#ifdef WITH_THEME_INSTALL
1484 if (content_get_type(c) == CONTENT_THEME) {
1485 theme_install_start(c);
1486 bw->loading_content = NULL;
1487 browser_window_stop_throbber(bw);
1488 } else
1489#endif
1490 {
1491 bw->refresh_interval = -1;
1492 browser_window_set_status(bw,
1493 content_get_status_message(c));
1494 }
1495 break;
1496
1497 case CONTENT_MSG_READY:
1498 assert(bw->loading_content == c);
1499
1500 res = browser_window_content_ready(bw);
1501 break;
1502
1503 case CONTENT_MSG_DONE:
1504 assert(bw->current_content == c);
1505
1506 res = browser_window_content_done(bw);
1507 break;
1508
1509 case CONTENT_MSG_ERROR:
1510 res = browser_window__handle_error(bw, c, event);
1511 break;
1512
1513 case CONTENT_MSG_REDIRECT:
1514 if (urldb_add_url(event->data.redirect.from)) {
1515 urldb_update_url_visit_data(event->data.redirect.from);
1516 }
1517 browser_window_refresh_url_bar_internal(bw, event->data.redirect.to);
1518 break;
1519
1520 case CONTENT_MSG_STATUS:
1521 if (event->data.explicit_status_text == NULL) {
1522 /* Object content's status text updated */
1523 const char *status = NULL;
1524 if (bw->loading_content != NULL) {
1525 /* Give preference to any loading content */
1526 status = content_get_status_message(
1527 bw->loading_content);
1528 }
1529
1530 if (status == NULL) {
1531 status = content_get_status_message(c);
1532 }
1533
1534 if (status != NULL) {
1535 browser_window_set_status(bw, status);
1536 }
1537 } else {
1538 /* Object content wants to set explicit message */
1539 browser_window_set_status(bw,
1540 event->data.explicit_status_text);
1541 }
1542 break;
1543
1544 case CONTENT_MSG_REFORMAT:
1545 if (c == bw->current_content) {
1546 /* recompute frameset */
1547 browser_window_recalculate_frameset(bw);
1548
1549 /* recompute iframe positions, sizes and scrollbars */
1550 browser_window_recalculate_iframes(bw);
1551 }
1552
1553 /* Hide any caret, but don't remove it */
1554 browser_window_remove_caret(bw, true);
1555
1556 if (!(event->data.background)) {
1557 /* Reformatted content should be redrawn */
1558 browser_window_update(bw, false);
1559 }
1560 break;
1561
1562 case CONTENT_MSG_REDRAW:
1563 {
1564 struct rect rect = {
1565 .x0 = event->data.redraw.x,
1566 .y0 = event->data.redraw.y,
1567 .x1 = event->data.redraw.x + event->data.redraw.width,
1568 .y1 = event->data.redraw.y + event->data.redraw.height
1569 };
1570
1571 browser_window_invalidate_rect(bw, &rect);
1572 }
1573 break;
1574
1575 case CONTENT_MSG_REFRESH:
1576 bw->refresh_interval = event->data.delay * 100;
1577 break;
1578
1579 case CONTENT_MSG_LINK: /* content has an rfc5988 link element */
1580 {
1581 bool match;
1582
1583 /* Handle "icon" and "shortcut icon" */
1584 if ((lwc_string_caseless_isequal(
1585 event->data.rfc5988_link->rel,
1586 corestring_lwc_icon,
1587 &match) == lwc_error_ok && match) ||
1588 (lwc_string_caseless_isequal(
1589 event->data.rfc5988_link->rel,
1590 corestring_lwc_shortcut_icon,
1591 &match) == lwc_error_ok && match)) {
1592 /* it's a favicon perhaps start a fetch for it */
1593 browser_window_update_favicon(c, bw,
1594 event->data.rfc5988_link);
1595 }
1596 }
1597 break;
1598
1599 case CONTENT_MSG_GETTHREAD:
1600 {
1601 /* only the content object created by the browser
1602 * window requires a new javascript thread object
1603 */
1604 jsthread *thread;
1605 assert(bw->loading_content == c);
1606
1607 if (js_newthread(bw->jsheap,
1608 bw,
1609 hlcache_handle_get_content(c),
1610 &thread) == NSERROR_OK) {
1611 /* The content which is requesting the thread
1612 * is required to keep hold of it and
1613 * to destroy it when it is finished with it.
1614 */
1615 *(event->data.jsthread) = thread;
1616 }
1617 }
1618 break;
1619
1620 case CONTENT_MSG_GETDIMS:
1621 {
1622 int width;
1623 int height;
1624
1625 browser_window_get_dimensions(bw, &width, &height);
1626
1627 *(event->data.getdims.viewport_width) = width / bw->scale;
1628 *(event->data.getdims.viewport_height) = height / bw->scale;
1629 break;
1630 }
1631
1632 case CONTENT_MSG_SCROLL:
1633 {
1634 struct rect rect = {
1635 .x0 = event->data.scroll.x0,
1636 .y0 = event->data.scroll.y0,
1637 };
1638
1639 /* Content wants to be scrolled */
1640 if (bw->current_content != c) {
1641 break;
1642 }
1643
1644 if (event->data.scroll.area) {
1645 rect.x1 = event->data.scroll.x1;
1646 rect.y1 = event->data.scroll.y1;
1647 } else {
1648 rect.x1 = event->data.scroll.x0;
1649 rect.y1 = event->data.scroll.y0;
1650 }
1651 browser_window_set_scroll(bw, &rect);
1652
1653 break;
1654 }
1655
1656 case CONTENT_MSG_DRAGSAVE:
1657 {
1658 /* Content wants drag save of a content */
1659 struct browser_window *root = browser_window_get_root(bw);
1660 hlcache_handle *save = event->data.dragsave.content;
1661
1662 if (save == NULL) {
1663 save = c;
1664 }
1665
1666 switch(event->data.dragsave.type) {
1667 case CONTENT_SAVE_ORIG:
1668 guit->window->drag_save_object(root->window,
1669 save,
1670 GUI_SAVE_OBJECT_ORIG);
1671 break;
1672
1673 case CONTENT_SAVE_NATIVE:
1674 guit->window->drag_save_object(root->window,
1675 save,
1676 GUI_SAVE_OBJECT_NATIVE);
1677 break;
1678
1679 case CONTENT_SAVE_COMPLETE:
1680 guit->window->drag_save_object(root->window,
1681 save,
1682 GUI_SAVE_COMPLETE);
1683 break;
1684
1685 case CONTENT_SAVE_SOURCE:
1686 guit->window->drag_save_object(root->window,
1687 save,
1688 GUI_SAVE_SOURCE);
1689 break;
1690 }
1691 }
1692 break;
1693
1694 case CONTENT_MSG_SAVELINK:
1695 {
1696 /* Content wants a link to be saved */
1697 struct browser_window *root = browser_window_get_root(bw);
1698 guit->window->save_link(root->window,
1699 event->data.savelink.url,
1700 event->data.savelink.title);
1701 }
1702 break;
1703
1704 case CONTENT_MSG_POINTER:
1705 /* Content wants to have specific mouse pointer */
1706 browser_window_set_pointer(bw, event->data.pointer);
1707 break;
1708
1709 case CONTENT_MSG_DRAG:
1710 {
1711 browser_drag_type bdt = DRAGGING_NONE;
1712
1713 switch (event->data.drag.type) {
1714 case CONTENT_DRAG_NONE:
1715 bdt = DRAGGING_NONE;
1716 break;
1717 case CONTENT_DRAG_SCROLL:
1718 bdt = DRAGGING_CONTENT_SCROLLBAR;
1719 break;
1720 case CONTENT_DRAG_SELECTION:
1721 bdt = DRAGGING_SELECTION;
1722 break;
1723 }
1724 browser_window_set_drag_type(bw, bdt, event->data.drag.rect);
1725 }
1726 break;
1727
1728 case CONTENT_MSG_CARET:
1729 switch (event->data.caret.type) {
1730 case CONTENT_CARET_REMOVE:
1731 browser_window_remove_caret(bw, false);
1732 break;
1733 case CONTENT_CARET_HIDE:
1734 browser_window_remove_caret(bw, true);
1735 break;
1736 case CONTENT_CARET_SET_POS:
1737 browser_window_place_caret(bw,
1738 event->data.caret.pos.x,
1739 event->data.caret.pos.y,
1740 event->data.caret.pos.height,
1741 event->data.caret.pos.clip);
1742 break;
1743 }
1744 break;
1745
1746 case CONTENT_MSG_SELECTION:
1747 browser_window_set_selection(bw,
1748 event->data.selection.selection,
1749 event->data.selection.read_only);
1750 break;
1751
1752 case CONTENT_MSG_SELECTMENU:
1753 if (event->data.select_menu.gadget->type == GADGET_SELECT) {
1754 struct browser_window *root =
1755 browser_window_get_root(bw);
1756 guit->window->create_form_select_menu(root->window,
1757 event->data.select_menu.gadget);
1758 }
1759
1760 break;
1761
1762 case CONTENT_MSG_GADGETCLICK:
1763 if (event->data.gadget_click.gadget->type == GADGET_FILE) {
1764 struct browser_window *root =
1765 browser_window_get_root(bw);
1766 guit->window->file_gadget_open(root->window, c,
1767 event->data.gadget_click.gadget);
1768 }
1769
1770 break;
1771
1772
1773 case CONTENT_MSG_TEXTSEARCH:
1774 switch (event->data.textsearch.type) {
1775 case CONTENT_TEXTSEARCH_FIND:
1776 guit->search->hourglass(event->data.textsearch.state,
1777 event->data.textsearch.ctx);
1778 break;
1779
1780 case CONTENT_TEXTSEARCH_MATCH:
1781 guit->search->status(event->data.textsearch.state,
1782 event->data.textsearch.ctx);
1783 break;
1784
1785 case CONTENT_TEXTSEARCH_BACK:
1786 guit->search->back_state(event->data.textsearch.state,
1787 event->data.textsearch.ctx);
1788 break;
1789
1790 case CONTENT_TEXTSEARCH_FORWARD:
1791 guit->search->forward_state(event->data.textsearch.state,
1792 event->data.textsearch.ctx);
1793 break;
1794
1795 case CONTENT_TEXTSEARCH_RECENT:
1796 guit->search->add_recent(event->data.textsearch.string,
1797 event->data.textsearch.ctx);
1798
1799 break;
1800 }
1801 break;
1802
1803 default:
1804 break;
1805 }
1806
1807 return res;
1808}
1809
1810
1811/**
1812 * internal scheduled reformat callback.
1813 *
1814 * scheduled reformat callback to allow reformats from unthreaded context.
1815 *
1816 * \param vbw The browser window to be reformatted
1817 */
1818static void scheduled_reformat(void *vbw)
1819{
1820 struct browser_window *bw = vbw;
1821 int width;
1822 int height;
1823 nserror res;
1824
1825 res = guit->window->get_dimensions(bw->window, &width, &height);
1826 if (res == NSERROR_OK) {
1827 browser_window_reformat(bw, false, width, height);
1828 }
1829}
1830
1831/* exported interface documented in desktop/browser_private.h */
1832nserror browser_window_destroy_internal(struct browser_window *bw)
1833{
1834 assert(bw);
1835
1836 browser_window_destroy_children(bw);
1837 browser_window_destroy_iframes(bw);
1838
1839 /* Destroy scrollbars */
1840 if (bw->scroll_x != NULL) {
1841 scrollbar_destroy(bw->scroll_x);
1842 }
1843
1844 if (bw->scroll_y != NULL) {
1845 scrollbar_destroy(bw->scroll_y);
1846 }
1847
1848 /* clear any pending callbacks */
1849 guit->misc->schedule(-1, browser_window_refresh, bw);
1850 NSLOG(netsurf, INFO,
1851 "Clearing reformat schedule for browser window %p", bw);
1852 guit->misc->schedule(-1, scheduled_reformat, bw);
1853
1854 /* If this brower window is not the root window, and has focus, unset
1855 * the root browser window's focus pointer. */
1856 if (!bw->window) {
1857 struct browser_window *top = browser_window_get_root(bw);
1858
1859 if (top->focus == bw)
1860 top->focus = top;
1861
1862 if (top->selection.bw == bw) {
1863 browser_window_set_selection(top, false, false);
1864 }
1865 }
1866
1867 /* Destruction order is important: we must ensure that the frontend
1868 * destroys any window(s) associated with this browser window before
1869 * we attempt any destructive cleanup.
1870 */
1871
1872 if (bw->window) {
1873 /* Only the root window has a GUI window */
1874 guit->window->destroy(bw->window);
1875 }
1876
1877 if (bw->loading_content != NULL) {
1878 hlcache_handle_abort(bw->loading_content);
1879 hlcache_handle_release(bw->loading_content);
1880 bw->loading_content = NULL;
1881 }
1882
1883 if (bw->current_content != NULL) {
1884 content_close(bw->current_content);
1885 hlcache_handle_release(bw->current_content);
1886 bw->current_content = NULL;
1887 }
1888
1889 if (bw->favicon.loading != NULL) {
1890 hlcache_handle_abort(bw->favicon.loading);
1891 hlcache_handle_release(bw->favicon.loading);
1892 bw->favicon.loading = NULL;
1893 }
1894
1895 if (bw->favicon.current != NULL) {
1896 content_close(bw->favicon.current);
1897 hlcache_handle_release(bw->favicon.current);
1898 bw->favicon.current = NULL;
1899 }
1900
1901 if (bw->jsheap != NULL) {
1902 js_destroyheap(bw->jsheap);
1903 bw->jsheap = NULL;
1904 }
1905
1906 /* These simply free memory, so are safe here */
1907
1908 if (bw->frag_id != NULL) {
1909 lwc_string_unref(bw->frag_id);
1910 }
1911
1912 browser_window_history_destroy(bw);
1913
1914 cert_chain_free(bw->current_cert_chain);
1915 cert_chain_free(bw->loading_cert_chain);
1916 bw->current_cert_chain = NULL;
1917 bw->loading_cert_chain = NULL;
1918
1919 free(bw->name);
1920 free(bw->status.text);
1921 bw->status.text = NULL;
1922 browser_window__free_fetch_parameters(&bw->current_parameters);
1923 browser_window__free_fetch_parameters(&bw->loading_parameters);
1924 NSLOG(netsurf, INFO, "Status text cache match:miss %d:%d",
1925 bw->status.match, bw->status.miss);
1926
1927 return NSERROR_OK;
1928}
1929
1930
1931/**
1932 * Set browser window scale.
1933 *
1934 * \param bw Browser window.
1935 * \param absolute scale value.
1936 * \return NSERROR_OK on success else error code
1937 */
1938static nserror
1939browser_window_set_scale_internal(struct browser_window *bw, float scale)
1940{
1941 int i;
1942 nserror res = NSERROR_OK;
1943
1944 /* do not apply tiny changes in scale */
1945 if (fabs(bw->scale - scale) < 0.0001)
1946 return res;
1947
1948 bw->scale = scale;
1949
1950 if (bw->current_content != NULL) {
1951 if (content_can_reformat(bw->current_content) == false) {
1952 browser_window_update(bw, false);
1953 } else {
1954 res = browser_window_schedule_reformat(bw);
1955 }
1956 }
1957
1958 /* scale frames */
1959 for (i = 0; i < (bw->cols * bw->rows); i++) {
1960 res = browser_window_set_scale_internal(&bw->children[i], scale);
1961 }
1962
1963 /* scale iframes */
1964 for (i = 0; i < bw->iframe_count; i++) {
1965 res = browser_window_set_scale_internal(&bw->iframes[i], scale);
1966 }
1967
1968 return res;
1969}
1970
1971
1972/**
1973 * Find browser window.
1974 *
1975 * \param bw Browser window.
1976 * \param target Name of target.
1977 * \param depth Depth to scan.
1978 * \param page The browser window page.
1979 * \param rdepth The rdepth.
1980 * \param bw_target the output browser window.
1981 */
1982static void
1983browser_window_find_target_internal(struct browser_window *bw,
1984 const char *target,
1985 int depth,
1986 struct browser_window *page,
1987 int *rdepth,
1988 struct browser_window **bw_target)
1989{
1990 int i;
1991
1992 if ((bw->name) && (!strcasecmp(bw->name, target))) {
1993 if ((bw == page) || (depth > *rdepth)) {
1994 *rdepth = depth;
1995 *bw_target = bw;
1996 }
1997 }
1998
1999 if ((!bw->children) && (!bw->iframes))
2000 return;
2001
2002 depth++;
2003
2004 if (bw->children != NULL) {
2005 for (i = 0; i < (bw->cols * bw->rows); i++) {
2006 if ((bw->children[i].name) &&
2007 (!strcasecmp(bw->children[i].name,
2008 target))) {
2009 if ((page == &bw->children[i]) ||
2010 (depth > *rdepth)) {
2011 *rdepth = depth;
2012 *bw_target = &bw->children[i];
2013 }
2014 }
2015 if (bw->children[i].children)
2016 browser_window_find_target_internal(
2017 &bw->children[i],
2018 target, depth, page,
2019 rdepth, bw_target);
2020 }
2021 }
2022
2023 if (bw->iframes != NULL) {
2024 for (i = 0; i < bw->iframe_count; i++) {
2025 browser_window_find_target_internal(&bw->iframes[i],
2026 target,
2027 depth,
2028 page,
2029 rdepth,
2030 bw_target);
2031 }
2032 }
2033}
2034
2035
2036/**
2037 * Handles the end of a drag operation in a browser window.
2038 *
2039 * \param bw browser window
2040 * \param mouse state of mouse buttons and modifier keys
2041 * \param x coordinate of mouse
2042 * \param y coordinate of mouse
2043 *
2044 * \todo Remove this function, once these things are associated with content,
2045 * rather than bw.
2046 */
2047static void
2048browser_window_mouse_drag_end(struct browser_window *bw,
2049 browser_mouse_state mouse,
2050 int x, int y)
2051{
2052 int scr_x, scr_y;
2053
2054 switch (bw->drag.type) {
2055 case DRAGGING_SELECTION:
2056 case DRAGGING_OTHER:
2057 case DRAGGING_CONTENT_SCROLLBAR:
2058 /* Drag handled by content handler */
2059 break;
2060
2061 case DRAGGING_SCR_X:
2062
2063 browser_window_get_scrollbar_pos(bw, true, &scr_x, &scr_y);
2064
2065 scr_x = x - scr_x - scrollbar_get_offset(bw->scroll_x);
2066 scr_y = y - scr_y - scrollbar_get_offset(bw->scroll_y);
2067
2068 scrollbar_mouse_drag_end(bw->scroll_x, mouse, scr_x, scr_y);
2069
2070 bw->drag.type = DRAGGING_NONE;
2071 break;
2072
2073 case DRAGGING_SCR_Y:
2074
2075 browser_window_get_scrollbar_pos(bw, false, &scr_x, &scr_y);
2076
2077 scr_x = x - scr_x - scrollbar_get_offset(bw->scroll_x);
2078 scr_y = y - scr_y - scrollbar_get_offset(bw->scroll_y);
2079
2080 scrollbar_mouse_drag_end(bw->scroll_y, mouse, scr_x, scr_y);
2081
2082 bw->drag.type = DRAGGING_NONE;
2083 break;
2084
2085 default:
2086 browser_window_set_drag_type(bw, DRAGGING_NONE, NULL);
2087 break;
2088 }
2089}
2090
2091/**
2092 * Process mouse click event
2093 *
2094 * \param bw The browsing context receiving the event
2095 * \param mouse The mouse event state
2096 * \param x The scaled x co-ordinate of the event
2097 * \param y The scaled y co-ordinate of the event
2098 */
2099static void
2100browser_window_mouse_click_internal(struct browser_window *bw,
2101 browser_mouse_state mouse,
2102 int x, int y)
2103{
2104 hlcache_handle *c = bw->current_content;
2105 const char *status = NULL;
2106 browser_pointer_shape pointer = BROWSER_POINTER_DEFAULT;
2107
2108 if (bw->children) {
2109 /* Browser window has children (frames) */
2110 struct browser_window *child;
2111 int cur_child;
2112 int children = bw->rows * bw->cols;
2113
2114 for (cur_child = 0; cur_child < children; cur_child++) {
2115
2116 child = &bw->children[cur_child];
2117
2118 if ((x < child->x) ||
2119 (y < child->y) ||
2120 (child->x + child->width < x) ||
2121 (child->y + child->height < y)) {
2122 /* Click not in this child */
2123 continue;
2124 }
2125
2126 /* It's this child that contains the click; pass it
2127 * on to child. */
2128 browser_window_mouse_click_internal(
2129 child,
2130 mouse,
2131 x - child->x + scrollbar_get_offset(child->scroll_x),
2132 y - child->y + scrollbar_get_offset(child->scroll_y));
2133
2134 /* Mouse action was for this child, we're done */
2135 return;
2136 }
2137
2138 return;
2139 }
2140
2141 if (!c)
2142 return;
2143
2144 if (bw->scroll_x != NULL) {
2145 int scr_x, scr_y;
2146 browser_window_get_scrollbar_pos(bw, true, &scr_x, &scr_y);
2147 scr_x = x - scr_x - scrollbar_get_offset(bw->scroll_x);
2148 scr_y = y - scr_y - scrollbar_get_offset(bw->scroll_y);
2149
2150 if (scr_x > 0 && scr_x < get_horz_scrollbar_len(bw) &&
2151 scr_y > 0 && scr_y < SCROLLBAR_WIDTH) {
2152 status = scrollbar_mouse_status_to_message(
2153 scrollbar_mouse_action(
2154 bw->scroll_x, mouse,
2155 scr_x, scr_y));
2156 pointer = BROWSER_POINTER_DEFAULT;
2157
2158 if (status != NULL)
2159 browser_window_set_status(bw, status);
2160
2161 browser_window_set_pointer(bw, pointer);
2162 return;
2163 }
2164 }
2165
2166 if (bw->scroll_y != NULL) {
2167 int scr_x, scr_y;
2168 browser_window_get_scrollbar_pos(bw, false, &scr_x, &scr_y);
2169 scr_x = x - scr_x - scrollbar_get_offset(bw->scroll_x);
2170 scr_y = y - scr_y - scrollbar_get_offset(bw->scroll_y);
2171
2172 if (scr_y > 0 && scr_y < get_vert_scrollbar_len(bw) &&
2173 scr_x > 0 && scr_x < SCROLLBAR_WIDTH) {
2174 status = scrollbar_mouse_status_to_message(
2175 scrollbar_mouse_action(
2176 bw->scroll_y,
2177 mouse,
2178 scr_x,
2179 scr_y));
2180 pointer = BROWSER_POINTER_DEFAULT;
2181
2182 if (status != NULL) {
2183 browser_window_set_status(bw, status);
2184 }
2185
2186 browser_window_set_pointer(bw, pointer);
2187 return;
2188 }
2189 }
2190
2191 switch (content_get_type(c)) {
2192 case CONTENT_HTML:
2193 case CONTENT_TEXTPLAIN:
2194 {
2195 /* Give bw focus */
2196 struct browser_window *root_bw = browser_window_get_root(bw);
2197 if (bw != root_bw->focus) {
2198 browser_window_remove_caret(bw, false);
2199 browser_window_set_selection(bw, false, true);
2200 root_bw->focus = bw;
2201 }
2202
2203 /* Pass mouse action to content */
2204 content_mouse_action(c, bw, mouse, x, y);
2205 }
2206 break;
2207 default:
2208 if (mouse & BROWSER_MOUSE_MOD_2) {
2209 if (mouse & BROWSER_MOUSE_DRAG_2) {
2210 guit->window->drag_save_object(bw->window, c,
2211 GUI_SAVE_OBJECT_NATIVE);
2212 } else if (mouse & BROWSER_MOUSE_DRAG_1) {
2213 guit->window->drag_save_object(bw->window, c,
2214 GUI_SAVE_OBJECT_ORIG);
2215 }
2216 } else if (mouse & (BROWSER_MOUSE_DRAG_1 |
2217 BROWSER_MOUSE_DRAG_2)) {
2218 browser_window_page_drag_start(bw, x, y);
2219 browser_window_set_pointer(bw, BROWSER_POINTER_MOVE);
2220 }
2221 break;
2222 }
2223}
2224
2225
2226/**
2227 * Process mouse movement event
2228 *
2229 * \param bw The browsing context receiving the event
2230 * \param mouse The mouse event state
2231 * \param x The scaled x co-ordinate of the event
2232 * \param y The scaled y co-ordinate of the event
2233 */
2234static void
2235browser_window_mouse_track_internal(struct browser_window *bw,
2236 browser_mouse_state mouse,
2237 int x, int y)
2238{
2239 hlcache_handle *c = bw->current_content;
2240 const char *status = NULL;
2241 browser_pointer_shape pointer = BROWSER_POINTER_DEFAULT;
2242
2243 if (bw->window != NULL && bw->drag.window && bw != bw->drag.window) {
2244 /* This is the root browser window and there's an active drag
2245 * in a sub window.
2246 * Pass the mouse action straight on to that bw. */
2247 struct browser_window *drag_bw = bw->drag.window;
2248 int off_x = 0;
2249 int off_y = 0;
2250
2251 browser_window_get_position(drag_bw, true, &off_x, &off_y);
2252
2253 if (drag_bw->browser_window_type == BROWSER_WINDOW_FRAME) {
2254 browser_window_mouse_track_internal(drag_bw,
2255 mouse,
2256 x - off_x,
2257 y - off_y);
2258
2259 } else if (drag_bw->browser_window_type == BROWSER_WINDOW_IFRAME) {
2260 browser_window_mouse_track_internal(drag_bw, mouse,
2261 x - off_x / bw->scale,
2262 y - off_y / bw->scale);
2263 }
2264 return;
2265 }
2266
2267 if (bw->children) {
2268 /* Browser window has children (frames) */
2269 struct browser_window *child;
2270 int cur_child;
2271 int children = bw->rows * bw->cols;
2272
2273 for (cur_child = 0; cur_child < children; cur_child++) {
2274
2275 child = &bw->children[cur_child];
2276
2277 if ((x < child->x) ||
2278 (y < child->y) ||
2279 (child->x + child->width < x) ||
2280 (child->y + child->height < y)) {
2281 /* Click not in this child */
2282 continue;
2283 }
2284
2285 /* It's this child that contains the mouse; pass
2286 * mouse action on to child */
2287 browser_window_mouse_track_internal(
2288 child,
2289 mouse,
2290 x - child->x + scrollbar_get_offset(child->scroll_x),
2291 y - child->y + scrollbar_get_offset(child->scroll_y));
2292
2293 /* Mouse action was for this child, we're done */
2294 return;
2295 }
2296
2297 /* Odd if we reached here, but nothing else can use the click
2298 * when there are children. */
2299 return;
2300 }
2301
2302 if (c == NULL && bw->drag.type != DRAGGING_FRAME) {
2303 return;
2304 }
2305
2306 if (bw->drag.type != DRAGGING_NONE && !mouse) {
2307 browser_window_mouse_drag_end(bw, mouse, x, y);
2308 }
2309
2310 /* Browser window's horizontal scrollbar */
2311 if (bw->scroll_x != NULL && bw->drag.type != DRAGGING_SCR_Y) {
2312 int scr_x, scr_y;
2313 browser_window_get_scrollbar_pos(bw, true, &scr_x, &scr_y);
2314 scr_x = x - scr_x - scrollbar_get_offset(bw->scroll_x);
2315 scr_y = y - scr_y - scrollbar_get_offset(bw->scroll_y);
2316
2317 if ((bw->drag.type == DRAGGING_SCR_X) ||
2318 (scr_x > 0 &&
2319 scr_x < get_horz_scrollbar_len(bw) &&
2320 scr_y > 0 &&
2321 scr_y < SCROLLBAR_WIDTH &&
2322 bw->drag.type == DRAGGING_NONE)) {
2323 /* Start a scrollbar drag, or continue existing drag */
2324 status = scrollbar_mouse_status_to_message(
2325 scrollbar_mouse_action(bw->scroll_x,
2326 mouse,
2327 scr_x,
2328 scr_y));
2329 pointer = BROWSER_POINTER_DEFAULT;
2330
2331 if (status != NULL) {
2332 browser_window_set_status(bw, status);
2333 }
2334
2335 browser_window_set_pointer(bw, pointer);
2336 return;
2337 }
2338 }
2339
2340 /* Browser window's vertical scrollbar */
2341 if (bw->scroll_y != NULL) {
2342 int scr_x, scr_y;
2343 browser_window_get_scrollbar_pos(bw, false, &scr_x, &scr_y);
2344 scr_x = x - scr_x - scrollbar_get_offset(bw->scroll_x);
2345 scr_y = y - scr_y - scrollbar_get_offset(bw->scroll_y);
2346
2347 if ((bw->drag.type == DRAGGING_SCR_Y) ||
2348 (scr_y > 0 &&
2349 scr_y < get_vert_scrollbar_len(bw) &&
2350 scr_x > 0 &&
2351 scr_x < SCROLLBAR_WIDTH &&
2352 bw->drag.type == DRAGGING_NONE)) {
2353 /* Start a scrollbar drag, or continue existing drag */
2354 status = scrollbar_mouse_status_to_message(
2355 scrollbar_mouse_action(bw->scroll_y,
2356 mouse,
2357 scr_x,
2358 scr_y));
2359 pointer = BROWSER_POINTER_DEFAULT;
2360
2361 if (status != NULL) {
2362 browser_window_set_status(bw, status);
2363 }
2364
2365 browser_window_set_pointer(bw, pointer);
2366 return;
2367 }
2368 }
2369
2370 if (bw->drag.type == DRAGGING_FRAME) {
2371 browser_window_resize_frame(bw, bw->x + x, bw->y + y);
2372 } else if (bw->drag.type == DRAGGING_PAGE_SCROLL) {
2373 /* mouse movement since drag started */
2374 struct rect rect;
2375
2376 rect.x0 = bw->drag.start_x - x;
2377 rect.y0 = bw->drag.start_y - y;
2378
2379 /* new scroll offsets */
2380 rect.x0 += bw->drag.start_scroll_x;
2381 rect.y0 += bw->drag.start_scroll_y;
2382
2383 bw->drag.start_scroll_x = rect.x1 = rect.x0;
2384 bw->drag.start_scroll_y = rect.y1 = rect.y0;
2385
2386 browser_window_set_scroll(bw, &rect);
2387 } else {
2388 assert(c != NULL);
2389 content_mouse_track(c, bw, mouse, x, y);
2390 }
2391}
2392
2393
2394/**
2395 * perform a scroll operation at a given coordinate
2396 *
2397 * \param bw The browsing context receiving the event
2398 * \param x The scaled x co-ordinate of the event
2399 * \param y The scaled y co-ordinate of the event
2400 */
2401static bool
2402browser_window_scroll_at_point_internal(struct browser_window *bw,
2403 int x, int y,
2404 int scrx, int scry)
2405{
2406 assert(bw != NULL);
2407
2408 /* Handle (i)frame scroll offset (core-managed browser windows only) */
2409 x += scrollbar_get_offset(bw->scroll_x);
2410 y += scrollbar_get_offset(bw->scroll_y);
2411
2412 if (bw->children) {
2413 /* Browser window has children, so pass request on to
2414 * appropriate child */
2415 struct browser_window *bwc;
2416 int cur_child;
2417 int children = bw->rows * bw->cols;
2418
2419 /* Loop through all children of bw */
2420 for (cur_child = 0; cur_child < children; cur_child++) {
2421 /* Set current child */
2422 bwc = &bw->children[cur_child];
2423
2424 /* Skip this frame if (x, y) coord lies outside */
2425 if (x < bwc->x || bwc->x + bwc->width < x ||
2426 y < bwc->y || bwc->y + bwc->height < y)
2427 continue;
2428
2429 /* Pass request into this child */
2430 return browser_window_scroll_at_point_internal(
2431 bwc,
2432 (x - bwc->x),
2433 (y - bwc->y),
2434 scrx, scry);
2435 }
2436 }
2437
2438 /* Try to scroll any current content */
2439 if (bw->current_content != NULL &&
2440 content_scroll_at_point(bw->current_content, x, y, scrx, scry) == true) {
2441 /* Scroll handled by current content */
2442 return true;
2443 }
2444
2445 /* Try to scroll this window. */
2446 return (int)scrollbar_scroll(bw->scroll_y, scry) |
2447 (int)scrollbar_scroll(bw->scroll_x, scrx);
2448}
2449
2450
2451/**
2452 * allows a dragged file to be dropped into a browser window at a position
2453 *
2454 * \param bw The browsing context receiving the event
2455 * \param x The scaled x co-ordinate of the event
2456 * \param y The scaled y co-ordinate of the event
2457 * \param file filename to be put in the widget
2458 */
2459static bool
2460browser_window_drop_file_at_point_internal(struct browser_window *bw,
2461 int x, int y,
2462 char *file)
2463{
2464 assert(bw != NULL);
2465
2466 /* Handle (i)frame scroll offset (core-managed browser windows only) */
2467 x += scrollbar_get_offset(bw->scroll_x);
2468 y += scrollbar_get_offset(bw->scroll_y);
2469
2470 if (bw->children) {
2471 /* Browser window has children, so pass request on to
2472 * appropriate child */
2473 struct browser_window *bwc;
2474 int cur_child;
2475 int children = bw->rows * bw->cols;
2476
2477 /* Loop through all children of bw */
2478 for (cur_child = 0; cur_child < children; cur_child++) {
2479 /* Set current child */
2480 bwc = &bw->children[cur_child];
2481
2482 /* Skip this frame if (x, y) coord lies outside */
2483 if (x < bwc->x || bwc->x + bwc->width < x ||
2484 y < bwc->y || bwc->y + bwc->height < y)
2485 continue;
2486
2487 /* Pass request into this child */
2488 return browser_window_drop_file_at_point_internal(
2489 bwc,
2490 (x - bwc->x),
2491 (y - bwc->y),
2492 file);
2493 }
2494 }
2495
2496 /* Pass file drop on to any content */
2497 if (bw->current_content != NULL) {
2498 return content_drop_file_at_point(bw->current_content,
2499 x, y, file);
2500 }
2501
2502 return false;
2503}
2504
2505
2506/**
2507 * Check if this is an internal navigation URL.
2508 *
2509 * This safely checks if the given url is an internal navigation even
2510 * for urls with no scheme or path.
2511 *
2512 * \param url The URL to check
2513 * \return true if an internal navigation url else false
2514 */
2515static bool
2516is_internal_navigate_url(nsurl *url)
2517{
2518 bool is_internal = false;
2519 lwc_string *scheme, *path;
2520
2521 scheme = nsurl_get_component(url, NSURL_SCHEME);
2522 if (scheme != NULL) {
2523 path = nsurl_get_component(url, NSURL_PATH);
2524 if (path != NULL) {
2525 if (scheme == corestring_lwc_about) {
2526 if (path == corestring_lwc_query_auth) {
2527 is_internal = true;
2528 } else if (path == corestring_lwc_query_ssl) {
2529 is_internal = true;
2530 } else if (path == corestring_lwc_query_timeout) {
2531 is_internal = true;
2532 } else if (path == corestring_lwc_query_fetcherror) {
2533 is_internal = true;
2534 }
2535 }
2536 lwc_string_unref(path);
2537 }
2538 lwc_string_unref(scheme);
2539 }
2540 return is_internal;
2541}
2542
2543
2544/* exported interface, documented in netsurf/browser_window.h */
2545nserror
2546browser_window_get_name(struct browser_window *bw, const char **out_name)
2547{
2548 assert(bw != NULL);
2549
2550 *out_name = bw->name;
2551
2552 return NSERROR_OK;
2553}
2554
2555
2556/* exported interface, documented in netsurf/browser_window.h */
2557nserror
2558browser_window_set_name(struct browser_window *bw, const char *name)
2559{
2560 char *nname = NULL;
2561
2562 assert(bw != NULL);
2563
2564 if (name != NULL) {
2565 nname = strdup(name);
2566 if (nname == NULL) {
2567 return NSERROR_NOMEM;
2568 }
2569 }
2570
2571 if (bw->name != NULL) {
2572 free(bw->name);
2573 }
2574
2575 bw->name = nname;
2576
2577 return NSERROR_OK;
2578}
2579
2580
2581/* exported interface, documented in netsurf/browser_window.h */
2582bool
2583browser_window_redraw(struct browser_window *bw,
2584 int x, int y,
2585 const struct rect *clip,
2586 const struct redraw_context *ctx)
2587{
2588 struct redraw_context new_ctx = *ctx;
2589 int width = 0;
2590 int height = 0;
2591 bool plot_ok = true;
2592 content_type content_type;
2593 struct content_redraw_data data;
2594 struct rect content_clip;
2595 nserror res;
2596
2597 if (bw == NULL) {
2598 NSLOG(netsurf, INFO, "NULL browser window");
2599 return false;
2600 }
2601
2602 x /= bw->scale;
2603 y /= bw->scale;
2604
2605 if ((bw->current_content == NULL) &&
2606 (bw->children == NULL)) {
2607 /* Browser window has no content, render blank fill */
2608 ctx->plot->clip(ctx, clip);
2609 return (ctx->plot->rectangle(ctx, plot_style_fill_white, clip) == NSERROR_OK);
2610 }
2611
2612 /* Browser window has content OR children (frames) */
2613 if ((bw->window != NULL) &&
2614 (ctx->plot->option_knockout)) {
2615 /* Root browser window: start knockout */
2616 knockout_plot_start(ctx, &new_ctx);
2617 }
2618
2619 new_ctx.plot->clip(ctx, clip);
2620
2621 /* Handle redraw of any browser window children */
2622 if (bw->children) {
2623 struct browser_window *child;
2624 int cur_child;
2625 int children = bw->rows * bw->cols;
2626
2627 if (bw->window != NULL) {
2628 /* Root browser window; start with blank fill */
2629 plot_ok &= (new_ctx.plot->rectangle(ctx,
2630 plot_style_fill_white,
2631 clip) == NSERROR_OK);
2632 }
2633
2634 /* Loop through all children of bw */
2635 for (cur_child = 0; cur_child < children; cur_child++) {
2636 /* Set current child */
2637 child = &bw->children[cur_child];
2638
2639 /* Get frame edge area in global coordinates */
2640 content_clip.x0 = (x + child->x) * child->scale;
2641 content_clip.y0 = (y + child->y) * child->scale;
2642 content_clip.x1 = content_clip.x0 +
2643 child->width * child->scale;
2644 content_clip.y1 = content_clip.y0 +
2645 child->height * child->scale;
2646
2647 /* Intersect it with clip rectangle */
2648 if (content_clip.x0 < clip->x0)
2649 content_clip.x0 = clip->x0;
2650 if (content_clip.y0 < clip->y0)
2651 content_clip.y0 = clip->y0;
2652 if (clip->x1 < content_clip.x1)
2653 content_clip.x1 = clip->x1;
2654 if (clip->y1 < content_clip.y1)
2655 content_clip.y1 = clip->y1;
2656
2657 /* Skip this frame if it lies outside clip rectangle */
2658 if (content_clip.x0 >= content_clip.x1 ||
2659 content_clip.y0 >= content_clip.y1)
2660 continue;
2661
2662 /* Redraw frame */
2663 plot_ok &= browser_window_redraw(child,
2664 x + child->x,
2665 y + child->y,
2666 &content_clip,
2667 &new_ctx);
2668 }
2669
2670 /* Nothing else to redraw for browser windows with children;
2671 * cleanup and return
2672 */
2673 if (bw->window != NULL && ctx->plot->option_knockout) {
2674 /* Root browser window: knockout end */
2675 knockout_plot_end(ctx);
2676 }
2677
2678 return plot_ok;
2679 }
2680
2681 /* Handle browser windows with content to redraw */
2682
2683 content_type = content_get_type(bw->current_content);
2684 if (content_type != CONTENT_HTML && content_type != CONTENT_TEXTPLAIN) {
2685 /* Set render area according to scale */
2686 width = content_get_width(bw->current_content) * bw->scale;
2687 height = content_get_height(bw->current_content) * bw->scale;
2688
2689 /* Non-HTML may not fill viewport to extents, so plot white
2690 * background fill */
2691 plot_ok &= (new_ctx.plot->rectangle(&new_ctx,
2692 plot_style_fill_white,
2693 clip) == NSERROR_OK);
2694 }
2695
2696 /* Set up content redraw data */
2697 data.x = x - scrollbar_get_offset(bw->scroll_x);
2698 data.y = y - scrollbar_get_offset(bw->scroll_y);
2699 data.width = width;
2700 data.height = height;
2701
2702 data.background_colour = 0xFFFFFF;
2703 data.scale = bw->scale;
2704 data.repeat_x = false;
2705 data.repeat_y = false;
2706
2707 content_clip = *clip;
2708
2709 if (!bw->window) {
2710 int x0 = x * bw->scale;
2711 int y0 = y * bw->scale;
2712 int x1 = (x + bw->width - ((bw->scroll_y != NULL) ?
2713 SCROLLBAR_WIDTH : 0)) * bw->scale;
2714 int y1 = (y + bw->height - ((bw->scroll_x != NULL) ?
2715 SCROLLBAR_WIDTH : 0)) * bw->scale;
2716
2717 if (content_clip.x0 < x0) content_clip.x0 = x0;
2718 if (content_clip.y0 < y0) content_clip.y0 = y0;
2719 if (x1 < content_clip.x1) content_clip.x1 = x1;
2720 if (y1 < content_clip.y1) content_clip.y1 = y1;
2721 }
2722
2723 /* Render the content */
2724 plot_ok &= content_redraw(bw->current_content, &data,
2725 &content_clip, &new_ctx);
2726
2727 /* Back to full clip rect */
2728 new_ctx.plot->clip(&new_ctx, clip);
2729
2730 if (!bw->window) {
2731 /* Render scrollbars */
2732 int off_x, off_y;
2733 if (bw->scroll_x != NULL) {
2734 browser_window_get_scrollbar_pos(bw, true,
2735 &off_x, &off_y);
2736 res = scrollbar_redraw(bw->scroll_x,
2737 x + off_x, y + off_y, clip,
2738 bw->scale, &new_ctx);
2739 if (res != NSERROR_OK) {
2740 plot_ok = false;
2741 }
2742 }
2743 if (bw->scroll_y != NULL) {
2744 browser_window_get_scrollbar_pos(bw, false,
2745 &off_x, &off_y);
2746 res = scrollbar_redraw(bw->scroll_y,
2747 x + off_x, y + off_y, clip,
2748 bw->scale, &new_ctx);
2749 if (res != NSERROR_OK) {
2750 plot_ok = false;
2751 }
2752 }
2753 }
2754
2755 if (bw->window != NULL && ctx->plot->option_knockout) {
2756 /* Root browser window: end knockout */
2757 knockout_plot_end(ctx);
2758 }
2759
2760 return plot_ok;
2761}
2762
2763
2764/* exported interface, documented in netsurf/browser_window.h */
2765bool browser_window_redraw_ready(struct browser_window *bw)
2766{
2767 if (bw == NULL) {
2768 NSLOG(netsurf, INFO, "NULL browser window");
2769 return false;
2770 } else if (bw->current_content != NULL) {
2771 /* Can't render locked contents */
2772 return !content_is_locked(bw->current_content);
2773 }
2774
2775 return true;
2776}
2777
2778
2779/* exported interface, documented in browser_private.h */
2780void browser_window_update_extent(struct browser_window *bw)
2781{
2782 if (bw->window != NULL) {
2783 /* Front end window */
2784 guit->window->event(bw->window, GW_EVENT_UPDATE_EXTENT);
2785 } else {
2786 /* Core-managed browser window */
2787 browser_window_handle_scrollbars(bw);
2788 }
2789}
2790
2791
2792/* exported interface, documented in netsurf/browser_window.h */
2793void
2794browser_window_get_position(struct browser_window *bw,
2795 bool root,
2796 int *pos_x,
2797 int *pos_y)
2798{
2799 *pos_x = 0;
2800 *pos_y = 0;
2801
2802 assert(bw != NULL);
2803
2804 while (bw) {
2805 switch (bw->browser_window_type) {
2806
2807 case BROWSER_WINDOW_FRAMESET:
2808 *pos_x += bw->x * bw->scale;
2809 *pos_y += bw->y * bw->scale;
2810 break;
2811
2812 case BROWSER_WINDOW_NORMAL:
2813 /* There is no offset to the root browser window */
2814 break;
2815
2816 case BROWSER_WINDOW_FRAME:
2817 /* Iframe and Frame handling is identical;
2818 * fall though */
2819 case BROWSER_WINDOW_IFRAME:
2820 *pos_x += (bw->x - scrollbar_get_offset(bw->scroll_x)) *
2821 bw->scale;
2822 *pos_y += (bw->y - scrollbar_get_offset(bw->scroll_y)) *
2823 bw->scale;
2824 break;
2825 }
2826
2827 bw = bw->parent;
2828
2829 if (!root) {
2830 /* return if we just wanted the position in the parent
2831 * browser window. */
2832 return;
2833 }
2834 }
2835}
2836
2837
2838/* exported interface, documented in netsurf/browser_window.h */
2839void browser_window_set_position(struct browser_window *bw, int x, int y)
2840{
2841 assert(bw != NULL);
2842
2843 if (bw->window == NULL) {
2844 /* Core managed browser window */
2845 bw->x = x;
2846 bw->y = y;
2847 } else {
2848 NSLOG(netsurf, INFO,
2849 "Asked to set position of front end window.");
2850 assert(0);
2851 }
2852}
2853
2854
2855/* exported interface, documented in netsurf/browser_window.h */
2856void
2857browser_window_set_drag_type(struct browser_window *bw,
2858 browser_drag_type type,
2859 const struct rect *rect)
2860{
2861 struct browser_window *top_bw = browser_window_get_root(bw);
2862 gui_drag_type gtype;
2863
2864 bw->drag.type = type;
2865
2866 if (type == DRAGGING_NONE) {
2867 top_bw->drag.window = NULL;
2868 } else {
2869 top_bw->drag.window = bw;
2870
2871 switch (type) {
2872 case DRAGGING_SELECTION:
2873 /** \todo tell front end */
2874 return;
2875 case DRAGGING_SCR_X:
2876 case DRAGGING_SCR_Y:
2877 case DRAGGING_CONTENT_SCROLLBAR:
2878 gtype = GDRAGGING_SCROLLBAR;
2879 break;
2880 default:
2881 gtype = GDRAGGING_OTHER;
2882 break;
2883 }
2884
2885 guit->window->drag_start(top_bw->window, gtype, rect);
2886 }
2887}
2888
2889
2890/* exported interface, documented in netsurf/browser_window.h */
2891browser_drag_type browser_window_get_drag_type(struct browser_window *bw)
2892{
2893 return bw->drag.type;
2894}
2895
2896
2897/* exported interface, documented in netsurf/browser_window.h */
2898struct browser_window * browser_window_get_root(struct browser_window *bw)
2899{
2900 while (bw && bw->parent) {
2901 bw = bw->parent;
2902 }
2903 return bw;
2904}
2905
2906
2907/* exported interface, documented in netsurf/browser_window.h */
2908browser_editor_flags browser_window_get_editor_flags(struct browser_window *bw)
2909{
2910 browser_editor_flags ed_flags = BW_EDITOR_NONE;
2911 assert(bw->window);
2912 assert(bw->parent == NULL);
2913
2914 if (bw->selection.bw != NULL) {
2915 ed_flags |= BW_EDITOR_CAN_COPY;
2916
2917 if (!bw->selection.read_only)
2918 ed_flags |= BW_EDITOR_CAN_CUT;
2919 }
2920
2921 if (bw->can_edit)
2922 ed_flags |= BW_EDITOR_CAN_PASTE;
2923
2924 return ed_flags;
2925}
2926
2927
2928/* exported interface, documented in netsurf/browser_window.h */
2929bool browser_window_can_select(struct browser_window *bw)
2930{
2931 if (bw == NULL || bw->current_content == NULL)
2932 return false;
2933
2934 /* TODO: We shouldn't have to know about specific content types
2935 * here. There should be a content_is_selectable() call. */
2936 if (content_get_type(bw->current_content) != CONTENT_HTML &&
2937 content_get_type(bw->current_content) !=
2938 CONTENT_TEXTPLAIN)
2939 return false;
2940
2941 return true;
2942}
2943
2944
2945/* exported interface, documented in netsurf/browser_window.h */
2946char * browser_window_get_selection(struct browser_window *bw)
2947{
2948 assert(bw->window);
2949 assert(bw->parent == NULL);
2950
2951 if (bw->selection.bw == NULL ||
2952 bw->selection.bw->current_content == NULL)
2953 return NULL;
2954
2955 return content_get_selection(bw->selection.bw->current_content);
2956}
2957
2958
2959/* exported interface, documented in netsurf/browser_window.h */
2960bool browser_window_can_search(struct browser_window *bw)
2961{
2962 if (bw == NULL || bw->current_content == NULL)
2963 return false;
2964
2965 /** \todo We shouldn't have to know about specific content
2966 * types here. There should be a content_is_searchable() call.
2967 */
2968 if ((content_get_type(bw->current_content) != CONTENT_HTML) &&
2969 (content_get_type(bw->current_content) != CONTENT_TEXTPLAIN)) {
2970 return false;
2971 }
2972
2973 return true;
2974}
2975
2976
2977/* exported interface, documented in netsurf/browser_window.h */
2978bool browser_window_is_frameset(struct browser_window *bw)
2979{
2980 return (bw->children != NULL);
2981}
2982
2983
2984/* exported interface, documented in netsurf/browser_window.h */
2985nserror
2986browser_window_get_scrollbar_type(struct browser_window *bw,
2987 browser_scrolling *h,
2988 browser_scrolling *v)
2989{
2990 *h = bw->scrolling;
2991 *v = bw->scrolling;
2992
2993 return NSERROR_OK;
2994}
2995
2996
2997/* exported interface, documented in netsurf/browser_window.h */
2998nserror
2999browser_window_get_features(struct browser_window *bw,
3000 int x, int y,
3001 struct browser_window_features *data)
3002{
3003 /* clear the features structure to empty values */
3004 data->link = NULL;
3005 data->object = NULL;
3006 data->main = NULL;
3007 data->form_features = CTX_FORM_NONE;
3008
3009 return browser_window__get_contextual_content(bw,
3010 x / bw->scale,
3011 y / bw->scale,
3012 data);
3013}
3014
3015
3016/* exported interface, documented in netsurf/browser_window.h */
3017bool
3018browser_window_scroll_at_point(struct browser_window *bw,
3019 int x, int y,
3020 int scrx, int scry)
3021{
3022 return browser_window_scroll_at_point_internal(bw,
3023 x / bw->scale,
3024 y / bw->scale,
3025 scrx,
3026 scry);
3027}
3028
3029
3030/* exported interface, documented in netsurf/browser_window.h */
3031bool
3032browser_window_drop_file_at_point(struct browser_window *bw,
3033 int x, int y,
3034 char *file)
3035{
3036 return browser_window_drop_file_at_point_internal(bw,
3037 x / bw->scale,
3038 y / bw->scale,
3039 file);
3040}
3041
3042
3043/* exported interface, documented in netsurf/browser_window.h */
3044void
3045browser_window_set_gadget_filename(struct browser_window *bw,
3046 struct form_control *gadget,
3047 const char *fn)
3048{
3049 html_set_file_gadget_filename(bw->current_content, gadget, fn);
3050}
3051
3052
3053/* exported interface, documented in netsurf/browser_window.h */
3054nserror
3055browser_window_debug_dump(struct browser_window *bw,
3056 FILE *f,
3057 enum content_debug op)
3058{
3059 if (bw->current_content != NULL) {
3060 return content_debug_dump(bw->current_content, f, op);
3061 }
3062 return NSERROR_OK;
3063}
3064
3065
3066/* exported interface, documented in netsurf/browser_window.h */
3067nserror browser_window_debug(struct browser_window *bw, enum content_debug op)
3068{
3069 if (bw->current_content != NULL) {
3070 return content_debug(bw->current_content, op);
3071 }
3072 return NSERROR_OK;
3073}
3074
3075
3076/* exported interface, documented in netsurf/browser_window.h */
3077nserror
3078browser_window_create(enum browser_window_create_flags flags,
3079 nsurl *url,
3080 nsurl *referrer,
3081 struct browser_window *existing,
3082 struct browser_window **bw)
3083{
3084 gui_window_create_flags gw_flags = GW_CREATE_NONE;
3085 struct browser_window *ret;
3086 nserror err;
3087
3088 /* Check parameters */
3089 if (flags & BW_CREATE_CLONE) {
3090 if (existing == NULL) {
3091 assert(0 && "Failed: No existing window provided.");
3092 return NSERROR_BAD_PARAMETER;
3093 }
3094 }
3095
3096 if (!(flags & BW_CREATE_HISTORY)) {
3097 if (!(flags & BW_CREATE_CLONE) || existing == NULL) {
3098 assert(0 && "Failed: Must have existing for history.");
3099 return NSERROR_BAD_PARAMETER;
3100 }
3101 }
3102
3103 ret = calloc(1, sizeof(struct browser_window));
3104 if (ret == NULL) {
3105 return NSERROR_NOMEM;
3106 }
3107
3108 /* Initialise common parts */
3109 err = browser_window_initialise_common(flags, ret, existing);
3110 if (err != NSERROR_OK) {
3111 browser_window_destroy(ret);
3112 return err;
3113 }
3114
3115 /* window characteristics */
3116 ret->browser_window_type = BROWSER_WINDOW_NORMAL;
3117 ret->scrolling = BW_SCROLLING_YES;
3118 ret->border = true;
3119 ret->no_resize = true;
3120 ret->focus = ret;
3121
3122 /* initialise last action with creation time */
3123 nsu_getmonotonic_ms(&ret->last_action);
3124
3125 /* The existing gui_window is on the top-level existing
3126 * browser_window. */
3127 existing = browser_window_get_root(existing);
3128
3129 /* Set up gui_window creation flags */
3130 if (flags & BW_CREATE_TAB)
3131 gw_flags |= GW_CREATE_TAB;
3132 if (flags & BW_CREATE_CLONE)
3133 gw_flags |= GW_CREATE_CLONE;
3134 if (flags & BW_CREATE_FOREGROUND)
3135 gw_flags |= GW_CREATE_FOREGROUND;
3136 if (flags & BW_CREATE_FOCUS_LOCATION)
3137 gw_flags |= GW_CREATE_FOCUS_LOCATION;
3138
3139 ret->window = guit->window->create(ret,
3140 (existing != NULL) ? existing->window : NULL,
3141 gw_flags);
3142
3143 if (ret->window == NULL) {
3144 browser_window_destroy(ret);
3145 return NSERROR_BAD_PARAMETER;
3146 }
3147
3148 if (url != NULL) {
3149 enum browser_window_nav_flags nav_flags;
3150 nav_flags = BW_NAVIGATE_NO_TERMINAL_HISTORY_UPDATE;
3151 if (flags & BW_CREATE_UNVERIFIABLE) {
3152 nav_flags |= BW_NAVIGATE_UNVERIFIABLE;
3153 }
3154 if (flags & BW_CREATE_HISTORY) {
3155 nav_flags |= BW_NAVIGATE_HISTORY;
3156 }
3157 browser_window_navigate(ret,
3158 url,
3159 referrer,
3160 nav_flags,
3161 NULL,
3162 NULL,
3163 NULL);
3164 }
3165
3166 if (bw != NULL) {
3167 *bw = ret;
3168 }
3169
3170 return NSERROR_OK;
3171}
3172
3173
3174/* exported internal interface, documented in desktop/browser_private.h */
3175nserror
3176browser_window_initialise_common(enum browser_window_create_flags flags,
3177 struct browser_window *bw,
3178 const struct browser_window *existing)
3179{
3180 nserror err;
3181 assert(bw);
3182
3183 /* new javascript context for each window/(i)frame */
3184 err = js_newheap(nsoption_int(script_timeout), &bw->jsheap);
3185 if (err != NSERROR_OK)
3186 return err;
3187
3188 if (flags & BW_CREATE_CLONE) {
3189 assert(existing != NULL);
3190
3191 /* clone history */
3192 err = browser_window_history_clone(existing, bw);
3193
3194 /* copy the scale */
3195 bw->scale = existing->scale;
3196 } else {
3197 /* create history */
3198 err = browser_window_history_create(bw);
3199
3200 /* default scale */
3201 bw->scale = (float) nsoption_int(scale) / 100.0;
3202 }
3203
3204 if (err != NSERROR_OK)
3205 return err;
3206
3207 /* window characteristics */
3208 bw->refresh_interval = -1;
3209
3210 bw->drag.type = DRAGGING_NONE;
3211
3212 bw->scroll_x = NULL;
3213 bw->scroll_y = NULL;
3214
3215 bw->focus = NULL;
3216
3217 /* initialise status text cache */
3218 bw->status.text = NULL;
3219 bw->status.text_len = 0;
3220 bw->status.match = 0;
3221 bw->status.miss = 0;
3222
3223 return NSERROR_OK;
3224}
3225
3226
3227/* exported interface, documented in netsurf/browser_window.h */
3228void browser_window_destroy(struct browser_window *bw)
3229{
3230 /* can't destoy child windows on their own */
3231 assert(!bw->parent);
3232
3233 /* destroy */
3234 browser_window_destroy_internal(bw);
3235 free(bw);
3236}
3237
3238
3239/* exported interface, documented in netsurf/browser_window.h */
3240nserror browser_window_refresh_url_bar(struct browser_window *bw)
3241{
3242 nserror ret;
3243 nsurl *display_url, *url;
3244
3245 assert(bw);
3246
3247 if (bw->parent != NULL) {
3248 /* Not root window; don't set a URL in GUI URL bar */
3249 return NSERROR_OK;
3250 }
3251
3252 if (bw->current_content == NULL) {
3253 /* no content so return about:blank */
3254 ret = browser_window_refresh_url_bar_internal(bw,
3255 corestring_nsurl_about_blank);
3256 } else if (bw->throbbing && bw->loading_parameters.url != NULL) {
3257 /* Throbbing and we have loading parameters, use those */
3258 url = bw->loading_parameters.url;
3259 ret = browser_window_refresh_url_bar_internal(bw, url);
3260 } else if (bw->frag_id == NULL) {
3261 if (bw->internal_nav) {
3262 url = bw->loading_parameters.url;
3263 } else {
3264 url = hlcache_handle_get_url(bw->current_content);
3265 }
3266 ret = browser_window_refresh_url_bar_internal(bw, url);
3267 } else {
3268 /* Combine URL and Fragment */
3269 if (bw->internal_nav) {
3270 url = bw->loading_parameters.url;
3271 } else {
3272 url = hlcache_handle_get_url(bw->current_content);
3273 }
3274 ret = nsurl_refragment(
3275 url,
3276 bw->frag_id, &display_url);
3277 if (ret == NSERROR_OK) {
3278 ret = browser_window_refresh_url_bar_internal(bw,
3279 display_url);
3280 nsurl_unref(display_url);
3281 }
3282 }
3283
3284 return ret;
3285}
3286
3287
3288/* exported interface documented in netsurf/browser_window.h */
3289nserror
3290browser_window_navigate(struct browser_window *bw,
3291 nsurl *url,
3292 nsurl *referrer,
3293 enum browser_window_nav_flags flags,
3294 char *post_urlenc,
3295 struct fetch_multipart_data *post_multipart,
3296 hlcache_handle *parent)
3297{
3298 int depth = 0;
3299 struct browser_window *cur;
3300 uint32_t fetch_flags = 0;
3301 bool fetch_is_post = (post_urlenc != NULL || post_multipart != NULL);
3302 llcache_post_data post;
3303 hlcache_child_context child;
3304 nserror error;
3305 bool is_internal = false;
3306 struct browser_fetch_parameters params, *pass_params = NULL;
3307
3308 assert(bw);
3309 assert(url);
3310
3311 NSLOG(netsurf, INFO, "bw %p, url %s", bw, nsurl_access(url));
3312
3313 /*
3314 * determine if navigation is internal url, if so, we do not
3315 * do certain things during the load.
3316 */
3317 is_internal = is_internal_navigate_url(url);
3318
3319 if (is_internal &&
3320 !(flags & BW_NAVIGATE_INTERNAL)) {
3321 /* Internal navigation detected, but flag not set, only allow
3322 * this is there's a fetch multipart
3323 */
3324 if (post_multipart == NULL) {
3325 return NSERROR_NEED_DATA;
3326 }
3327 /* It *is* internal, set it as such */
3328 flags |= BW_NAVIGATE_INTERNAL | BW_NAVIGATE_HISTORY;
3329 /* If we were previously internal, don't update again */
3330 if (bw->internal_nav) {
3331 flags |= BW_NAVIGATE_NO_TERMINAL_HISTORY_UPDATE;
3332 }
3333 }
3334
3335 /* If we're navigating and we have a history entry and a content
3336 * then update the history entry before we navigate to save our
3337 * current state. However since history navigation pre-moves
3338 * the history state, we ensure that we only do this if we've not
3339 * been suppressed. In the suppressed case, the history code
3340 * updates the history itself before navigating.
3341 */
3342 if (bw->current_content != NULL &&
3343 bw->history != NULL &&
3344 bw->history->current != NULL &&
3345 !is_internal &&
3346 !(flags & BW_NAVIGATE_NO_TERMINAL_HISTORY_UPDATE)) {
3347 browser_window_history_update(bw, bw->current_content);
3348 }
3349
3350 /* don't allow massively nested framesets */
3351 for (cur = bw; cur->parent; cur = cur->parent) {
3352 depth++;
3353 }
3354 if (depth > FRAME_DEPTH) {
3355 NSLOG(netsurf, INFO, "frame depth too high.");
3356 return NSERROR_FRAME_DEPTH;
3357 }
3358
3359 /* Set up retrieval parameters */
3360 if (!(flags & BW_NAVIGATE_UNVERIFIABLE)) {
3361 fetch_flags |= LLCACHE_RETRIEVE_VERIFIABLE;
3362 }
3363
3364 if (post_multipart != NULL) {
3365 post.type = LLCACHE_POST_MULTIPART;
3366 post.data.multipart = post_multipart;
3367 } else if (post_urlenc != NULL) {
3368 post.type = LLCACHE_POST_URL_ENCODED;
3369 post.data.urlenc = post_urlenc;
3370 }
3371
3372 child.charset = content_get_encoding(parent, CONTENT_ENCODING_NORMAL);
3373 if ((parent != NULL) && (content_get_type(parent) == CONTENT_HTML)) {
3374 child.quirks = content_get_quirks(parent);
3375 } else {
3376 child.quirks = false;
3377 }
3378
3379 url = nsurl_ref(url);
3380
3381 if (referrer != NULL) {
3382 referrer = nsurl_ref(referrer);
3383 }
3384
3385 /* Get download out of the way */
3386 if ((flags & BW_NAVIGATE_DOWNLOAD) != 0) {
3387 error = browser_window_download(bw,
3388 url,
3389 referrer,
3390 fetch_flags,
3391 fetch_is_post,
3392 &post);
3393 nsurl_unref(url);
3394 if (referrer != NULL) {
3395 nsurl_unref(referrer);
3396 }
3397 return error;
3398 }
3399
3400 if (bw->frag_id != NULL) {
3401 lwc_string_unref(bw->frag_id);
3402 }
3403 bw->frag_id = NULL;
3404
3405 if (nsurl_has_component(url, NSURL_FRAGMENT)) {
3406 bool same_url = false;
3407
3408 bw->frag_id = nsurl_get_component(url, NSURL_FRAGMENT);
3409
3410 /* Compare new URL with existing one (ignoring fragments) */
3411 if ((bw->current_content != NULL) &&
3412 (hlcache_handle_get_url(bw->current_content) != NULL)) {
3413 same_url = nsurl_compare(
3414 url,
3415 hlcache_handle_get_url(bw->current_content),
3416 NSURL_COMPLETE);
3417 }
3418
3419 /* if we're simply moving to another ID on the same page,
3420 * don't bother to fetch, just update the window.
3421 */
3422 if ((same_url) &&
3423 (fetch_is_post == false) &&
3424 (nsurl_has_component(url, NSURL_QUERY) == false)) {
3425 nsurl_unref(url);
3426
3427 if (referrer != NULL) {
3428 nsurl_unref(referrer);
3429 }
3430
3431 if ((flags & BW_NAVIGATE_HISTORY) != 0) {
3432 browser_window_history_add(bw,
3433 bw->current_content,
3434 bw->frag_id);
3435 }
3436
3437 browser_window_update(bw, false);
3438
3439 if (bw->current_content != NULL) {
3440 browser_window_refresh_url_bar(bw);
3441 }
3442 return NSERROR_OK;
3443 }
3444 }
3445
3446 browser_window_stop(bw);
3447 browser_window_remove_caret(bw, false);
3448 browser_window_destroy_children(bw);
3449 browser_window_destroy_iframes(bw);
3450
3451 /* Set up the fetch parameters */
3452 memset(&params, 0, sizeof(params));
3453
3454 params.url = nsurl_ref(url);
3455
3456 if (referrer != NULL) {
3457 params.referrer = nsurl_ref(referrer);
3458 }
3459
3460 params.flags = flags;
3461
3462 if (post_urlenc != NULL) {
3463 params.post_urlenc = strdup(post_urlenc);
3464 }
3465
3466 if (post_multipart != NULL) {
3467 params.post_multipart = fetch_multipart_data_clone(post_multipart);
3468 }
3469
3470 if (parent != NULL) {
3471 params.parent_charset = strdup(child.charset);
3472 params.parent_quirks = child.quirks;
3473 }
3474
3475 bw->internal_nav = is_internal;
3476
3477 if (is_internal) {
3478 pass_params = &params;
3479 } else {
3480 /* At this point, we're navigating, so store the fetch parameters */
3481 browser_window__free_fetch_parameters(&bw->loading_parameters);
3482 memcpy(&bw->loading_parameters, &params, sizeof(params));
3483 memset(&params, 0, sizeof(params));
3484 pass_params = &bw->loading_parameters;
3485 }
3486
3487 error = browser_window__navigate_internal(bw, pass_params);
3488
3489 nsurl_unref(url);
3490
3491 if (referrer != NULL) {
3492 nsurl_unref(referrer);
3493 }
3494
3495 if (is_internal) {
3496 browser_window__free_fetch_parameters(&params);
3497 }
3498
3499 return error;
3500}
3501
3502
3503/**
3504 * Internal navigation handler for normal fetches
3505 */
3506static nserror
3507navigate_internal_real(struct browser_window *bw,
3508 struct browser_fetch_parameters *params)
3509{
3510 uint32_t fetch_flags = 0;
3511 bool fetch_is_post;
3512 llcache_post_data post;
3513 hlcache_child_context child;
3514 nserror res;
3515 hlcache_handle *c;
3516
3517 NSLOG(netsurf, INFO, "Loading '%s'", nsurl_access(params->url));
3518
3519 fetch_is_post = (params->post_urlenc != NULL || params->post_multipart != NULL);
3520
3521 /* Clear SSL info for load */
3522 cert_chain_free(bw->loading_cert_chain);
3523 bw->loading_cert_chain = NULL;
3524
3525 /* Set up retrieval parameters */
3526 if (!(params->flags & BW_NAVIGATE_UNVERIFIABLE)) {
3527 fetch_flags |= LLCACHE_RETRIEVE_VERIFIABLE;
3528 }
3529
3530 if (params->post_multipart != NULL) {
3531 post.type = LLCACHE_POST_MULTIPART;
3532 post.data.multipart = params->post_multipart;
3533 } else if (params->post_urlenc != NULL) {
3534 post.type = LLCACHE_POST_URL_ENCODED;
3535 post.data.urlenc = params->post_urlenc;
3536 }
3537
3538 if (params->parent_charset != NULL) {
3539 child.charset = params->parent_charset;
3540 child.quirks = params->parent_quirks;
3541 }
3542
3543 browser_window_set_status(bw, messages_get("Loading"));
3544 bw->history_add = (params->flags & BW_NAVIGATE_HISTORY);
3545
3546 /* Verifiable fetches may trigger a download */
3547 if (!(params->flags & BW_NAVIGATE_UNVERIFIABLE)) {
3548 fetch_flags |= HLCACHE_RETRIEVE_MAY_DOWNLOAD;
3549 }
3550
3551 res = hlcache_handle_retrieve(params->url,
3552 fetch_flags | HLCACHE_RETRIEVE_SNIFF_TYPE,
3553 params->referrer,
3554 fetch_is_post ? &post : NULL,
3555 browser_window_callback,
3556 bw,
3557 params->parent_charset != NULL ? &child : NULL,
3558 CONTENT_ANY,
3559 &c);
3560
3561 switch (res) {
3562 case NSERROR_OK:
3563 bw->loading_content = c;
3564 browser_window_start_throbber(bw);
3565 if (bw->window != NULL) {
3566 guit->window->set_icon(bw->window, NULL);
3567 }
3568 if (bw->internal_nav == false) {
3569 res = browser_window_refresh_url_bar_internal(bw,
3570 params->url);
3571 }
3572 break;
3573
3574 case NSERROR_NO_FETCH_HANDLER: /* no handler for this type */
3575 /** \todo does this always try and download even
3576 * unverifiable content?
3577 */
3578 res = guit->misc->launch_url(params->url);
3579 break;
3580
3581 default: /* report error to user */
3582 browser_window_set_status(bw, messages_get_errorcode(res));
3583 break;
3584
3585 }
3586
3587 /* Record time */
3588 nsu_getmonotonic_ms(&bw->last_action);
3589
3590 return res;
3591}
3592
3593
3594/**
3595 * Internal navigation handler for the authentication query handler
3596 *
3597 * If the parameters indicate we're processing a *response* from the handler
3598 * then we deal with that, otherwise we pass it on to the about: handler
3599 */
3600static nserror
3601navigate_internal_query_auth(struct browser_window *bw,
3602 struct browser_fetch_parameters *params)
3603{
3604 char *userpass = NULL;
3605 const char *username, *password, *realm, *siteurl;
3606 nsurl *sitensurl;
3607 nserror res;
3608 bool is_login = false, is_cancel = false;
3609
3610 assert(params->post_multipart != NULL);
3611
3612 is_login = fetch_multipart_data_find(params->post_multipart, "login") != NULL;
3613 is_cancel = fetch_multipart_data_find(params->post_multipart, "cancel") != NULL;
3614
3615 if (!(is_login || is_cancel)) {
3616 /* This is a request, so pass it on */
3617 return navigate_internal_real(bw, params);
3618 }
3619
3620 if (is_cancel) {
3621 /* We're processing a cancel, do a rough-and-ready nav to
3622 * about:blank
3623 */
3624 browser_window__free_fetch_parameters(&bw->loading_parameters);
3625 bw->loading_parameters.url = nsurl_ref(corestring_nsurl_about_blank);
3626 bw->loading_parameters.flags = BW_NAVIGATE_NO_TERMINAL_HISTORY_UPDATE | BW_NAVIGATE_INTERNAL;
3627 bw->internal_nav = true;
3628 return browser_window__navigate_internal(bw, &bw->loading_parameters);
3629 }
3630
3631 /* We're processing a "login" attempt from the form */
3632
3633 /* Retrieve the data */
3634 username = fetch_multipart_data_find(params->post_multipart, "username");
3635 password = fetch_multipart_data_find(params->post_multipart, "password");
3636 realm = fetch_multipart_data_find(params->post_multipart, "realm");
3637 siteurl = fetch_multipart_data_find(params->post_multipart, "siteurl");
3638
3639 if (username == NULL || password == NULL ||
3640 realm == NULL || siteurl == NULL) {
3641 /* Bad inputs, simply fail */
3642 return NSERROR_INVALID;
3643 }
3644
3645 /* Parse the URL */
3646 res = nsurl_create(siteurl, &sitensurl);
3647 if (res != NSERROR_OK) {
3648 return res;
3649 }
3650
3651 /* Construct the username/password */
3652 res = browser_window__build_userpass(username, password, &userpass);
3653 if (res != NSERROR_OK) {
3654 nsurl_unref(sitensurl);
3655 return res;
3656 }
3657
3658 /* And let urldb know */
3659 urldb_set_auth_details(sitensurl, realm, userpass);
3660
3661 /* Clean up */
3662 free(userpass);
3663 nsurl_unref(sitensurl);
3664
3665 /* Finally navigate to the original loading parameters */
3666 bw->internal_nav = false;
3667 return navigate_internal_real(bw, &bw->loading_parameters);
3668}
3669
3670
3671/**
3672 * Internal navigation handler for the SSL/privacy query page.
3673 *
3674 * If the parameters indicate we're processing a *response* from the handler
3675 * then we deal with that, otherwise we pass it on to the about: handler
3676 */
3677static nserror
3678navigate_internal_query_ssl(struct browser_window *bw,
3679 struct browser_fetch_parameters *params)
3680{
3681 bool is_proceed = false, is_back = false;
3682 const char *siteurl = NULL;
3683 nsurl *siteurl_ns;
3684
3685 assert(params->post_multipart != NULL);
3686
3687 is_proceed = fetch_multipart_data_find(params->post_multipart, "proceed") != NULL;
3688 is_back = fetch_multipart_data_find(params->post_multipart, "back") != NULL;
3689 siteurl = fetch_multipart_data_find(params->post_multipart, "siteurl");
3690
3691 if (!(is_proceed || is_back) || siteurl == NULL) {
3692 /* This is a request, so pass it on */
3693 return navigate_internal_real(bw, params);
3694 }
3695
3696 if (nsurl_create(siteurl, &siteurl_ns) != NSERROR_OK) {
3697 NSLOG(netsurf, ERROR, "Unable to reset ssl loading parameters");
3698 } else {
3699 /* In order that we may proceed, replace the loading parameters */
3700 nsurl_unref(bw->loading_parameters.url);
3701 bw->loading_parameters.url = siteurl_ns;
3702 }
3703
3704 return browser_window__handle_ssl_query_response(is_proceed, bw);
3705}
3706
3707
3708/**
3709 * Internal navigation handler for the timeout query page.
3710 *
3711 * If the parameters indicate we're processing a *response* from the handler
3712 * then we deal with that, otherwise we pass it on to the about: handler
3713 */
3714static nserror
3715navigate_internal_query_timeout(struct browser_window *bw,
3716 struct browser_fetch_parameters *params)
3717{
3718 bool is_retry = false, is_back = false;
3719
3720 NSLOG(netsurf, INFO, "bw:%p params:%p", bw, params);
3721
3722 assert(params->post_multipart != NULL);
3723
3724 is_retry = fetch_multipart_data_find(params->post_multipart, "retry") != NULL;
3725 is_back = fetch_multipart_data_find(params->post_multipart, "back") != NULL;
3726
3727 if (is_back) {
3728 /* do a rough-and-ready nav to the old 'current'
3729 * parameters, with any post data stripped away
3730 */
3731 return browser_window__reload_current_parameters(bw);
3732 }
3733
3734 if (is_retry) {
3735 /* Finally navigate to the original loading parameters */
3736 bw->internal_nav = false;
3737 return navigate_internal_real(bw, &bw->loading_parameters);
3738 }
3739
3740 return navigate_internal_real(bw, params);
3741}
3742
3743
3744/**
3745 * Internal navigation handler for the fetch error query page.
3746 *
3747 * If the parameters indicate we're processing a *response* from the handler
3748 * then we deal with that, otherwise we pass it on to the about: handler
3749 */
3750static nserror
3751navigate_internal_query_fetcherror(struct browser_window *bw,
3752 struct browser_fetch_parameters *params)
3753{
3754 bool is_retry = false, is_back = false;
3755
3756 NSLOG(netsurf, INFO, "bw:%p params:%p", bw, params);
3757
3758 assert(params->post_multipart != NULL);
3759
3760 is_retry = fetch_multipart_data_find(params->post_multipart, "retry") != NULL;
3761 is_back = fetch_multipart_data_find(params->post_multipart, "back") != NULL;
3762
3763 if (is_back) {
3764 /* do a rough-and-ready nav to the old 'current'
3765 * parameters, with any post data stripped away
3766 */
3767 return browser_window__reload_current_parameters(bw);
3768 }
3769
3770 if (is_retry) {
3771 /* Finally navigate to the original loading parameters */
3772 bw->internal_nav = false;
3773 return navigate_internal_real(bw, &bw->loading_parameters);
3774 }
3775
3776 return navigate_internal_real(bw, params);
3777}
3778
3779
3780/**
3781 * dispatch to internal query handlers or normal navigation
3782 *
3783 * Here we determine if we're navigating to an internal query URI and
3784 * if so, what we need to do about it.
3785 *
3786 * \note these check must match those in is_internal_navigate_url()
3787 *
3788 * If we're not, then we just move on to the real navigate.
3789 */
3790nserror
3791browser_window__navigate_internal(struct browser_window *bw,
3792 struct browser_fetch_parameters *params)
3793{
3794 lwc_string *scheme, *path;
3795
3796 /* All our special URIs are in the about: scheme */
3797 scheme = nsurl_get_component(params->url, NSURL_SCHEME);
3798 if (scheme != corestring_lwc_about) {
3799 lwc_string_unref(scheme);
3800 goto normal_fetch;
3801 }
3802 lwc_string_unref(scheme);
3803
3804 /* Is it the auth query handler? */
3805 path = nsurl_get_component(params->url, NSURL_PATH);
3806 if (path == corestring_lwc_query_auth) {
3807 lwc_string_unref(path);
3808 return navigate_internal_query_auth(bw, params);
3809 }
3810 if (path == corestring_lwc_query_ssl) {
3811 lwc_string_unref(path);
3812 return navigate_internal_query_ssl(bw, params);
3813 }
3814 if (path == corestring_lwc_query_timeout) {
3815 lwc_string_unref(path);
3816 return navigate_internal_query_timeout(bw, params);
3817 }
3818 if (path == corestring_lwc_query_fetcherror) {
3819 lwc_string_unref(path);
3820 return navigate_internal_query_fetcherror(bw, params);
3821 }
3822 if (path != NULL) {
3823 lwc_string_unref(path);
3824 }
3825
3826 /* Fall through to a normal about: fetch */
3827
3828 normal_fetch:
3829 return navigate_internal_real(bw, params);
3830}
3831
3832
3833/* Exported interface, documented in netsurf/browser_window.h */
3834bool browser_window_up_available(struct browser_window *bw)
3835{
3836 bool result = false;
3837
3838 if (bw != NULL && bw->current_content != NULL) {
3839 nsurl *parent;
3840 nserror err;
3841 err = nsurl_parent(hlcache_handle_get_url(bw->current_content),
3842 &parent);
3843 if (err == NSERROR_OK) {
3844 result = nsurl_compare(hlcache_handle_get_url(
3845 bw->current_content),
3846 parent,
3847 NSURL_COMPLETE) == false;
3848 nsurl_unref(parent);
3849 }
3850 }
3851
3852 return result;
3853}
3854
3855
3856/* Exported interface, documented in netsurf/browser_window.h */
3857nserror browser_window_navigate_up(struct browser_window *bw, bool new_window)
3858{
3859 nsurl *current, *parent;
3860 nserror err;
3861
3862 if (bw == NULL)
3863 return NSERROR_BAD_PARAMETER;
3864
3865 current = browser_window_access_url(bw);
3866
3867 err = nsurl_parent(current, &parent);
3868 if (err != NSERROR_OK) {
3869 return err;
3870 }
3871
3872 if (nsurl_compare(current, parent, NSURL_COMPLETE) == true) {
3873 /* Can't go up to parent from here */
3874 nsurl_unref(parent);
3875 return NSERROR_OK;
3876 }
3877
3878 if (new_window) {
3879 err = browser_window_create(BW_CREATE_CLONE,
3880 parent, NULL, bw, NULL);
3881 } else {
3882 err = browser_window_navigate(bw, parent, NULL,
3883 BW_NAVIGATE_HISTORY,
3884 NULL, NULL, NULL);
3885 }
3886
3887 nsurl_unref(parent);
3888 return err;
3889}
3890
3891
3892/* Exported interface, documented in include/netsurf/browser_window.h */
3893nsurl* browser_window_access_url(const struct browser_window *bw)
3894{
3895 assert(bw != NULL);
3896
3897 if (bw->current_content != NULL) {
3898 return hlcache_handle_get_url(bw->current_content);
3899
3900 } else if (bw->loading_content != NULL) {
3901 /* TODO: should we return this? */
3902 return hlcache_handle_get_url(bw->loading_content);
3903 }
3904
3905 return corestring_nsurl_about_blank;
3906}
3907
3908
3909/* Exported interface, documented in include/netsurf/browser_window.h */
3910nserror
3911browser_window_get_url(struct browser_window *bw, bool fragment,nsurl** url_out)
3912{
3913 nserror err;
3914 nsurl *url;
3915
3916 assert(bw != NULL);
3917
3918 if (!fragment || bw->frag_id == NULL || bw->loading_content != NULL) {
3919 /* If there's a loading content, then the bw->frag_id will have
3920 * been trampled, possibly with a new frag_id, but we will
3921 * still be returning the current URL, so in this edge case
3922 * we just drop any fragment. */
3923 url = nsurl_ref(browser_window_access_url(bw));
3924
3925 } else {
3926 err = nsurl_refragment(browser_window_access_url(bw),
3927 bw->frag_id, &url);
3928 if (err != NSERROR_OK) {
3929 return err;
3930 }
3931 }
3932
3933 *url_out = url;
3934 return NSERROR_OK;
3935}
3936
3937
3938/* Exported interface, documented in netsurf/browser_window.h */
3939const char* browser_window_get_title(struct browser_window *bw)
3940{
3941 assert(bw != NULL);
3942
3943 if (bw->current_content != NULL) {
3944 return content_get_title(bw->current_content);
3945 }
3946
3947 /* no content so return about:blank */
3948 return nsurl_access(corestring_nsurl_about_blank);
3949}
3950
3951
3952/* Exported interface, documented in netsurf/browser_window.h */
3953struct history * browser_window_get_history(struct browser_window *bw)
3954{
3955 assert(bw != NULL);
3956
3957 return bw->history;
3958}
3959
3960
3961/* Exported interface, documented in netsurf/browser_window.h */
3962bool browser_window_has_content(struct browser_window *bw)
3963{
3964 assert(bw != NULL);
3965
3966 if (bw->current_content == NULL) {
3967 return false;
3968 }
3969
3970 return true;
3971}
3972
3973
3974/* Exported interface, documented in netsurf/browser_window.h */
3975struct hlcache_handle *browser_window_get_content(struct browser_window *bw)
3976{
3977 return bw->current_content;
3978}
3979
3980
3981/* Exported interface, documented in netsurf/browser_window.h */
3982nserror browser_window_get_extents(struct browser_window *bw, bool scaled,
3983 int *width, int *height)
3984{
3985 assert(bw != NULL);
3986
3987 if (bw->current_content == NULL) {
3988 *width = 0;
3989 *height = 0;
3990 return NSERROR_BAD_CONTENT;
3991 }
3992
3993 *width = content_get_width(bw->current_content);
3994 *height = content_get_height(bw->current_content);
3995
3996 if (scaled) {
3997 *width *= bw->scale;
3998 *height *= bw->scale;
3999 }
4000
4001 return NSERROR_OK;
4002}
4003
4004
4005/* exported internal interface, documented in desktop/browser_private.h */
4006nserror
4007browser_window_get_dimensions(struct browser_window *bw,
4008 int *width,
4009 int *height)
4010{
4011 nserror res;
4012 assert(bw);
4013
4014 if (bw->window == NULL) {
4015 /* Core managed browser window */
4016 *width = bw->width;
4017 *height = bw->height;
4018 res = NSERROR_OK;
4019 } else {
4020 /* Front end window */
4021 res = guit->window->get_dimensions(bw->window, width, height);
4022 }
4023 return res;
4024}
4025
4026
4027/* Exported interface, documented in netsurf/browser_window.h */
4028void
4029browser_window_set_dimensions(struct browser_window *bw, int width, int height)
4030{
4031 assert(bw);
4032
4033 if (bw->window == NULL) {
4034 /* Core managed browser window */
4035 bw->width = width;
4036 bw->height = height;
4037 } else {
4038 NSLOG(netsurf, INFO,
4039 "Asked to set dimensions of front end window.");
4040 assert(0);
4041 }
4042}
4043
4044
4045/* Exported interface, documented in browser/browser_private.h */
4046nserror
4047browser_window_invalidate_rect(struct browser_window *bw, struct rect *rect)
4048{
4049 int pos_x;
4050 int pos_y;
4051 struct browser_window *top = bw;
4052
4053 assert(bw);
4054
4055 if (bw->window == NULL) {
4056 /* Core managed browser window */
4057 browser_window_get_position(bw, true, &pos_x, &pos_y);
4058
4059 top = browser_window_get_root(bw);
4060
4061 rect->x0 += pos_x / bw->scale;
4062 rect->y0 += pos_y / bw->scale;
4063 rect->x1 += pos_x / bw->scale;
4064 rect->y1 += pos_y / bw->scale;
4065 }
4066
4067 rect->x0 *= top->scale;
4068 rect->y0 *= top->scale;
4069 rect->x1 *= top->scale;
4070 rect->y1 *= top->scale;
4071
4072 return guit->window->invalidate(top->window, rect);
4073}
4074
4075
4076/* Exported interface, documented in netsurf/browser_window.h */
4077void browser_window_stop(struct browser_window *bw)
4078{
4079 int children, index;
4080
4081 if (bw->loading_content != NULL) {
4082 hlcache_handle_abort(bw->loading_content);
4083 hlcache_handle_release(bw->loading_content);
4084 bw->loading_content = NULL;
4085 }
4086
4087 if (bw->current_content != NULL &&
4088 content_get_status(bw->current_content) != CONTENT_STATUS_DONE) {
4089 nserror error;
4090 assert(content_get_status(bw->current_content) ==
4091 CONTENT_STATUS_READY);
4092 error = hlcache_handle_abort(bw->current_content);
4093 assert(error == NSERROR_OK);
4094 }
4095
4096 guit->misc->schedule(-1, browser_window_refresh, bw);
4097
4098 if (bw->children) {
4099 children = bw->rows * bw->cols;
4100 for (index = 0; index < children; index++)
4101 browser_window_stop(&bw->children[index]);
4102 }
4103 if (bw->iframes) {
4104 children = bw->iframe_count;
4105 for (index = 0; index < children; index++)
4106 browser_window_stop(&bw->iframes[index]);
4107 }
4108
4109 if (bw->current_content != NULL) {
4110 browser_window_refresh_url_bar(bw);
4111 }
4112
4113 browser_window_stop_throbber(bw);
4114}
4115
4116
4117/* Exported interface, documented in netsurf/browser_window.h */
4118nserror browser_window_reload(struct browser_window *bw, bool all)
4119{
4120 hlcache_handle *c;
4121 unsigned int i;
4122 struct nsurl *reload_url;
4123
4124 if ((bw->current_content) == NULL ||
4125 (bw->loading_content) != NULL) {
4126 return NSERROR_INVALID;
4127 }
4128
4129 if (all && content_get_type(bw->current_content) == CONTENT_HTML) {
4130 struct html_stylesheet *sheets;
4131 struct content_html_object *object;
4132 unsigned int count;
4133
4134 c = bw->current_content;
4135
4136 /* invalidate objects */
4137 object = html_get_objects(c, &count);
4138
4139 for (; object != NULL; object = object->next) {
4140 if (object->content != NULL)
4141 content_invalidate_reuse_data(object->content);
4142 }
4143
4144 /* invalidate stylesheets */
4145 sheets = html_get_stylesheets(c, &count);
4146
4147 for (i = STYLESHEET_START; i != count; i++) {
4148 if (sheets[i].sheet != NULL) {
4149 content_invalidate_reuse_data(sheets[i].sheet);
4150 }
4151 }
4152 }
4153
4154 content_invalidate_reuse_data(bw->current_content);
4155
4156 reload_url = hlcache_handle_get_url(bw->current_content);
4157
4158 return browser_window_navigate(bw,
4159 reload_url,
4160 NULL,
4161 BW_NAVIGATE_NONE,
4162 NULL,
4163 NULL,
4164 NULL);
4165}
4166
4167
4168/* Exported interface, documented in netsurf/browser_window.h */
4169void browser_window_set_status(struct browser_window *bw, const char *text)
4170{
4171 int text_len;
4172 /* find topmost window */
4173 while (bw->parent)
4174 bw = bw->parent;
4175
4176 if ((bw->status.text != NULL) &&
4177 (strcmp(text, bw->status.text) == 0)) {
4178 /* status text is unchanged */
4179 bw->status.match++;
4180 return;
4181 }
4182
4183 /* status text is changed */
4184
4185 text_len = strlen(text);
4186
4187 if ((bw->status.text == NULL) || (bw->status.text_len < text_len)) {
4188 /* no current string allocation or it is not long enough */
4189 free(bw->status.text);
4190 bw->status.text = strdup(text);
4191 bw->status.text_len = text_len;
4192 } else {
4193 /* current allocation has enough space */
4194 memcpy(bw->status.text, text, text_len + 1);
4195 }
4196
4197 bw->status.miss++;
4198 guit->window->set_status(bw->window, bw->status.text);
4199}
4200
4201
4202/* Exported interface, documented in netsurf/browser_window.h */
4203void browser_window_set_pointer(struct browser_window *bw,
4204 browser_pointer_shape shape)
4205{
4206 struct browser_window *root = browser_window_get_root(bw);
4207 gui_pointer_shape gui_shape;
4208 bool loading;
4209 uint64_t ms_now;
4210
4211 assert(root);
4212 assert(root->window);
4213
4214 loading = ((bw->loading_content != NULL) ||
4215 ((bw->current_content != NULL) &&
4216 (content_get_status(bw->current_content) == CONTENT_STATUS_READY)));
4217
4218 nsu_getmonotonic_ms(&ms_now);
4219
4220 if (loading && ((ms_now - bw->last_action) < 1000)) {
4221 /* If loading and less than 1 second since last link followed,
4222 * force progress indicator pointer */
4223 gui_shape = GUI_POINTER_PROGRESS;
4224
4225 } else if (shape == BROWSER_POINTER_AUTO) {
4226 /* Up to browser window to decide */
4227 if (loading) {
4228 gui_shape = GUI_POINTER_PROGRESS;
4229 } else {
4230 gui_shape = GUI_POINTER_DEFAULT;
4231 }
4232
4233 } else {
4234 /* Use what we were told */
4235 gui_shape = (gui_pointer_shape)shape;
4236 }
4237
4238 guit->window->set_pointer(root->window, gui_shape);
4239}
4240
4241
4242/* exported function documented in netsurf/browser_window.h */
4243nserror browser_window_schedule_reformat(struct browser_window *bw)
4244{
4245 if (bw->window == NULL) {
4246 return NSERROR_BAD_PARAMETER;
4247 }
4248
4249 return guit->misc->schedule(0, scheduled_reformat, bw);
4250}
4251
4252
4253/* exported function documented in netsurf/browser_window.h */
4254void
4255browser_window_reformat(struct browser_window *bw,
4256 bool background,
4257 int width,
4258 int height)
4259{
4260 hlcache_handle *c = bw->current_content;
4261
4262 if (c == NULL)
4263 return;
4264
4265 if (bw->browser_window_type != BROWSER_WINDOW_IFRAME) {
4266 /* Iframe dimensions are already scaled in parent's layout */
4267 width /= bw->scale;
4268 height /= bw->scale;
4269 }
4270
4271 if (bw->window == NULL) {
4272 /* Core managed browser window; subtract scrollbar width */
4273 width -= bw->scroll_y ? SCROLLBAR_WIDTH : 0;
4274 height -= bw->scroll_x ? SCROLLBAR_WIDTH : 0;
4275
4276 width = width > 0 ? width : 0;
4277 height = height > 0 ? height : 0;
4278 }
4279
4280 content_reformat(c, background, width, height);
4281}
4282
4283
4284/* exported interface documented in netsurf/browser_window.h */
4285nserror
4286browser_window_set_scale(struct browser_window *bw, float scale, bool absolute)
4287{
4288 nserror res;
4289
4290 /* get top browser window */
4291 while (bw->parent) {
4292 bw = bw->parent;
4293 }
4294
4295 if (!absolute) {
4296 /* snap small values around 1.0 */
4297 if ((scale + bw->scale) > (1.01 - scale) &&
4298 (scale + bw->scale) < (0.99 + scale)) {
4299 scale = 1.0;
4300 } else {
4301 scale += bw->scale;
4302 }
4303 }
4304
4305 /* clamp range between 0.1 and 10 (10% and 1000%) */
4306 if (scale < SCALE_MINIMUM) {
4307 scale = SCALE_MINIMUM;
4308 } else if (scale > SCALE_MAXIMUM) {
4309 scale = SCALE_MAXIMUM;
4310 }
4311
4312 res = browser_window_set_scale_internal(bw, scale);
4313 if (res == NSERROR_OK) {
4314 browser_window_recalculate_frameset(bw);
4315 }
4316
4317 return res;
4318}
4319
4320
4321/* exported interface documented in netsurf/browser_window.h */
4322float browser_window_get_scale(struct browser_window *bw)
4323{
4324 if (bw == NULL) {
4325 return 1.0;
4326 }
4327
4328 return bw->scale;
4329}
4330
4331
4332/* exported interface documented in netsurf/browser_window.h */
4333struct browser_window *
4334browser_window_find_target(struct browser_window *bw,
4335 const char *target,
4336 browser_mouse_state mouse)
4337{
4338 struct browser_window *bw_target;
4339 struct browser_window *top;
4340 hlcache_handle *c;
4341 int rdepth;
4342 nserror error;
4343
4344 /* use the base target if we don't have one */
4345 c = bw->current_content;
4346 if (target == NULL &&
4347 c != NULL &&
4348 content_get_type(c) == CONTENT_HTML) {
4349 target = html_get_base_target(c);
4350 }
4351 if (target == NULL) {
4352 target = "_self";
4353 }
4354
4355 /* allow the simple case of target="_blank" to be ignored if requested
4356 */
4357 if ((!(mouse & BROWSER_MOUSE_CLICK_2)) &&
4358 (!((mouse & BROWSER_MOUSE_CLICK_2) &&
4359 (mouse & BROWSER_MOUSE_MOD_2))) &&
4360 (!nsoption_bool(target_blank))) {
4361 /* not a mouse button 2 click
4362 * not a mouse button 1 click with ctrl pressed
4363 * configured to ignore target="_blank" */
4364 if (!strcasecmp(target, "_blank"))
4365 return bw;
4366 }
4367
4368 /* handle reserved keywords */
4369 if (((nsoption_bool(button_2_tab)) &&
4370 (mouse & BROWSER_MOUSE_CLICK_2))||
4371 ((!nsoption_bool(button_2_tab)) &&
4372 ((mouse & BROWSER_MOUSE_CLICK_1) &&
4373 (mouse & BROWSER_MOUSE_MOD_2))) ||
4374 ((nsoption_bool(button_2_tab)) &&
4375 (!strcasecmp(target, "_blank")))) {
4376 /* open in new tab if:
4377 * - button_2 opens in new tab and button_2 was pressed
4378 * OR
4379 * - button_2 doesn't open in new tabs and button_1 was
4380 * pressed with ctrl held
4381 * OR
4382 * - button_2 opens in new tab and the link target is "_blank"
4383 */
4384 error = browser_window_create(BW_CREATE_TAB |
4385 BW_CREATE_HISTORY |
4386 BW_CREATE_CLONE,
4387 NULL,
4388 NULL,
4389 bw,
4390 &bw_target);
4391 if (error != NSERROR_OK) {
4392 return bw;
4393 }
4394 return bw_target;
4395 } else if (((!nsoption_bool(button_2_tab)) &&
4396 (mouse & BROWSER_MOUSE_CLICK_2)) ||
4397 ((nsoption_bool(button_2_tab)) &&
4398 ((mouse & BROWSER_MOUSE_CLICK_1) &&
4399 (mouse & BROWSER_MOUSE_MOD_2))) ||
4400 ((!nsoption_bool(button_2_tab)) &&
4401 (!strcasecmp(target, "_blank")))) {
4402 /* open in new window if:
4403 * - button_2 doesn't open in new tabs and button_2 was pressed
4404 * OR
4405 * - button_2 opens in new tab and button_1 was pressed with
4406 * ctrl held
4407 * OR
4408 * - button_2 doesn't open in new tabs and the link target is
4409 * "_blank"
4410 */
4411 error = browser_window_create(BW_CREATE_HISTORY |
4412 BW_CREATE_CLONE,
4413 NULL,
4414 NULL,
4415 bw,
4416 &bw_target);
4417 if (error != NSERROR_OK) {
4418 return bw;
4419 }
4420 return bw_target;
4421 } else if (!strcasecmp(target, "_self")) {
4422 return bw;
4423 } else if (!strcasecmp(target, "_parent")) {
4424 if (bw->parent)
4425 return bw->parent;
4426 return bw;
4427 } else if (!strcasecmp(target, "_top")) {
4428 while (bw->parent)
4429 bw = bw->parent;
4430 return bw;
4431 }
4432
4433 /* find frame according to B.8, ie using the following priorities:
4434 *
4435 * 1) current frame
4436 * 2) closest to front
4437 */
4438 rdepth = -1;
4439 bw_target = NULL;
4440 for (top = bw; top->parent; top = top->parent);
4441 browser_window_find_target_internal(top, target, 0, bw, &rdepth,
4442 &bw_target);
4443 if (bw_target)
4444 return bw_target;
4445
4446 /* we require a new window using the target name */
4447 if (!nsoption_bool(target_blank))
4448 return bw;
4449
4450 error = browser_window_create(BW_CREATE_CLONE | BW_CREATE_HISTORY,
4451 NULL,
4452 NULL,
4453 bw,
4454 &bw_target);
4455 if (error != NSERROR_OK) {
4456 return bw;
4457 }
4458
4459 /* frame names should begin with an alphabetic character (a-z,A-Z),
4460 * however in practice you get things such as '_new' and '2left'. The
4461 * only real effect this has is when giving out names as it can be
4462 * assumed that an author intended '_new' to create a new nameless
4463 * window (ie '_blank') whereas in the case of '2left' the intention
4464 * was for a new named window. As such we merely special case windows
4465 * that begin with an underscore. */
4466 if (target[0] != '_') {
4467 bw_target->name = strdup(target);
4468 }
4469 return bw_target;
4470}
4471
4472
4473/* exported interface documented in netsurf/browser_window.h */
4474void
4475browser_window_mouse_track(struct browser_window *bw,
4476 browser_mouse_state mouse,
4477 int x, int y)
4478{
4479 browser_window_mouse_track_internal(bw,
4480 mouse,
4481 x / bw->scale,
4482 y / bw->scale);
4483}
4484
4485/* exported interface documented in netsurf/browser_window.h */
4486void
4487browser_window_mouse_click(struct browser_window *bw,
4488 browser_mouse_state mouse,
4489 int x, int y)
4490{
4491 browser_window_mouse_click_internal(bw,
4492 mouse,
4493 x / bw->scale,
4494 y / bw->scale);
4495}
4496
4497
4498/* exported interface documented in netsurf/browser_window.h */
4499void browser_window_page_drag_start(struct browser_window *bw, int x, int y)
4500{
4501 assert(bw != NULL);
4502
4503 browser_window_set_drag_type(bw, DRAGGING_PAGE_SCROLL, NULL);
4504
4505 bw->drag.start_x = x;
4506 bw->drag.start_y = y;
4507
4508 if (bw->window != NULL) {
4509 /* Front end window */
4510 guit->window->get_scroll(bw->window,
4511 &bw->drag.start_scroll_x,
4512 &bw->drag.start_scroll_y);
4513
4514 guit->window->event(bw->window, GW_EVENT_SCROLL_START);
4515 } else {
4516 /* Core managed browser window */
4517 bw->drag.start_scroll_x = scrollbar_get_offset(bw->scroll_x);
4518 bw->drag.start_scroll_y = scrollbar_get_offset(bw->scroll_y);
4519 }
4520}
4521
4522
4523/* exported interface documented in netsurf/browser_window.h */
4524bool browser_window_back_available(struct browser_window *bw)
4525{
4526 if (bw != NULL && bw->internal_nav) {
4527 /* Internal nav, back is possible */
4528 return true;
4529 }
4530 return (bw && bw->history && browser_window_history_back_available(bw));
4531}
4532
4533
4534/* exported interface documented in netsurf/browser_window.h */
4535bool browser_window_forward_available(struct browser_window *bw)
4536{
4537 return (bw && bw->history && browser_window_history_forward_available(bw));
4538}
4539
4540/* exported interface documented in netsurf/browser_window.h */
4541bool browser_window_reload_available(struct browser_window *bw)
4542{
4543 return (bw && bw->current_content && !bw->loading_content);
4544}
4545
4546
4547/* exported interface documented in netsurf/browser_window.h */
4548bool browser_window_stop_available(struct browser_window *bw)
4549{
4550 return (bw && (bw->loading_content ||
4551 (bw->current_content &&
4552 (content_get_status(bw->current_content) !=
4553 CONTENT_STATUS_DONE))));
4554}
4555
4556/* exported interface documented in netsurf/browser_window.h */
4557bool
4558browser_window_exec(struct browser_window *bw, const char *src, size_t srclen)
4559{
4560 assert(bw != NULL);
4561
4562 if (!bw->current_content) {
4563 NSLOG(netsurf, DEEPDEBUG, "Unable to exec, no content");
4564 return false;
4565 }
4566
4567 if (content_get_status(bw->current_content) != CONTENT_STATUS_DONE) {
4568 NSLOG(netsurf, DEEPDEBUG, "Unable to exec, content not done");
4569 return false;
4570 }
4571
4572 /* Okay it should be safe, forward the request through to the content
4573 * itself. Only HTML contents currently support executing code
4574 */
4575 return content_exec(bw->current_content, src, srclen);
4576}
4577
4578
4579/* exported interface documented in browser_window.h */
4580nserror
4581browser_window_console_log(struct browser_window *bw,
4582 browser_window_console_source src,
4583 const char *msg,
4584 size_t msglen,
4585 browser_window_console_flags flags)
4586{
4587 browser_window_console_flags log_level = flags & BW_CS_FLAG_LEVEL_MASK;
4588 struct browser_window *root = browser_window_get_root(bw);
4589
4590 assert(msg != NULL);
4591 /* We don't assert msglen > 0, if someone wants to log a real empty
4592 * string then we won't stop them. It does sometimes happen from
4593 * JavaScript for example.
4594 */
4595
4596 /* bw is the target of the log, but root is where we log it */
4597
4598 NSLOG(netsurf, DEEPDEBUG, "Logging message in %p targetted at %p", root, bw);
4599 NSLOG(netsurf, DEEPDEBUG, "Log came from %s",
4600 ((src == BW_CS_INPUT) ? "user input" :
4601 (src == BW_CS_SCRIPT_ERROR) ? "script error" :
4602 (src == BW_CS_SCRIPT_CONSOLE) ? "script console" :
4603 "unknown input location"));
4604
4605 switch (log_level) {
4606 case BW_CS_FLAG_LEVEL_DEBUG:
4607 NSLOG(netsurf, DEBUG, "%.*s", (int)msglen, msg);
4608 break;
4609 case BW_CS_FLAG_LEVEL_LOG:
4610 NSLOG(netsurf, VERBOSE, "%.*s", (int)msglen, msg);
4611 break;
4612 case BW_CS_FLAG_LEVEL_INFO:
4613 NSLOG(netsurf, INFO, "%.*s", (int)msglen, msg);
4614 break;
4615 case BW_CS_FLAG_LEVEL_WARN:
4616 NSLOG(netsurf, WARNING, "%.*s", (int)msglen, msg);
4617 break;
4618 case BW_CS_FLAG_LEVEL_ERROR:
4619 NSLOG(netsurf, ERROR, "%.*s", (int)msglen, msg);
4620 break;
4621 default:
4622 /* Unreachable */
4623 break;
4624 }
4625
4626 guit->window->console_log(root->window, src, msg, msglen, flags);
4627
4628 return NSERROR_OK;
4629}
4630
4631
4632/* Exported interface, documented in browser_private.h */
4633nserror
4634browser_window__reload_current_parameters(struct browser_window *bw)
4635{
4636 assert(bw != NULL);
4637
4638 if (bw->current_parameters.post_urlenc != NULL) {
4639 free(bw->current_parameters.post_urlenc);
4640 bw->current_parameters.post_urlenc = NULL;
4641 }
4642
4643 if (bw->current_parameters.post_multipart != NULL) {
4644 fetch_multipart_data_destroy(bw->current_parameters.post_multipart);
4645 bw->current_parameters.post_multipart = NULL;
4646 }
4647
4648 if (bw->current_parameters.url == NULL) {
4649 /* We have never navigated so go to about:blank */
4650 bw->current_parameters.url = nsurl_ref(corestring_nsurl_about_blank);
4651 }
4652
4653 bw->current_parameters.flags &= ~BW_NAVIGATE_HISTORY;
4654 bw->internal_nav = false;
4655
4656 browser_window__free_fetch_parameters(&bw->loading_parameters);
4657 memcpy(&bw->loading_parameters, &bw->current_parameters, sizeof(bw->loading_parameters));
4658 memset(&bw->current_parameters, 0, sizeof(bw->current_parameters));
4659 return browser_window__navigate_internal(bw, &bw->loading_parameters);
4660}
4661
4662/* Exported interface, documented in browser_window.h */
4663browser_window_page_info_state browser_window_get_page_info_state(
4664 const struct browser_window *bw)
4665{
4666 lwc_string *scheme;
4667 bool match;
4668
4669 assert(bw != NULL);
4670
4671 /* Do we have any content? If not -- UNKNOWN */
4672 if (bw->current_content == NULL) {
4673 return PAGE_STATE_UNKNOWN;
4674 }
4675
4676 scheme = nsurl_get_component(
4677 hlcache_handle_get_url(bw->current_content), NSURL_SCHEME);
4678
4679 /* Is this an internal scheme? */
4680 if ((lwc_string_isequal(scheme, corestring_lwc_about,
4681 &match) == lwc_error_ok &&
4682 (match == true)) ||
4683 (lwc_string_isequal(scheme, corestring_lwc_data,
4684 &match) == lwc_error_ok &&
4685 (match == true)) ||
4686 (lwc_string_isequal(scheme, corestring_lwc_resource,
4687 &match) == lwc_error_ok &&
4688 (match == true))) {
4689 lwc_string_unref(scheme);
4690 return PAGE_STATE_INTERNAL;
4691 }
4692
4693 /* Is this file:/// ? */
4694 if (lwc_string_isequal(scheme, corestring_lwc_file,
4695 &match) == lwc_error_ok &&
4696 match == true) {
4697 lwc_string_unref(scheme);
4698 return PAGE_STATE_LOCAL;
4699 }
4700
4701 /* If not https, from here on down that'd be insecure */
4702 if ((lwc_string_isequal(scheme, corestring_lwc_https,
4703 &match) == lwc_error_ok &&
4704 (match == false))) {
4705 /* Some remote content, not https, therefore insecure */
4706 lwc_string_unref(scheme);
4707 return PAGE_STATE_INSECURE;
4708 }
4709
4710 lwc_string_unref(scheme);
4711
4712 /* Did we have to override this SSL setting? */
4713 if (urldb_get_cert_permissions(hlcache_handle_get_url(bw->current_content))) {
4714 return PAGE_STATE_SECURE_OVERRIDE;
4715 }
4716
4717 /* If we've seen insecure content internally then we need to say so */
4718 if (content_saw_insecure_objects(bw->current_content)) {
4719 return PAGE_STATE_SECURE_ISSUES;
4720 }
4721
4722 /* All is well, return secure state */
4723 return PAGE_STATE_SECURE;
4724}
4725
4726/* Exported interface, documented in browser_window.h */
4727nserror
4728browser_window_get_ssl_chain(struct browser_window *bw,
4729 struct cert_chain **chain)
4730{
4731 assert(bw != NULL);
4732
4733 if (bw->current_cert_chain == NULL) {
4734 return NSERROR_NOT_FOUND;
4735 }
4736
4737 *chain = bw->current_cert_chain;
4738
4739 return NSERROR_OK;
4740}
4741
4742/* Exported interface, documented in browser_window.h */
4743int browser_window_get_cookie_count(
4744 const struct browser_window *bw)
4745{
4746 int count = 0;
4747 char *cookies = urldb_get_cookie(browser_window_access_url(bw), true);
4748 if (cookies == NULL) {
4749 return 0;
4750 }
4751
4752 for (char *c = cookies; *c != '\0'; c++) {
4753 if (*c == ';')
4754 count++;
4755 }
4756
4757 free(cookies);
4758
4759 return count;
4760}
4761
4762/* Exported interface, documented in browser_window.h */
4763nserror browser_window_show_cookies(
4764 const struct browser_window *bw)
4765{
4766 nserror err;
4767 nsurl *url = browser_window_access_url(bw);
4768 lwc_string *host = nsurl_get_component(url, NSURL_HOST);
4769 const char *string = (host != NULL) ? lwc_string_data(host) : NULL;
4770
4771 err = guit->misc->present_cookies(string);
4772
4773 if (host != NULL) {
4774 lwc_string_unref(host);
4775 }
4776 return err;
4777}
4778
4779/* Exported interface, documented in browser_window.h */
4780nserror browser_window_show_certificates(struct browser_window *bw)
4781{
4782 nserror res;
4783 nsurl *url;
4784
4785 if (bw->current_cert_chain == NULL) {
4786 return NSERROR_NOT_FOUND;
4787 }
4788
4789 res = cert_chain_to_query(bw->current_cert_chain, &url);
4790 if (res == NSERROR_OK) {
4791 res = browser_window_create(BW_CREATE_HISTORY |
4792 BW_CREATE_FOREGROUND |
4793 BW_CREATE_TAB,
4794 url,
4795 NULL,
4796 bw,
4797 NULL);
4798
4799 nsurl_unref(url);
4800 }
4801
4802 return res;
4803}
result
STATIC char result[100]
Definition: arexx.c:77
browser_window_history_add
nserror browser_window_history_add(struct browser_window *bw, struct hlcache_handle *content, lwc_string *frag_id)
Insert a url into the history tree.
Definition: browser_history.c:352
browser_window_history_update
nserror browser_window_history_update(struct browser_window *bw, struct hlcache_handle *content)
Update the thumbnail and scroll offsets for the current entry.
Definition: browser_history.c:427
browser_window_history_create
nserror browser_window_history_create(struct browser_window *bw)
Create a new history tree for a browser window window.
Definition: browser_history.c:296
browser_window_history_get_scroll
nserror browser_window_history_get_scroll(struct browser_window *bw, float *sx, float *sy)
Retrieve the stored scroll offsets for the current history entry.
Definition: browser_history.c:482
browser_window_history_clone
nserror browser_window_history_clone(const struct browser_window *existing, struct browser_window *clone)
Clone a bw's history tree for new bw.
Definition: browser_history.c:317
browser_window_history_forward_available
bool browser_window_history_forward_available(struct browser_window *bw)
Check whether it is pssible to go forwards in the history.
Definition: browser_history.c:570
browser_window_history_back_available
bool browser_window_history_back_available(struct browser_window *bw)
Check whether it is pssible to go back in the history.
Definition: browser_history.c:562
browser_window_history_destroy
void browser_window_history_destroy(struct browser_window *bw)
Free a history structure.
Definition: browser_history.c:502
browser_history.h
Interface to browser history operations.
browser_private.h
Browser window private structure.
browser_window_initialise_common
nserror browser_window_initialise_common(enum browser_window_create_flags flags, struct browser_window *bw, const struct browser_window *existing)
Initialise common parts of a browser window.
Definition: browser_window.c:3176
browser_window_schedule_reformat
nserror browser_window_schedule_reformat(struct browser_window *bw)
Reformat the browser window contents in a safe context.
Definition: browser_window.c:4243
browser_window_redraw_ready
bool browser_window_redraw_ready(struct browser_window *bw)
Check whether browser window is ready for redraw.
Definition: browser_window.c:2765
browser_window__handle_ssl_query_response
static nserror browser_window__handle_ssl_query_response(bool proceed, void *pw)
Handle query responses from SSL requests.
Definition: browser_window.c:977
browser_window_show_certificates
nserror browser_window_show_certificates(struct browser_window *bw)
Show the certificate page for the current page.
Definition: browser_window.c:4780
browser_window_page_drag_start
void browser_window_page_drag_start(struct browser_window *bw, int x, int y)
Start drag scrolling the contents of the browser window.
Definition: browser_window.c:4499
browser_window_refresh_url_bar_internal
static nserror browser_window_refresh_url_bar_internal(struct browser_window *bw, nsurl *url)
Update URL bar for a given browser window to given URL.
Definition: browser_window.c:1432
browser_window_can_select
bool browser_window_can_select(struct browser_window *bw)
Find out if given browser window content is selectable.
Definition: browser_window.c:2929
browser_window__handle_userpass_response
static nserror browser_window__handle_userpass_response(nsurl *url, const char *realm, const char *username, const char *password, void *pw)
Handle a response from the UI when prompted for credentials.
Definition: browser_window.c:1104
browser_window_update_extent
void browser_window_update_extent(struct browser_window *bw)
Update the extent of the inside of a browser window to that of the current content.
Definition: browser_window.c:2780
browser_window_refresh_url_bar
nserror browser_window_refresh_url_bar(struct browser_window *bw)
Update URL bar for a given browser window to bw's content's URL.
Definition: browser_window.c:3240
browser_window_set_scale_internal
static nserror browser_window_set_scale_internal(struct browser_window *bw, float scale)
Set browser window scale.
Definition: browser_window.c:1939
browser_window_get_features
nserror browser_window_get_features(struct browser_window *bw, int x, int y, struct browser_window_features *data)
Get access to any page features at the given coordinates.
Definition: browser_window.c:2999
browser_window_redraw
bool browser_window_redraw(struct browser_window *bw, int x, int y, const struct rect *clip, const struct redraw_context *ctx)
Redraw an area of a window.
Definition: browser_window.c:2583
browser_window_check_throbber
static bool browser_window_check_throbber(struct browser_window *bw)
recursively check browser windows for activity
Definition: browser_window.c:365
browser_window__build_userpass
static nserror browser_window__build_userpass(const char *username, const char *password, char **userpass_out)
Build a "username:password" from components.
Definition: browser_window.c:1079
browser_window_get_scale
float browser_window_get_scale(struct browser_window *bw)
Gets the scale of a browser window.
Definition: browser_window.c:4322
browser_window_set_drag_type
void browser_window_set_drag_type(struct browser_window *bw, browser_drag_type type, const struct rect *rect)
Set drag type for a browser window, and inform front end.
Definition: browser_window.c:2857
browser_window__handle_error
static nserror browser_window__handle_error(struct browser_window *bw, hlcache_handle *c, const hlcache_event *event)
Handle errors during content fetch.
Definition: browser_window.c:1376
get_horz_scrollbar_len
static int get_horz_scrollbar_len(struct browser_window *bw)
Get browser window horizontal scrollbar widget length.
Definition: browser_window.c:172
browser_window__get_contextual_content
static nserror browser_window__get_contextual_content(struct browser_window *bw, int x, int y, struct browser_window_features *data)
Internal helper for getting the positional features.
Definition: browser_window.c:268
browser_window_access_url
nsurl * browser_window_access_url(const struct browser_window *bw)
Access a browser window's URL.
Definition: browser_window.c:3893
browser_window_has_content
bool browser_window_has_content(struct browser_window *bw)
Find out if a browser window is currently showing a content.
Definition: browser_window.c:3962
browser_window_get_scrollbar_pos
static void browser_window_get_scrollbar_pos(struct browser_window *bw, bool horizontal, int *x, int *y)
Get position of scrollbar widget within browser window.
Definition: browser_window.c:152
browser_window__handle_fetcherror
static nserror browser_window__handle_fetcherror(struct browser_window *bw, const char *reason, nsurl *url)
Handle non specific errors during a fetch.
Definition: browser_window.c:1332
browser_window_create
nserror browser_window_create(enum browser_window_create_flags flags, nsurl *url, nsurl *referrer, struct browser_window *existing, struct browser_window **bw)
Create and open a new root browser window with the given page.
Definition: browser_window.c:3078
browser_window_back_available
bool browser_window_back_available(struct browser_window *bw)
Check availability of Back action for a given browser window.
Definition: browser_window.c:4524
browser_window_get_ssl_chain
nserror browser_window_get_ssl_chain(struct browser_window *bw, struct cert_chain **chain)
Request the current browser window SSL certificate chain.
Definition: browser_window.c:4728
browser_window_mouse_track_internal
static void browser_window_mouse_track_internal(struct browser_window *bw, browser_mouse_state mouse, int x, int y)
Process mouse movement event.
Definition: browser_window.c:2235
browser_window_get_name
nserror browser_window_get_name(struct browser_window *bw, const char **out_name)
Obtain a browsing contexts name.
Definition: browser_window.c:2546
browser_window_exec
bool browser_window_exec(struct browser_window *bw, const char *src, size_t srclen)
Execute some JavaScript code in a browsing context.
Definition: browser_window.c:4558
navigate_internal_query_auth
static nserror navigate_internal_query_auth(struct browser_window *bw, struct browser_fetch_parameters *params)
Internal navigation handler for the authentication query handler.
Definition: browser_window.c:3601
browser_window_get_scrollbar_type
nserror browser_window_get_scrollbar_type(struct browser_window *bw, browser_scrolling *h, browser_scrolling *v)
Get the browser window's scrollbar details.
Definition: browser_window.c:2986
scheduled_reformat
static void scheduled_reformat(void *vbw)
internal scheduled reformat callback.
Definition: browser_window.c:1818
browser_window_debug
nserror browser_window_debug(struct browser_window *bw, enum content_debug op)
Set debug options on a window.
Definition: browser_window.c:3067
browser_window_scroll_at_point_internal
static bool browser_window_scroll_at_point_internal(struct browser_window *bw, int x, int y, int scrx, int scry)
perform a scroll operation at a given coordinate
Definition: browser_window.c:2402
browser_window_can_search
bool browser_window_can_search(struct browser_window *bw)
Find out if given browser window can be searched.
Definition: browser_window.c:2960
browser_window_refresh
static void browser_window_refresh(void *p)
Handle meta http-equiv refresh time elapsing by loading a new page.
Definition: browser_window.c:617
browser_window_mouse_click
void browser_window_mouse_click(struct browser_window *bw, browser_mouse_state mouse, int x, int y)
Handle mouse clicks in a browser window.
Definition: browser_window.c:4487
browser_window_favicon_callback
static nserror browser_window_favicon_callback(hlcache_handle *c, const hlcache_event *event, void *pw)
Callback for fetchcache() for browser window favicon fetches.
Definition: browser_window.c:438
browser_window_scroll_at_point
bool browser_window_scroll_at_point(struct browser_window *bw, int x, int y, int scrx, int scry)
Send a scroll request to a browser window at a particular point.
Definition: browser_window.c:3018
browser_window_console_log
nserror browser_window_console_log(struct browser_window *bw, browser_window_console_source src, const char *msg, size_t msglen, browser_window_console_flags flags)
Log a console message into the browser window console.
Definition: browser_window.c:4581
browser_window_show_cookies
nserror browser_window_show_cookies(const struct browser_window *bw)
Open cookie viewer for the current page.
Definition: browser_window.c:4763
browser_window_start_throbber
static nserror browser_window_start_throbber(struct browser_window *bw)
Start the busy indicator.
Definition: browser_window.c:396
browser_window_content_ready
static nserror browser_window_content_ready(struct browser_window *bw)
handle message for content ready on browser window
Definition: browser_window.c:822
browser_window_up_available
bool browser_window_up_available(struct browser_window *bw)
Return true if a browser window can navigate upwards.
Definition: browser_window.c:3834
browser_window_destroy
void browser_window_destroy(struct browser_window *bw)
Close and destroy a browser window.
Definition: browser_window.c:3228
browser_window__handle_bad_certs
static nserror browser_window__handle_bad_certs(struct browser_window *bw, nsurl *url)
Handle a certificate verification request (BAD_CERTS) during a fetch.
Definition: browser_window.c:1225
browser_window_set_position
void browser_window_set_position(struct browser_window *bw, int x, int y)
Set the position of the current browser window with respect to the parent browser window.
Definition: browser_window.c:2839
browser_window__unpack_userpass
static nserror browser_window__unpack_userpass(const char *userpass, char **username_out, char **password_out)
Unpack a "username:password" to components.
Definition: browser_window.c:1018
navigate_internal_query_ssl
static nserror navigate_internal_query_ssl(struct browser_window *bw, struct browser_fetch_parameters *params)
Internal navigation handler for the SSL/privacy query page.
Definition: browser_window.c:3678
browser_window_set_scroll
static nserror browser_window_set_scroll(struct browser_window *bw, const struct rect *rect)
Set the scroll position of a browser window.
Definition: browser_window.c:241
browser_window_navigate_up
nserror browser_window_navigate_up(struct browser_window *bw, bool new_window)
Navigate to a browser_window's parent URL.
Definition: browser_window.c:3857
browser_window_reload
nserror browser_window_reload(struct browser_window *bw, bool all)
Reload the page in a browser window.
Definition: browser_window.c:4118
browser_window_get_dimensions
nserror browser_window_get_dimensions(struct browser_window *bw, int *width, int *height)
Get the dimensions of the area a browser window occupies.
Definition: browser_window.c:4007
browser_window_set_selection
static void browser_window_set_selection(struct browser_window *bw, bool selection, bool read_only)
Set or remove a selection.
Definition: browser_window.c:201
navigate_internal_query_timeout
static nserror navigate_internal_query_timeout(struct browser_window *bw, struct browser_fetch_parameters *params)
Internal navigation handler for the timeout query page.
Definition: browser_window.c:3715
browser_window_destroy_internal
nserror browser_window_destroy_internal(struct browser_window *bw)
Release all memory associated with a browser window.
Definition: browser_window.c:1832
browser_window_reload_available
bool browser_window_reload_available(struct browser_window *bw)
Check availability of Reload action for a given browser window.
Definition: browser_window.c:4541
frag_scroll
static bool frag_scroll(struct browser_window *bw)
scroll to a fragment if present
Definition: browser_window.c:701
browser_window_forward_available
bool browser_window_forward_available(struct browser_window *bw)
Check availability of Forward action for a given browser window.
Definition: browser_window.c:4535
browser_window_invalidate_rect
nserror browser_window_invalidate_rect(struct browser_window *bw, struct rect *rect)
Cause an area of a browser window to be marked invalid and hence redrawn.
Definition: browser_window.c:4047
browser_window_set_dimensions
void browser_window_set_dimensions(struct browser_window *bw, int width, int height)
Set the dimensions of the area a browser window occupies.
Definition: browser_window.c:4029
browser_window_get_selection
char * browser_window_get_selection(struct browser_window *bw)
Get the current selection from a root browser window, ownership passed to caller, who must free() it.
Definition: browser_window.c:2946
browser_window_get_url
nserror browser_window_get_url(struct browser_window *bw, bool fragment, nsurl **url_out)
Access a browser window's URL.
Definition: browser_window.c:3911
is_internal_navigate_url
static bool is_internal_navigate_url(nsurl *url)
Check if this is an internal navigation URL.
Definition: browser_window.c:2516
SCALE_MAXIMUM
#define SCALE_MAXIMUM
largests scale that can be applied to a browser window
Definition: browser_window.c:79
browser_window_get_title
const char * browser_window_get_title(struct browser_window *bw)
Get the title of a browser_window.
Definition: browser_window.c:3939
browser_window_convert_to_download
static void browser_window_convert_to_download(struct browser_window *bw, llcache_handle *stream)
Transfer the loading_content to a new download window.
Definition: browser_window.c:673
browser_window_mouse_click_internal
static void browser_window_mouse_click_internal(struct browser_window *bw, browser_mouse_state mouse, int x, int y)
Process mouse click event.
Definition: browser_window.c:2100
browser_window_get_cookie_count
int browser_window_get_cookie_count(const struct browser_window *bw)
Get the number of cookies in use for the current page.
Definition: browser_window.c:4743
browser_window__handle_timeout
static nserror browser_window__handle_timeout(struct browser_window *bw, nsurl *url)
Handle a timeout during a fetch.
Definition: browser_window.c:1297
FRAME_DEPTH
#define FRAME_DEPTH
maximum frame depth
Definition: browser_window.c:84
browser_window_get_extents
nserror browser_window_get_extents(struct browser_window *bw, bool scaled, int *width, int *height)
Get a browser window's content extents.
Definition: browser_window.c:3982
browser_window_stop
void browser_window_stop(struct browser_window *bw)
Stop all fetching activity in a browser window.
Definition: browser_window.c:4077
browser_window_is_frameset
bool browser_window_is_frameset(struct browser_window *bw)
Find out if a browser window contains a frameset.
Definition: browser_window.c:2978
browser_window_callback
static nserror browser_window_callback(hlcache_handle *c, const hlcache_event *event, void *pw)
Browser window content event callback handler.
Definition: browser_window.c:1450
browser_window__reload_current_parameters
nserror browser_window__reload_current_parameters(struct browser_window *bw)
Navigate a browser window to the current parameters.
Definition: browser_window.c:4634
browser_window_set_scale
nserror browser_window_set_scale(struct browser_window *bw, float scale, bool absolute)
Sets the scale of a browser window.
Definition: browser_window.c:4286
browser_window_get_history
struct history * browser_window_get_history(struct browser_window *bw)
Get a browser window's history object.
Definition: browser_window.c:3953
browser_window_reformat
void browser_window_reformat(struct browser_window *bw, bool background, int width, int height)
Reformat a browser window contents to a new width or height.
Definition: browser_window.c:4255
browser_window_navigate
nserror browser_window_navigate(struct browser_window *bw, nsurl *url, nsurl *referrer, enum browser_window_nav_flags flags, char *post_urlenc, struct fetch_multipart_data *post_multipart, hlcache_handle *parent)
Start fetching a page in a browser window.
Definition: browser_window.c:3290
browser_window__handle_login
static nserror browser_window__handle_login(struct browser_window *bw, const char *realm, nsurl *url)
Handle login request (BAD_AUTH) during fetch.
Definition: browser_window.c:1145
browser_window_update
static void browser_window_update(struct browser_window *bw, bool scroll_to_top)
Redraw browser window, set extent to content, and update title.
Definition: browser_window.c:736
navigate_internal_query_fetcherror
static nserror navigate_internal_query_fetcherror(struct browser_window *bw, struct browser_fetch_parameters *params)
Internal navigation handler for the fetch error query page.
Definition: browser_window.c:3751
browser_window_get_position
void browser_window_get_position(struct browser_window *bw, bool root, int *pos_x, int *pos_y)
Get the position of the current browser window with respect to the root or parent browser window.
Definition: browser_window.c:2794
browser_window_set_name
nserror browser_window_set_name(struct browser_window *bw, const char *name)
Set a browsing contexts name.
Definition: browser_window.c:2558
browser_window_get_page_info_state
browser_window_page_info_state browser_window_get_page_info_state(const struct browser_window *bw)
Request the current browser window page info state.
Definition: browser_window.c:4663
browser_window_get_content
struct hlcache_handle * browser_window_get_content(struct browser_window *bw)
Get a cache handle for the content within a browser window.
Definition: browser_window.c:3975
browser_window_find_target_internal
static void browser_window_find_target_internal(struct browser_window *bw, const char *target, int depth, struct browser_window *page, int *rdepth, struct browser_window **bw_target)
Find browser window.
Definition: browser_window.c:1983
SCALE_MINIMUM
#define SCALE_MINIMUM
smallest scale that can be applied to a browser window
Definition: browser_window.c:74
browser_window_debug_dump
nserror browser_window_debug_dump(struct browser_window *bw, FILE *f, enum content_debug op)
Dump debug info concerning the browser window's contents to file.
Definition: browser_window.c:3055
browser_window__navigate_internal
static nserror browser_window__navigate_internal(struct browser_window *bw, struct browser_fetch_parameters *params)
dispatch to internal query handlers or normal navigation
Definition: browser_window.c:3791
browser_window_drop_file_at_point_internal
static bool browser_window_drop_file_at_point_internal(struct browser_window *bw, int x, int y, char *file)
allows a dragged file to be dropped into a browser window at a position
Definition: browser_window.c:2460
browser_window_get_editor_flags
browser_editor_flags browser_window_get_editor_flags(struct browser_window *bw)
Check whether browser window can accept a cut/copy/paste, or has a selection that could be saved.
Definition: browser_window.c:2908
browser_window_mouse_drag_end
static void browser_window_mouse_drag_end(struct browser_window *bw, browser_mouse_state mouse, int x, int y)
Handles the end of a drag operation in a browser window.
Definition: browser_window.c:2048
browser_window_stop_available
bool browser_window_stop_available(struct browser_window *bw)
Check availability of Stop action for a given browser window.
Definition: browser_window.c:4548
browser_window_stop_throbber
static nserror browser_window_stop_throbber(struct browser_window *bw)
Stop the busy indicator.
Definition: browser_window.c:412
browser_window_content_done
static nserror browser_window_content_done(struct browser_window *bw)
handle message for content done on browser window
Definition: browser_window.c:926
get_vert_scrollbar_len
static int get_vert_scrollbar_len(struct browser_window *bw)
Get browser window vertical scrollbar widget length.
Definition: browser_window.c:187
browser_window_find_target
struct browser_window * browser_window_find_target(struct browser_window *bw, const char *target, browser_mouse_state mouse)
Locate a browser window in the specified stack according.
Definition: browser_window.c:4334
navigate_internal_real
static nserror navigate_internal_real(struct browser_window *bw, struct browser_fetch_parameters *params)
Internal navigation handler for normal fetches.
Definition: browser_window.c:3507
browser_window_download
static nserror browser_window_download(struct browser_window *bw, nsurl *url, nsurl *nsref, uint32_t fetch_flags, bool fetch_is_post, llcache_post_data *post)
implements the download operation of a window navigate
Definition: browser_window.c:321
browser_window_drop_file_at_point
bool browser_window_drop_file_at_point(struct browser_window *bw, int x, int y, char *file)
Drop a file onto a browser window at a particular point, or determine if a file may be dropped onto t...
Definition: browser_window.c:3032
browser_window_destroy_children
static void browser_window_destroy_children(struct browser_window *bw)
Close and destroy all child browser window.
Definition: browser_window.c:96
browser_window_set_status
void browser_window_set_status(struct browser_window *bw, const char *text)
Change the status bar of a browser window.
Definition: browser_window.c:4169
browser_window_get_root
struct browser_window * browser_window_get_root(struct browser_window *bw)
Get the root level browser window.
Definition: browser_window.c:2898
browser_window__free_fetch_parameters
static void browser_window__free_fetch_parameters(struct browser_fetch_parameters *params)
Free the stored fetch parameters.
Definition: browser_window.c:118
browser_window_update_favicon
static nserror browser_window_update_favicon(hlcache_handle *c, struct browser_window *bw, struct content_rfc5988_link *link)
update the favicon associated with the browser window
Definition: browser_window.c:512
browser_window_get_drag_type
browser_drag_type browser_window_get_drag_type(struct browser_window *bw)
Get type of any current drag for a browser window.
Definition: browser_window.c:2891
browser_window_mouse_track
void browser_window_mouse_track(struct browser_window *bw, browser_mouse_state mouse, int x, int y)
Handle non-click mouse action in a browser window.
Definition: browser_window.c:4475
browser_window_set_pointer
void browser_window_set_pointer(struct browser_window *bw, browser_pointer_shape shape)
Change the shape of the mouse pointer.
Definition: browser_window.c:4203
browser_window_set_gadget_filename
void browser_window_set_gadget_filename(struct browser_window *bw, struct form_control *gadget, const char *fn)
set filename on form control.
Definition: browser_window.c:3045
browser_window.h
Browser window creation and manipulation interface.
browser_drag_type
browser_drag_type
type of browser window drag in progess
Definition: browser_window.h:51
DRAGGING_SELECTION
@ DRAGGING_SELECTION
Definition: browser_window.h:53
DRAGGING_SCR_Y
@ DRAGGING_SCR_Y
Definition: browser_window.h:57
DRAGGING_CONTENT_SCROLLBAR
@ DRAGGING_CONTENT_SCROLLBAR
Definition: browser_window.h:58
DRAGGING_SCR_X
@ DRAGGING_SCR_X
Definition: browser_window.h:56
DRAGGING_NONE
@ DRAGGING_NONE
Definition: browser_window.h:52
DRAGGING_OTHER
@ DRAGGING_OTHER
Definition: browser_window.h:59
DRAGGING_PAGE_SCROLL
@ DRAGGING_PAGE_SCROLL
Definition: browser_window.h:54
DRAGGING_FRAME
@ DRAGGING_FRAME
Definition: browser_window.h:55
browser_editor_flags
browser_editor_flags
Definition: browser_window.h:76
BW_EDITOR_CAN_PASTE
@ BW_EDITOR_CAN_PASTE
Can paste, input.
Definition: browser_window.h:80
BW_EDITOR_NONE
@ BW_EDITOR_NONE
No selection, no editing.
Definition: browser_window.h:77
BW_EDITOR_CAN_CUT
@ BW_EDITOR_CAN_CUT
Selection not read-only.
Definition: browser_window.h:79
BW_EDITOR_CAN_COPY
@ BW_EDITOR_CAN_COPY
Have selection.
Definition: browser_window.h:78
browser_scrolling
browser_scrolling
Definition: browser_window.h:83
BW_SCROLLING_YES
@ BW_SCROLLING_YES
Definition: browser_window.h:85
browser_window_page_info_state
browser_window_page_info_state
Browser window page information states.
Definition: browser_window.h:65
PAGE_STATE_INSECURE
@ PAGE_STATE_INSECURE
Insecure page load.
Definition: browser_window.h:69
PAGE_STATE_UNKNOWN
@ PAGE_STATE_UNKNOWN
Unable to determine.
Definition: browser_window.h:66
PAGE_STATE_SECURE_ISSUES
@ PAGE_STATE_SECURE_ISSUES
Secure load, but has insecure elements.
Definition: browser_window.h:71
PAGE_STATE_SECURE
@ PAGE_STATE_SECURE
Secure load.
Definition: browser_window.h:72
PAGE_STATE_SECURE_OVERRIDE
@ PAGE_STATE_SECURE_OVERRIDE
Secure load, but had to override.
Definition: browser_window.h:70
PAGE_STATE_LOCAL
@ PAGE_STATE_LOCAL
Page loaded from file:/// etc.
Definition: browser_window.h:68
PAGE_STATE_INTERNAL
@ PAGE_STATE_INTERNAL
Page loaded from internal handler.
Definition: browser_window.h:67
browser_window_create_flags
browser_window_create_flags
flags to browser_window_create
Definition: browser_window.h:90
BW_CREATE_HISTORY
@ BW_CREATE_HISTORY
this will form a new history node (don't set for back/reload/etc)
Definition: browser_window.h:95
BW_CREATE_TAB
@ BW_CREATE_TAB
New gui_window to be tab in same window as "existing" gui_window.
Definition: browser_window.h:98
BW_CREATE_FOREGROUND
@ BW_CREATE_FOREGROUND
Request foreground opening.
Definition: browser_window.h:115
BW_CREATE_CLONE
@ BW_CREATE_CLONE
New gui_window to be clone of "existing" gui_window.
Definition: browser_window.h:101
BW_CREATE_FOCUS_LOCATION
@ BW_CREATE_FOCUS_LOCATION
Request location bar focus.
Definition: browser_window.h:118
BW_CREATE_UNVERIFIABLE
@ BW_CREATE_UNVERIFIABLE
Window not opened by user interaction (e.g.
Definition: browser_window.h:112
browser_window_nav_flags
browser_window_nav_flags
flags to browser_window_navigate
Definition: browser_window.h:122
BW_NAVIGATE_DOWNLOAD
@ BW_NAVIGATE_DOWNLOAD
download rather than render the uri
Definition: browser_window.h:130
BW_NAVIGATE_HISTORY
@ BW_NAVIGATE_HISTORY
this will form a new history node (don't set for back/reload/etc)
Definition: browser_window.h:127
BW_NAVIGATE_NO_TERMINAL_HISTORY_UPDATE
@ BW_NAVIGATE_NO_TERMINAL_HISTORY_UPDATE
suppress initial history updates (used by back/fwd/etc)
Definition: browser_window.h:144
BW_NAVIGATE_NONE
@ BW_NAVIGATE_NONE
No flags set.
Definition: browser_window.h:124
BW_NAVIGATE_UNVERIFIABLE
@ BW_NAVIGATE_UNVERIFIABLE
Transation not caused by user interaction (e.g.
Definition: browser_window.h:141
BW_NAVIGATE_INTERNAL
@ BW_NAVIGATE_INTERNAL
Internal navigation (set only by core features using such)
Definition: browser_window.h:147
count
static uint32_t count(const http_directive *list, lwc_string *key)
Definition: cache-control.c:157
browser_window_console_source
browser_window_console_source
Sources of messages which end up in the browser window console.
Definition: console.h:30
BW_CS_SCRIPT_CONSOLE
@ BW_CS_SCRIPT_CONSOLE
Logging from some running script.
Definition: console.h:33
BW_CS_INPUT
@ BW_CS_INPUT
Input from the client.
Definition: console.h:31
BW_CS_SCRIPT_ERROR
@ BW_CS_SCRIPT_ERROR
Error from some running script.
Definition: console.h:32
browser_window_console_flags
browser_window_console_flags
Flags for browser window console logging.
Definition: console.h:41
BW_CS_FLAG_LEVEL_LOG
@ BW_CS_FLAG_LEVEL_LOG
Logged at the 'log' level, please only use one of the LEVEL flags.
Definition: console.h:55
BW_CS_FLAG_LEVEL_DEBUG
@ BW_CS_FLAG_LEVEL_DEBUG
Logged at the 'debug' level, please use only one of the LEVEL flags.
Definition: console.h:53
BW_CS_FLAG_LEVEL_INFO
@ BW_CS_FLAG_LEVEL_INFO
Logged at the 'info' level, please use only one of the LEVEL flags.
Definition: console.h:57
BW_CS_FLAG_LEVEL_MASK
@ BW_CS_FLAG_LEVEL_MASK
Mask for the error level to allow easy comparison using the above.
Definition: console.h:64
BW_CS_FLAG_LEVEL_WARN
@ BW_CS_FLAG_LEVEL_WARN
Logged at the 'warn' level, please use only one of the LEVEL flags.
Definition: console.h:59
BW_CS_FLAG_LEVEL_ERROR
@ BW_CS_FLAG_LEVEL_ERROR
Logged at the 'error' level, please use only one of the LEVEL flags.
Definition: console.h:61
content.h
Content handling interface.
fetch_multipart_data_new_kv
nserror fetch_multipart_data_new_kv(struct fetch_multipart_data **list, const char *name, const char *value)
Create an entry for a fetch_multipart_data.
Definition: fetch.c:721
fetch_multipart_data_find
const char * fetch_multipart_data_find(const struct fetch_multipart_data *list, const char *name)
Find an entry in a fetch_multipart_data.
Definition: fetch.c:686
fetch_multipart_data_clone
struct fetch_multipart_data * fetch_multipart_data_clone(const struct fetch_multipart_data *list)
Clone a linked list of fetch_multipart_data.
Definition: fetch.c:620
fetch_multipart_data_destroy
void fetch_multipart_data_destroy(struct fetch_multipart_data *list)
Free a linked list of fetch_multipart_data.
Definition: fetch.c:701
content_get_selection
char * content_get_selection(hlcache_handle *h)
Get a text selection from a content.
Definition: content.c:858
content_get_quirks
bool content_get_quirks(hlcache_handle *h)
Retrieve quirkiness of a content.
Definition: content.c:1308
content_debug_dump
nserror content_debug_dump(struct hlcache_handle *h, FILE *f, enum content_debug op)
Dump debug information to file.
Definition: content.c:922
content_exec
bool content_exec(struct hlcache_handle *h, const char *src, size_t srclen)
Execute some JavaScript code inside a content object.
Definition: content.c:477
content_is_locked
bool content_is_locked(hlcache_handle *h)
Return whether a content is currently locked.
Definition: content.c:1344
content_find_rfc5988_link
struct content_rfc5988_link * content_find_rfc5988_link(hlcache_handle *h, lwc_string *rel)
find link in content that matches the rel string.
Definition: content.c:954
content_mouse_action
void content_mouse_action(hlcache_handle *h, struct browser_window *bw, browser_mouse_state mouse, int x, int y)
Handle mouse clicks and movements in a content window.
Definition: content.c:421
content_clear_selection
void content_clear_selection(hlcache_handle *h)
Tell a content that any selection it has, or one of its objects has, must be cleared.
Definition: content.c:847
content_close
nserror content_close(hlcache_handle *h)
The window containing the content has been closed.
Definition: content.c:813
content_saw_insecure_objects
bool content_saw_insecure_objects(struct hlcache_handle *h)
Determine if the content referred to any insecure objects.
Definition: content.c:500
content_scroll_at_point
bool content_scroll_at_point(struct hlcache_handle *h, int x, int y, int scrx, int scry)
scroll content at coordnate
Definition: content.c:890
content_get_contextual_content
nserror content_get_contextual_content(struct hlcache_handle *h, int x, int y, struct browser_window_features *data)
Get positional contextural information for a content.
Definition: content.c:872
content_mouse_track
void content_mouse_track(hlcache_handle *h, struct browser_window *bw, browser_mouse_state mouse, int x, int y)
Handle mouse movements in a content window.
Definition: content.c:398
content_can_reformat
bool content_can_reformat(hlcache_handle *h)
Get whether a content can reformat.
Definition: content.c:258
content_drop_file_at_point
bool content_drop_file_at_point(struct hlcache_handle *h, int x, int y, char *file)
Drag and drop a file at coordinate.
Definition: content.c:906
content_reformat
void content_reformat(hlcache_handle *h, bool background, int width, int height)
Reformat to new size.
Definition: content.c:321
content_get_refresh_url
nsurl * content_get_refresh_url(hlcache_handle *h)
Retrieve the refresh URL for a content.
Definition: content.c:1247
content_get_status_message
const char * content_get_status_message(hlcache_handle *h)
Retrieve status message associated with content.
Definition: content.c:1141
content_open
nserror content_open(hlcache_handle *h, struct browser_window *bw, struct content *page, struct object_params *params)
A window containing the content has been opened.
Definition: content.c:791
content_get_status
content_status content_get_status(hlcache_handle *h)
Retrieve status of content.
Definition: content.c:1124
content_debug.h
Interface to content handling debug.
CONTENT_STATUS_READY
@ CONTENT_STATUS_READY
Some parts of content still being loaded, but can be displayed.
Definition: content_type.h:92
CONTENT_STATUS_DONE
@ CONTENT_STATUS_DONE
Content has completed all processing.
Definition: content_type.h:95
content_type
content_type
The type of a content.
Definition: content_type.h:53
CONTENT_IMAGE
@ CONTENT_IMAGE
All images.
Definition: content_type.h:67
CONTENT_ANY
@ CONTENT_ANY
Any content matches.
Definition: content_type.h:82
CONTENT_THEME
@ CONTENT_THEME
RISC OS themes content.
Definition: content_type.h:73
CONTENT_HTML
@ CONTENT_HTML
content is HTML
Definition: content_type.h:58
CONTENT_TEXTPLAIN
@ CONTENT_TEXTPLAIN
content is plain text
Definition: content_type.h:61
CONTENT_MSG_TEXTSEARCH
@ CONTENT_MSG_TEXTSEARCH
A free text search action has occurred.
Definition: content_type.h:179
CONTENT_MSG_LINK
@ CONTENT_MSG_LINK
RFC5988 link.
Definition: content_type.h:143
CONTENT_MSG_SELECTMENU
@ CONTENT_MSG_SELECTMENU
Create a select menu.
Definition: content_type.h:173
CONTENT_MSG_REFRESH
@ CONTENT_MSG_REFRESH
wants refresh
Definition: content_type.h:137
CONTENT_MSG_GETDIMS
@ CONTENT_MSG_GETDIMS
Get viewport dimensions.
Definition: content_type.h:149
CONTENT_MSG_GADGETCLICK
@ CONTENT_MSG_GADGETCLICK
A gadget has been clicked on (mainly for file)
Definition: content_type.h:176
CONTENT_MSG_STATUS
@ CONTENT_MSG_STATUS
new status string
Definition: content_type.h:128
CONTENT_MSG_SCROLL
@ CONTENT_MSG_SCROLL
Request to scroll content.
Definition: content_type.h:152
CONTENT_MSG_LOG
@ CONTENT_MSG_LOG
Content wishes to log something.
Definition: content_type.h:107
CONTENT_MSG_DONE
@ CONTENT_MSG_DONE
content has finished processing
Definition: content_type.h:119
CONTENT_MSG_DOWNLOAD
@ CONTENT_MSG_DOWNLOAD
download, not for display
Definition: content_type.h:140
CONTENT_MSG_LOADING
@ CONTENT_MSG_LOADING
fetching or converting
Definition: content_type.h:113
CONTENT_MSG_ERROR
@ CONTENT_MSG_ERROR
error occurred
Definition: content_type.h:122
CONTENT_MSG_REDIRECT
@ CONTENT_MSG_REDIRECT
fetch url redirect occured
Definition: content_type.h:125
CONTENT_MSG_DRAGSAVE
@ CONTENT_MSG_DRAGSAVE
Allow drag saving of content.
Definition: content_type.h:155
CONTENT_MSG_POINTER
@ CONTENT_MSG_POINTER
Wants a specific mouse pointer set.
Definition: content_type.h:161
CONTENT_MSG_SELECTION
@ CONTENT_MSG_SELECTION
A selection made or cleared.
Definition: content_type.h:164
CONTENT_MSG_SSL_CERTS
@ CONTENT_MSG_SSL_CERTS
Content is from SSL and this is its chain.
Definition: content_type.h:110
CONTENT_MSG_DRAG
@ CONTENT_MSG_DRAG
A drag started or ended.
Definition: content_type.h:170
CONTENT_MSG_GETTHREAD
@ CONTENT_MSG_GETTHREAD
Javascript thread.
Definition: content_type.h:146
CONTENT_MSG_REDRAW
@ CONTENT_MSG_REDRAW
needs redraw (eg.
Definition: content_type.h:134
CONTENT_MSG_READY
@ CONTENT_MSG_READY
may be displayed
Definition: content_type.h:116
CONTENT_MSG_SAVELINK
@ CONTENT_MSG_SAVELINK
Allow URL to be saved.
Definition: content_type.h:158
CONTENT_MSG_REFORMAT
@ CONTENT_MSG_REFORMAT
content_reformat done
Definition: content_type.h:131
CONTENT_MSG_CARET
@ CONTENT_MSG_CARET
Caret movement / hiding.
Definition: content_type.h:167
content_debug
content_debug
Debugging dump operations.
Definition: content_type.h:30
CONTENT_ENCODING_NORMAL
@ CONTENT_ENCODING_NORMAL
The content encoding.
Definition: content_type.h:45
corestrings.h
Useful interned string pointers (interface).
download_context_create
nserror download_context_create(llcache_handle *llcache, struct gui_window *parent)
Create a download context.
Definition: download.c:248
download.h
Core download context (interface)
global_history_add
nserror global_history_add(nsurl *url)
Add an entry to the global history.
Definition: global_history.c:829
global_history.h
hotlist_update_url
void hotlist_update_url(nsurl *url)
Update given URL, e.g.
Definition: hotlist.c:1602
theme.h
GUI Themeing interface.
parent
wimp_w parent
Definition: dialog.c:88
errors.h
Error codes.
nserror
nserror
Enumeration of error codes.
Definition: errors.h:29
NSERROR_TIMEOUT
@ NSERROR_TIMEOUT
Operation timed out.
Definition: errors.h:65
NSERROR_NOT_FOUND
@ NSERROR_NOT_FOUND
Requested item not found.
Definition: errors.h:34
NSERROR_BAD_CONTENT
@ NSERROR_BAD_CONTENT
Bad Content.
Definition: errors.h:56
NSERROR_BAD_AUTH
@ NSERROR_BAD_AUTH
Fetch needs authentication data.
Definition: errors.h:63
NSERROR_NOT_IMPLEMENTED
@ NSERROR_NOT_IMPLEMENTED
Functionality is not implemented.
Definition: errors.h:61
NSERROR_BAD_PARAMETER
@ NSERROR_BAD_PARAMETER
Bad Parameter.
Definition: errors.h:48
NSERROR_BAD_CERTS
@ NSERROR_BAD_CERTS
Fetch needs certificate chain check.
Definition: errors.h:64
NSERROR_NO_FETCH_HANDLER
@ NSERROR_NO_FETCH_HANDLER
No fetch handler for URL scheme.
Definition: errors.h:33
NSERROR_NEED_DATA
@ NSERROR_NEED_DATA
More data needed.
Definition: errors.h:46
NSERROR_FRAME_DEPTH
@ NSERROR_FRAME_DEPTH
Exceeded frame depth.
Definition: errors.h:57
NSERROR_INVALID
@ NSERROR_INVALID
Invalid data.
Definition: errors.h:49
NSERROR_NOMEM
@ NSERROR_NOMEM
Memory exhaustion.
Definition: errors.h:32
NSERROR_OK
@ NSERROR_OK
No error.
Definition: errors.h:30
root
static struct directory * root
Definition: filename.c:55
type
const char * type
Definition: filetype.cpp:44
form_internal.h
Interface to form handling functions internal to HTML content handler.
GADGET_FILE
@ GADGET_FILE
Definition: form_internal.h:58
GADGET_SELECT
@ GADGET_SELECT
Definition: form_internal.h:52
browser_window_destroy_iframes
nserror browser_window_destroy_iframes(struct browser_window *bw)
Destroy iframes opened in browser_window_create_iframes()
Definition: frames.c:307
browser_window_recalculate_frameset
void browser_window_recalculate_frameset(struct browser_window *bw)
Recalculate frameset positions following a resize.
Definition: frames.c:718
browser_window_recalculate_iframes
void browser_window_recalculate_iframes(struct browser_window *bw)
Recalculate iframe positions following a resize.
Definition: frames.c:291
browser_window_handle_scrollbars
void browser_window_handle_scrollbars(struct browser_window *bw)
Create, remove, and update browser window scrollbars.
Definition: frames.c:99
browser_window_create_iframes
nserror browser_window_create_iframes(struct browser_window *bw)
Create and open iframes for a browser window.
Definition: frames.c:192
browser_window_invalidate_iframe
nserror browser_window_invalidate_iframe(struct browser_window *bw)
Invalidate an iframe causing a redraw.
Definition: frames.c:185
browser_window_resize_frame
void browser_window_resize_frame(struct browser_window *bw, int x, int y)
Resize a browser window that is a frame.
Definition: frames.c:740
browser_window_create_frameset
nserror browser_window_create_frameset(struct browser_window *bw)
Create and open a frameset for a browser window.
Definition: frames.c:693
frames.h
Frame and frameset creation and manipulation (interface).
guit
struct netsurf_table * guit
The global interface table.
Definition: gui_factory.c:50
gui_internal.h
Interface to core interface table.
hlcache_handle_get_content
struct content * hlcache_handle_get_content(const hlcache_handle *handle)
Retrieve a content object from a cache handle.
Definition: hlcache.c:776
hlcache_handle_abort
nserror hlcache_handle_abort(hlcache_handle *handle)
Abort a high-level cache fetch.
Definition: hlcache.c:786
hlcache_handle_release
nserror hlcache_handle_release(hlcache_handle *handle)
Release a high-level cache handle.
Definition: hlcache.c:740
hlcache_handle_retrieve
nserror hlcache_handle_retrieve(nsurl *url, uint32_t flags, nsurl *referer, llcache_post_data *post, hlcache_handle_callback cb, void *pw, hlcache_child_context *child, content_type accepted_types, hlcache_handle **result)
Retrieve a high-level cache handle for an object.
Definition: hlcache.c:679
hlcache.h
High-level resource cache interface.
HLCACHE_RETRIEVE_SNIFF_TYPE
@ HLCACHE_RETRIEVE_SNIFF_TYPE
Definition: hlcache.h:75
HLCACHE_RETRIEVE_MAY_DOWNLOAD
@ HLCACHE_RETRIEVE_MAY_DOWNLOAD
It's permitted to convert this request into a download.
Definition: hlcache.h:73
html_get_stylesheets
struct html_stylesheet * html_get_stylesheets(hlcache_handle *h, unsigned int *n)
Retrieve stylesheets used by HTML document.
Definition: css.c:498
html_get_base_target
const char * html_get_base_target(hlcache_handle *h)
Retrieve an HTML content's base target.
Definition: html.c:2054
html_get_id_offset
bool html_get_id_offset(hlcache_handle *h, lwc_string *frag_id, int *x, int *y)
Retrieve layout coordinates of box with given id.
Definition: html.c:2073
html_set_file_gadget_filename
void html_set_file_gadget_filename(struct hlcache_handle *hl, struct form_control *gadget, const char *fn)
set filename on a file gadget
Definition: html.c:1666
html.h
Interface to text/html content handler.
html_get_objects
struct content_html_object * html_get_objects(struct hlcache_handle *h, unsigned int *n)
Retrieve objects used by HTML document.
Definition: object.c:60
STYLESHEET_START
#define STYLESHEET_START
Definition: html.h:152
content.h
Public content interface.
content_redraw
bool content_redraw(struct hlcache_handle *h, struct content_redraw_data *data, const struct rect *clip, const struct redraw_context *ctx)
Display content on screen with optional tiling.
Definition: content.c:558
hlcache_handle_get_url
struct nsurl * hlcache_handle_get_url(const struct hlcache_handle *handle)
Retrieve the URL associated with a high level cache handle.
content_get_title
const char * content_get_title(struct hlcache_handle *h)
Retrieve title associated with content.
Definition: content.c:1106
content_get_height
int content_get_height(struct hlcache_handle *h)
Retrieve height of content.
Definition: content.c:1175
content_get_width
int content_get_width(struct hlcache_handle *h)
Retrieve width of content.
Definition: content.c:1158
content_invalidate_reuse_data
void content_invalidate_reuse_data(struct hlcache_handle *h)
Invalidate content reuse data.
Definition: content.c:1229
content_get_encoding
const char * content_get_encoding(struct hlcache_handle *h, enum content_encoding_type op)
Retrieve the encoding of a content.
Definition: content.c:1321
content_get_type
content_type content_get_type(struct hlcache_handle *h)
Retrieve computed type of content.
Definition: content.c:1061
misc.h
Interface to platform-specific miscellaneous browser operation table.
browser_pointer_shape
browser_pointer_shape
Mouse pointer type.
Definition: mouse.h:112
BROWSER_POINTER_AUTO
@ BROWSER_POINTER_AUTO
Definition: mouse.h:132
BROWSER_POINTER_MOVE
@ BROWSER_POINTER_MOVE
Definition: mouse.h:126
BROWSER_POINTER_DEFAULT
@ BROWSER_POINTER_DEFAULT
Definition: mouse.h:113
browser_mouse_state
browser_mouse_state
Mouse state.
Definition: mouse.h:43
BROWSER_MOUSE_CLICK_2
@ BROWSER_MOUSE_CLICK_2
button 2 clicked.
Definition: mouse.h:57
BROWSER_MOUSE_CLICK_1
@ BROWSER_MOUSE_CLICK_1
button 1 clicked.
Definition: mouse.h:55
BROWSER_MOUSE_MOD_2
@ BROWSER_MOUSE_MOD_2
2nd modifier key pressed (eg.
Definition: mouse.h:80
BROWSER_MOUSE_DRAG_1
@ BROWSER_MOUSE_DRAG_1
start of button 1 drag
Definition: mouse.h:65
BROWSER_MOUSE_DRAG_2
@ BROWSER_MOUSE_DRAG_2
start of button 2 drag
Definition: mouse.h:67
gui_pointer_shape
gui_pointer_shape
Definition: mouse.h:89
GUI_POINTER_PROGRESS
@ GUI_POINTER_PROGRESS
Definition: mouse.h:108
GUI_POINTER_DEFAULT
@ GUI_POINTER_DEFAULT
Definition: mouse.h:90
plotters.h
Target independent plotting interface.
search.h
Interface to platform-specific search operations.
window.h
Interface to platform-specific graphical user interface window operations.
gui_window_create_flags
gui_window_create_flags
Window creation control flags.
Definition: window.h:66
GW_CREATE_NONE
@ GW_CREATE_NONE
New window.
Definition: window.h:67
GW_CREATE_TAB
@ GW_CREATE_TAB
Create tab in same window as existing.
Definition: window.h:69
GW_CREATE_FOREGROUND
@ GW_CREATE_FOREGROUND
Request this window/tab is foregrounded.
Definition: window.h:70
GW_CREATE_FOCUS_LOCATION
@ GW_CREATE_FOCUS_LOCATION
Definition: window.h:71
GW_CREATE_CLONE
@ GW_CREATE_CLONE
Clone existing window.
Definition: window.h:68
GUI_SAVE_OBJECT_ORIG
@ GUI_SAVE_OBJECT_ORIG
Definition: window.h:45
GUI_SAVE_SOURCE
@ GUI_SAVE_SOURCE
Definition: window.h:40
GUI_SAVE_OBJECT_NATIVE
@ GUI_SAVE_OBJECT_NATIVE
Definition: window.h:46
GUI_SAVE_COMPLETE
@ GUI_SAVE_COMPLETE
Definition: window.h:44
gui_drag_type
gui_drag_type
Definition: window.h:56
GDRAGGING_SCROLLBAR
@ GDRAGGING_SCROLLBAR
Definition: window.h:58
GDRAGGING_OTHER
@ GDRAGGING_OTHER
Definition: window.h:60
GW_EVENT_SCROLL_START
@ GW_EVENT_SCROLL_START
Starts drag scrolling of a browser window.
Definition: window.h:113
GW_EVENT_PAGE_INFO_CHANGE
@ GW_EVENT_PAGE_INFO_CHANGE
Page status has changed and so the padlock should be updated.
Definition: window.h:129
GW_EVENT_NEW_CONTENT
@ GW_EVENT_NEW_CONTENT
Called when the gui_window has new content.
Definition: window.h:118
GW_EVENT_STOP_THROBBER
@ GW_EVENT_STOP_THROBBER
stop the navigation throbber.
Definition: window.h:108
GW_EVENT_UPDATE_EXTENT
@ GW_EVENT_UPDATE_EXTENT
Update the extent of the inside of a browser window to that of the current content.
Definition: window.h:93
GW_EVENT_START_THROBBER
@ GW_EVENT_START_THROBBER
start the navigation throbber.
Definition: window.h:103
js.h
Interface to javascript engine functions.
js_destroyheap
void js_destroyheap(jsheap *heap)
Destroy a previously created heap.
Definition: dukky.c:638
js_newheap
nserror js_newheap(int timeout, jsheap **heap)
Create a new javascript heap.
Definition: dukky.c:598
js_newthread
nserror js_newthread(jsheap *heap, void *win_priv, void *doc_priv, jsthread **thread)
Create a new javascript thread.
Definition: dukky.c:650
knockout_plot_end
bool knockout_plot_end(const struct redraw_context *ctx)
End a knockout plotting session.
Definition: knockout.c:997
knockout_plot_start
bool knockout_plot_start(const struct redraw_context *ctx, struct redraw_context *knk_ctx)
Start a knockout plotting session.
Definition: knockout.c:971
knockout.h
Knockout rendering (interface).
llcache_handle_abort
nserror llcache_handle_abort(llcache_handle *handle)
Abort a low-level fetch, informing all users of this action.
Definition: llcache.c:4098
llcache_handle_retrieve
nserror llcache_handle_retrieve(nsurl *url, uint32_t flags, nsurl *referer, const llcache_post_data *post, llcache_handle_callback cb, void *pw, llcache_handle **result)
Retrieve a handle for a low-level cache object.
Definition: llcache.c:3990
llcache_handle_release
nserror llcache_handle_release(llcache_handle *handle)
Release a low-level cache handle.
Definition: llcache.c:4058
LLCACHE_RETRIEVE_STREAM_DATA
@ LLCACHE_RETRIEVE_STREAM_DATA
Definition: llcache.h:63
LLCACHE_RETRIEVE_VERIFIABLE
@ LLCACHE_RETRIEVE_VERIFIABLE
Requested URL was verified.
Definition: llcache.h:59
LLCACHE_RETRIEVE_FORCE_FETCH
@ LLCACHE_RETRIEVE_FORCE_FETCH
Force a new fetch.
Definition: llcache.h:57
NSLOG
#define NSLOG(catname, level, logmsg, args...)
Definition: log.h:116
messages_get_errorcode
const char * messages_get_errorcode(nserror code)
lookup of a message by errorcode from the standard Messages hash.
Definition: messages.c:248
messages_get
const char * messages_get(const char *key)
Fast lookup of a message by key from the standard Messages hash.
Definition: messages.c:241
messages_get_sslcode
const char * messages_get_sslcode(ssl_cert_err code)
lookup of a message by SSL error code from the standard Messages hash.
Definition: messages.c:405
messages.h
Localised message support (interface).
nsurl_compare
bool nsurl_compare(const nsurl *url1, const nsurl *url2, nsurl_component parts)
Compare two URLs.
nsurl_create
nserror nsurl_create(const char *const url_s, nsurl **url)
Create a NetSurf URL object from a URL string.
nsurl_unref
void nsurl_unref(nsurl *url)
Drop a reference to a NetSurf URL object.
nsurl_refragment
nserror nsurl_refragment(const nsurl *url, lwc_string *frag, nsurl **new_url)
Create a NetSurf URL object, adding a fragment to an existing URL object.
nsurl_access
const char * nsurl_access(const nsurl *url)
Access a NetSurf URL object as a string.
nsurl_has_component
bool nsurl_has_component(const nsurl *url, nsurl_component part)
Enquire about the existence of componenets in a given URL.
nsurl_ref
nsurl * nsurl_ref(nsurl *url)
Increment the reference count to a NetSurf URL object.
nsurl_get_component
lwc_string * nsurl_get_component(const nsurl *url, nsurl_component part)
Get part of a URL as a lwc_string, from a NetSurf URL object.
NSURL_FRAGMENT
@ NSURL_FRAGMENT
Definition: nsurl.h:56
NSURL_SCHEME
@ NSURL_SCHEME
Definition: nsurl.h:45
NSURL_PATH
@ NSURL_PATH
Definition: nsurl.h:52
NSURL_HOST
@ NSURL_HOST
Definition: nsurl.h:49
NSURL_COMPLETE
@ NSURL_COMPLETE
Definition: nsurl.h:54
NSURL_QUERY
@ NSURL_QUERY
Definition: nsurl.h:53
nsurl_join
nserror nsurl_join(const nsurl *base, const char *rel, nsurl **joined)
Join a base url to a relative link part, creating a new NetSurf URL object.
nsurl
struct nsurl nsurl
NetSurf URL object.
Definition: nsurl.h:31
nsurl_parent
nserror nsurl_parent(const nsurl *url, nsurl **new_url)
Create a NetSurf URL object for URL with parent location of an existing URL.
plot_style_fill_white
plot_style_t * plot_style_fill_white
Definition: plot_style.c:32
width
int width
Definition: gui.c:160
height
int height
Definition: gui.c:161
scrollbar_mouse_status_to_message
const char * scrollbar_mouse_status_to_message(scrollbar_mouse_status status)
Get a status bar message from a scrollbar mouse input status.
Definition: scrollbar.c:889
scrollbar_mouse_action
scrollbar_mouse_status scrollbar_mouse_action(struct scrollbar *s, browser_mouse_state mouse, int x, int y)
Handle mouse actions other then drag ends.
Definition: scrollbar.c:769
scrollbar_get_offset
int scrollbar_get_offset(struct scrollbar *s)
Get the current scroll offset to the visible part of the full area.
Definition: scrollbar.c:628
scrollbar_redraw
nserror scrollbar_redraw(struct scrollbar *s, int x, int y, const struct rect *clip, float scale, const struct redraw_context *ctx)
Redraw a part of the scrollbar.
Definition: scrollbar.c:239
scrollbar_scroll
bool scrollbar_scroll(struct scrollbar *s, int change)
Scroll the scrollbar by given amount.
Definition: scrollbar.c:562
scrollbar_destroy
void scrollbar_destroy(struct scrollbar *s)
Destroy a scrollbar.
Definition: scrollbar.c:138
scrollbar_set
void scrollbar_set(struct scrollbar *s, int value, bool bar_pos)
Set the scroll value of the scrollbar.
Definition: scrollbar.c:512
scrollbar_mouse_drag_end
void scrollbar_mouse_drag_end(struct scrollbar *s, browser_mouse_state mouse, int x, int y)
Handle end of mouse drags.
Definition: scrollbar.c:933
scrollbar.h
Scrollbar widget interface.
SCROLLBAR_WIDTH
#define SCROLLBAR_WIDTH
Definition: scrollbar.h:32
ssl_cert_err
ssl_cert_err
ssl certificate error status
Definition: ssl_certs.h:36
SSL_CERT_ERR_OK
@ SSL_CERT_ERR_OK
Nothing wrong with this certificate.
Definition: ssl_certs.h:37
SSL_CERT_ERR_UNKNOWN
@ SSL_CERT_ERR_UNKNOWN
Unknown error.
Definition: ssl_certs.h:38
cert_chain_dup
nserror cert_chain_dup(const struct cert_chain *src, struct cert_chain **dst_out)
duplicate a certificate chain
Definition: ssl_certs.c:101
cert_chain_free
nserror cert_chain_free(struct cert_chain *chain)
free a certificate chain
Definition: ssl_certs.c:317
cert_chain_to_query
nserror cert_chain_to_query(struct cert_chain *chain, struct nsurl **url_out)
create a fetch query string from a certificate chain
Definition: ssl_certs.c:226
string.h
Interface to utility string handling.
browser_fetch_parameters
The parameters for a fetch.
Definition: browser_private.h:82
browser_fetch_parameters::url
struct nsurl * url
The URL to fetch.
Definition: browser_private.h:83
browser_fetch_parameters::flags
enum browser_window_nav_flags flags
Navigation flags.
Definition: browser_private.h:85
browser_fetch_parameters::parent_charset
char * parent_charset
Optional parent character set.
Definition: browser_private.h:88
browser_fetch_parameters::parent_quirks
bool parent_quirks
Optional parent quirks.
Definition: browser_private.h:89
browser_fetch_parameters::post_multipart
struct fetch_multipart_data * post_multipart
Multipart post data.
Definition: browser_private.h:87
browser_fetch_parameters::post_urlenc
char * post_urlenc
URL encoded post data.
Definition: browser_private.h:86
browser_fetch_parameters::referrer
struct nsurl * referrer
Optional refererer.
Definition: browser_private.h:84
browser_window_features
Page features at a specific spatial location.
Definition: browser_window.h:153
browser_window_features::object
struct hlcache_handle * object
Object at position or NULL.
Definition: browser_window.h:158
browser_window_features::main
struct hlcache_handle * main
handle of top level content.
Definition: browser_window.h:161
browser_window_features::form_features
enum browser_window_features::@56 form_features
type of form feature.
browser_window_features::link
struct nsurl * link
URL of a link or NULL.
Definition: browser_window.h:155
browser_window
Browser window data.
Definition: browser_private.h:96
browser_window::start_scroll_y
int start_scroll_y
Definition: browser_private.h:187
browser_window::loading_parameters
struct browser_fetch_parameters loading_parameters
The fetch parameters for the loading content.
Definition: browser_private.h:122
browser_window::BROWSER_WINDOW_NORMAL
@ BROWSER_WINDOW_NORMAL
Definition: browser_private.h:216
browser_window::BROWSER_WINDOW_IFRAME
@ BROWSER_WINDOW_IFRAME
Definition: browser_private.h:217
browser_window::BROWSER_WINDOW_FRAMESET
@ BROWSER_WINDOW_FRAMESET
Definition: browser_private.h:219
browser_window::BROWSER_WINDOW_FRAME
@ BROWSER_WINDOW_FRAME
Definition: browser_private.h:218
browser_window::height
int height
Definition: browser_private.h:206
browser_window::scrolling
browser_scrolling scrolling
Definition: browser_private.h:237
browser_window::iframes
struct browser_window * iframes
Definition: browser_private.h:250
browser_window::scroll_x
struct scrollbar * scroll_x
Horizontal scroll.
Definition: browser_private.h:208
browser_window::drag
struct browser_window::@59 drag
Current drag status.
browser_window::x
int x
Window dimensions.
Definition: browser_private.h:203
browser_window::bw
struct browser_window * bw
Definition: browser_private.h:260
browser_window::scale
float scale
scale of window contents
Definition: browser_private.h:212
browser_window::rows
int rows
frameset characteristics
Definition: browser_private.h:223
browser_window::favicon
struct browser_window::@58 favicon
Favicon.
browser_window::text
char * text
Current status bar text.
Definition: browser_private.h:270
browser_window::start_scroll_x
int start_scroll_x
Scroll offsets at start of current scroll draw.
Definition: browser_private.h:186
browser_window::match
int match
Number of times an idempotent status-set operation was performed.
Definition: browser_private.h:272
browser_window::scroll_y
struct scrollbar * scroll_y
Vertical scroll.
Definition: browser_private.h:209
browser_window::miss
int miss
Number of times status was really updated.
Definition: browser_private.h:273
browser_window::history_add
bool history_add
Add loading_content to the window history when it loads.
Definition: browser_private.h:162
browser_window::width
int width
Definition: browser_private.h:205
browser_window::failed
bool failed
flag to indicate favicon fetch already failed which prevents infinite error looping.
Definition: browser_private.h:148
browser_window::iframe_count
int iframe_count
[iframe_count] iframes
Definition: browser_private.h:249
browser_window::loading_cert_chain
struct cert_chain * loading_cert_chain
The certificate chain for the loading content.
Definition: browser_private.h:127
browser_window::can_edit
bool can_edit
Definition: browser_private.h:263
browser_window::refresh_interval
int refresh_interval
Refresh interval (-1 if undefined)
Definition: browser_private.h:200
browser_window::parent
struct browser_window * parent
Definition: browser_private.h:246
browser_window::status
struct browser_window::@62 status
cache of the currently displayed status text.
browser_window::current_cert_chain
struct cert_chain * current_cert_chain
The certificate chain for the current content.
Definition: browser_private.h:111
browser_window::read_only
bool read_only
Definition: browser_private.h:261
browser_window::frag_id
lwc_string * frag_id
Fragment identifier for current_content.
Definition: browser_private.h:167
browser_window::last_action
uint64_t last_action
Last time a link was followed in this window.
Definition: browser_private.h:256
browser_window::current
struct hlcache_handle * current
content handle of current page favicon
Definition: browser_private.h:136
browser_window::window
struct gui_window * window
Platform specific window data only valid at top level.
Definition: browser_private.h:157
browser_window::text_len
int text_len
Length of the status::text buffer.
Definition: browser_private.h:271
browser_window::start_x
int start_x
Mouse position at start of current scroll drag.
Definition: browser_private.h:182
browser_window::no_resize
bool no_resize
frame characteristics
Definition: browser_private.h:236
browser_window::throbbing
bool throbbing
Busy indicator is active.
Definition: browser_private.h:160
browser_window::loading
struct hlcache_handle * loading
content handle for favicon which we started loading early
Definition: browser_private.h:142
browser_window::history
struct history * history
local history handle.
Definition: browser_private.h:152
browser_window::jsheap
struct jsheap * jsheap
current javascript context
Definition: browser_private.h:266
browser_window::children
struct browser_window * children
[cols * rows] children
Definition: browser_private.h:245
browser_window::type
browser_drag_type type
the type of drag in progress
Definition: browser_private.h:176
browser_window::current_content
struct hlcache_handle * current_content
Content handle of page currently displayed which must have READY or DONE status or NULL for no conten...
Definition: browser_private.h:101
browser_window::selection
struct browser_window::@61 selection
Current selection.
browser_window::y
int y
Definition: browser_private.h:204
browser_window::internal_nav
bool internal_nav
Internal navigation, do not update URL etc.
Definition: browser_private.h:164
browser_window::cols
int cols
Definition: browser_private.h:224
browser_window::name
char * name
frame name for targetting
Definition: browser_private.h:233
browser_window::start_y
int start_y
Definition: browser_private.h:183
browser_window::border
bool border
Definition: browser_private.h:238
browser_window::loading_content
struct hlcache_handle * loading_content
Content handle of page in process of being loaded or NULL if no page is being loaded.
Definition: browser_private.h:117
browser_window::browser_window_type
enum browser_window::@60 browser_window_type
Window characteristics.
browser_window::current_parameters
struct browser_fetch_parameters current_parameters
The fetch parameters for the current content.
Definition: browser_private.h:106
browser_window::focus
struct browser_window * focus
browser window child of root browser window which has input focus
Definition: browser_private.h:253
cert_chain
X509 certificate chain.
Definition: ssl_certs.h:59
cert_chain::certs
struct cert_chain::@57 certs[MAX_CERT_DEPTH]
cert_chain::depth
size_t depth
the number of certificates in the chain
Definition: ssl_certs.h:63
cert_chain::err
ssl_cert_err err
Whatever is wrong with this certificate.
Definition: ssl_certs.h:68
content_html_object
An object (img, object, etc.
Definition: html.h:93
content_html_object::content
struct hlcache_handle * content
Content, or 0.
Definition: html.h:97
content_redraw_data
parameters to content redraw
Definition: content.h:40
content_redraw_data::height
int height
vertical dimension
Definition: content.h:48
content_redraw_data::repeat_y
bool repeat_y
whether content is tiled in y direction
Definition: content.h:59
content_redraw_data::repeat_x
bool repeat_x
whether content is tiled in x direction
Definition: content.h:58
content_redraw_data::y
int y
coordinate for top-left of redraw
Definition: content.h:42
content_redraw_data::x
int x
coordinate for top-left of redraw
Definition: content.h:41
content_redraw_data::background_colour
colour background_colour
The background colour.
Definition: content.h:51
content_redraw_data::width
int width
dimensions to render content at (for scaling contents with intrinsic dimensions)
Definition: content.h:47
content_redraw_data::scale
float scale
Scale for redraw (for scaling contents without intrinsic dimensions)
Definition: content.h:56
content_rfc5988_link
RFC5988 metadata link.
Definition: content.h:48
content_rfc5988_link::rel
lwc_string * rel
the link relationship - must be present
Definition: content.h:51
content_rfc5988_link::href
struct nsurl * href
the link href - must be present
Definition: content.h:52
fetch_multipart_data
Fetch POST multipart data.
Definition: fetch.h:109
form_control
Form control.
Definition: form_internal.h:73
form_control::type
form_control_type type
Type of control.
Definition: form_internal.h:79
gui_misc_table::schedule
nserror(* schedule)(int t, void(*callback)(void *p), void *p)
Schedule a callback.
Definition: misc.h:58
gui_misc_table::launch_url
nserror(* launch_url)(struct nsurl *url)
core has no fetcher for url
Definition: misc.h:71
gui_misc_table::login
nserror(* login)(struct nsurl *url, const char *realm, const char *username, const char *password, nserror(*cb)(struct nsurl *url, const char *realm, const char *username, const char *password, void *pw), void *cbpw)
Retrieve username/password for a given url+realm if there is one stored in a frontend-specific way (e...
Definition: misc.h:105
gui_misc_table::present_cookies
nserror(* present_cookies)(const char *search_term)
Request that the cookie manager be displayed.
Definition: misc.h:126
gui_search_table::back_state
void(* back_state)(bool active, void *p)
activate search back button in gui
Definition: search.h:72
gui_search_table::add_recent
void(* add_recent)(const char *string, void *p)
add search string to recent searches list front has full liberty how to implement the bare notificati...
Definition: search.h:56
gui_search_table::forward_state
void(* forward_state)(bool active, void *p)
activate search forwards button in gui
Definition: search.h:64
gui_search_table::status
void(* status)(bool found, void *p)
Change the displayed search status.
Definition: search.h:38
gui_search_table::hourglass
void(* hourglass)(bool active, void *p)
display hourglass while searching.
Definition: search.h:46
gui_window_table::get_dimensions
nserror(* get_dimensions)(struct gui_window *gw, int *width, int *height)
Find the current dimensions of a browser window's content area.
Definition: window.h:241
gui_window_table::set_title
void(* set_title)(struct gui_window *gw, const char *title)
Set the title of a window.
Definition: window.h:264
gui_window_table::set_scroll
nserror(* set_scroll)(struct gui_window *gw, const struct rect *rect)
Set the scroll position of a browser window.
Definition: window.h:224
gui_window_table::drag_start
bool(* drag_start)(struct gui_window *g, gui_drag_type type, const struct rect *rect)
start a drag operation within a window
Definition: window.h:317
gui_window_table::set_pointer
void(* set_pointer)(struct gui_window *g, enum gui_pointer_shape shape)
Change mouse pointer shape.
Definition: window.h:296
gui_window_table::save_link
nserror(* save_link)(struct gui_window *g, struct nsurl *url, const char *title)
save link operation
Definition: window.h:327
gui_window_table::set_icon
void(* set_icon)(struct gui_window *gw, struct hlcache_handle *icon)
Set a favicon for a gui window.
Definition: window.h:280
gui_window_table::invalidate
nserror(* invalidate)(struct gui_window *gw, const struct rect *rect)
Invalidate an area of a window.
Definition: window.h:194
gui_window_table::event
nserror(* event)(struct gui_window *gw, enum gui_window_event event)
Miscellaneous event occurred for a window.
Definition: window.h:254
gui_window_table::destroy
void(* destroy)(struct gui_window *gw)
Destroy previously created gui window.
Definition: window.h:174
gui_window_table::get_scroll
bool(* get_scroll)(struct gui_window *gw, int *sx, int *sy)
Get the scroll position of a browser window.
Definition: window.h:205
gui_window_table::create_form_select_menu
void(* create_form_select_menu)(struct gui_window *gw, struct form_control *control)
create a form select menu
Definition: window.h:335
gui_window_table::drag_save_object
void(* drag_save_object)(struct gui_window *gw, struct hlcache_handle *c, gui_save_type type)
object dragged to window
Definition: window.h:353
gui_window_table::console_log
void(* console_log)(struct gui_window *gw, browser_window_console_source src, const char *msg, size_t msglen, browser_window_console_flags flags)
console logging happening.
Definition: window.h:374
gui_window_table::create
struct gui_window *(* create)(struct browser_window *bw, struct gui_window *existing, gui_window_create_flags flags)
Create and open a gui window for a browsing context.
Definition: window.h:164
gui_window_table::set_url
nserror(* set_url)(struct gui_window *gw, struct nsurl *url)
Set the navigation url.
Definition: window.h:272
gui_window_table::set_status
void(* set_status)(struct gui_window *g, const char *text)
Set the status bar message of a browser window.
Definition: window.h:288
gui_window_table::file_gadget_open
void(* file_gadget_open)(struct gui_window *gw, struct hlcache_handle *hl, struct form_control *gadget)
Called when file chooser gadget is activated.
Definition: window.h:344
history
History tree for a window.
Definition: browser_private.h:68
history::current
struct history_entry * current
Current position in tree.
Definition: browser_private.h:72
hlcache_child_context
Context for retrieving a child object.
Definition: hlcache.h:37
hlcache_child_context::quirks
bool quirks
Whether parent is quirky.
Definition: hlcache.h:39
hlcache_child_context::charset
const char * charset
Charset of parent.
Definition: hlcache.h:38
hlcache_event
High-level cache event.
Definition: hlcache.h:43
hlcache_event::type
content_msg type
Event type.
Definition: hlcache.h:44
hlcache_event::data
union content_msg_data data
Event data.
Definition: hlcache.h:45
hlcache_handle
High-level cache handle.
Definition: hlcache.c:66
html_stylesheet
Container for stylesheets used by an HTML document.
Definition: html.h:58
jsthread
dukky javascript thread
Definition: dukky.c:70
llcache_handle
Handle to low-level cache object.
Definition: llcache.c:76
llcache_post_data
POST data object for low-level cache requests.
Definition: llcache.h:40
llcache_post_data::multipart
struct fetch_multipart_data * multipart
Multipart data.
Definition: llcache.h:47
llcache_post_data::type
enum llcache_post_data::@122 type
Type of POST data.
llcache_post_data::data
union llcache_post_data::@123 data
POST data content.
llcache_post_data::urlenc
char * urlenc
URL encoded data.
Definition: llcache.h:46
netsurf_table::misc
struct gui_misc_table * misc
Browser table.
Definition: gui_table.h:57
netsurf_table::search
struct gui_search_table * search
Page search table.
Definition: gui_table.h:122
netsurf_table::window
struct gui_window_table * window
Window table.
Definition: gui_table.h:66
plotter_table::option_knockout
bool option_knockout
flag to enable knockout rendering.
Definition: plotters.h:328
plotter_table::rectangle
nserror(* rectangle)(const struct redraw_context *ctx, const plot_style_t *pstyle, const struct rect *rectangle)
Plots a rectangle.
Definition: plotters.h:188
plotter_table::clip
nserror(* clip)(const struct redraw_context *ctx, const struct rect *clip)
Sets a clip rectangle for subsequent plot operations.
Definition: plotters.h:111
rect
Rectangle coordinates.
Definition: types.h:40
rect::x0
int x0
Definition: types.h:41
rect::y0
int y0
Top left.
Definition: types.h:41
rect::x1
int x1
Definition: types.h:42
rect::y1
int y1
Bottom right.
Definition: types.h:42
redraw_context
Redraw context.
Definition: plotters.h:51
redraw_context::plot
const struct plotter_table * plot
Current plot operation table.
Definition: plotters.h:73
browser_window_remove_caret
void browser_window_remove_caret(struct browser_window *bw, bool only_hide)
Removes the caret and callback for key process.
Definition: textinput.c:88
browser_window_place_caret
void browser_window_place_caret(struct browser_window *bw, int x, int y, int height, const struct rect *clip)
Position the caret and assign a callback for key presses.
Definition: textinput.c:53
textinput.h
Textual input handling interface.
theme_install_start
void theme_install_start(struct hlcache_handle *c)
Handle a CONTENT_THEME that has started loading.
Definition: theme_install.c:56
types.h
NetSurf types.
content_msg_data::scroll
struct content_msg_data::@103 scroll
CONTENT_MSG_SCROLL - Part of content to scroll to show.
content_msg_data::x
int x
Carret x-coord.
Definition: content.h:110
content_msg_data::flags
browser_window_console_flags flags
The flags of the logging.
Definition: content.h:72
content_msg_data::area
bool area
Definition: content.h:162
content_msg_data::msg
const char * msg
The message to log.
Definition: content.h:68
content_msg_data::clip
const struct rect * clip
Carret clip rect.
Definition: content.h:215
content_msg_data::textsearch
struct content_msg_data::@111 textsearch
CONTENT_MSG_TEXTSEARCH - Free text search action.
content_msg_data::gadget_click
struct content_msg_data::@110 gadget_click
CONTENT_MSG_GADGETCLICK - User clicked on a form gadget.
content_msg_data::height
int height
Carret height.
Definition: content.h:110
content_msg_data::msglen
size_t msglen
The length of that message.
Definition: content.h:70
content_msg_data::pointer
browser_pointer_shape pointer
CONTENT_MSG_POINTER - Mouse pointer to set.
Definition: content.h:192
content_msg_data::caret
struct content_msg_data::@107 caret
CONTENT_MSG_CARET - set caret position or, hide caret.
content_msg_data::title
const char * title
Definition: content.h:186
content_msg_data::savelink
struct content_msg_data::@105 savelink
CONTENT_MSG_SAVELINK - Save a URL.
content_msg_data::selection
bool selection
false for selection cleared
Definition: content.h:198
content_msg_data::chain
const struct cert_chain * chain
CONTENT_MSG_SSL_CERTS - The certificate chain from the underlying fetch.
Definition: content.h:79
content_msg_data::rfc5988_link
struct content_rfc5988_link * rfc5988_link
CONTENT_MSG_RFC5988_LINK - rfc5988 link data.
Definition: content.h:138
content_msg_data::to
struct nsurl * to
Redirect target.
Definition: content.h:103
content_msg_data::dragsave
struct content_msg_data::@104 dragsave
CONTENT_MSG_DRAGSAVE - Drag save a content.
content_msg_data::viewport_height
unsigned * viewport_height
Definition: content.h:151
content_msg_data::drag
struct content_msg_data::@108 drag
CONTENT_MSG_DRAG - Drag start or end.
content_msg_data::select_menu
struct content_msg_data::@109 select_menu
CONTENT_MSG_SELECTMENU - Create select menu at pointer.
content_msg_data::from
struct nsurl * from
Redirect origin.
Definition: content.h:102
content_msg_data::log
struct content_msg_data::@98 log
CONTENT_MSG_LOG - Information for logging.
content_msg_data::download
struct llcache_handle * download
CONTENT_MSG_DOWNLOAD - Low-level cache handle.
Definition: content.h:133
content_msg_data::gadget
struct form_control * gadget
Definition: content.h:235
content_msg_data::src
browser_window_console_source src
The source of the logging.
Definition: content.h:66
content_msg_data::getdims
struct content_msg_data::@102 getdims
CONTENT_MSG_GETDIMS - Get the viewport dimensions.
content_msg_data::state
bool state
state for operation
Definition: content.h:281
content_msg_data::string
const char * string
search string
Definition: content.h:285
content_msg_data::type
enum content_msg_data::@104::@112 type
content_msg_data::y
int y
Carret y-coord.
Definition: content.h:110
content_msg_data::redirect
struct content_msg_data::@100 redirect
CONTENT_MSG_REDIRECT - Redirect info.
content_msg_data::url
struct nsurl * url
Definition: content.h:185
content_msg_data::rect
const struct rect * rect
Definition: content.h:228
content_msg_data::ctx
void * ctx
context passed to browser_window_search()
Definition: content.h:277
content_msg_data::explicit_status_text
const char * explicit_status_text
CONTENT_MSG_STATUS - Status message update.
Definition: content.h:128
content_msg_data::pos
struct content_msg_data::@107::@114 pos
With CONTENT_CARET_SET_POS.
content_msg_data::background
bool background
CONTENT_MSG_REFORMAT - Reformat should not cause a redraw.
Definition: content.h:121
urldb_set_cert_permissions
void urldb_set_cert_permissions(struct nsurl *url, bool permit)
Set certificate verification permissions.
Definition: urldb.c:3455
urldb_get_url
nsurl * urldb_get_url(nsurl *url)
Extract an URL from the db.
Definition: urldb.c:3327
urldb_set_url_title
nserror urldb_set_url_title(nsurl *url, const char *title)
Set an URL's title string, replacing any existing one.
Definition: urldb.c:3226
urldb_add_url
bool urldb_add_url(nsurl *url)
Insert an URL into the database.
Definition: urldb.c:3140
urldb_set_auth_details
void urldb_set_auth_details(nsurl *url, const char *realm, const char *auth)
Set authentication data for an URL.
Definition: urldb.c:3342
urldb_get_cert_permissions
bool urldb_get_cert_permissions(nsurl *url)
Retrieve certificate verification permissions from database.
Definition: urldb.c:3480
urldb_get_auth_details
const char * urldb_get_auth_details(nsurl *url, const char *realm)
Look up authentication details in database.
Definition: urldb.c:3405
urldb_update_url_visit_data
nserror urldb_update_url_visit_data(nsurl *url)
Update an URL's visit data.
Definition: urldb.c:3274
urldb_set_url_content_type
nserror urldb_set_url_content_type(nsurl *url, content_type type)
Set an URL's content type.
Definition: urldb.c:3256
urldb_get_cookie
char * urldb_get_cookie(nsurl *url, bool include_http_only)
Retrieve cookies for an URL.
Definition: urldb.c:3997
urldb.h
Unified URL information database internal interface.
nsoption.h
Option reading and saving interface.
nsoption_int
#define nsoption_int(OPTION)
Get the value of an integer option.
Definition: nsoption.h:313
nsoption_bool
#define nsoption_bool(OPTION)
Get the value of a boolean option.
Definition: nsoption.h:304
path
static nserror path(const struct redraw_context *ctx, const plot_style_t *pstyle, const float *p, unsigned int n, const float transform[6])
Plots a path.
Definition: plot.c:821
text
static nserror text(const struct redraw_context *ctx, const struct plot_font_style *fstyle, int x, int y, const char *text, size_t length)
Text plotting.
Definition: plot.c:978
clip
static nserror clip(const struct redraw_context *ctx, const struct rect *clip)
Sets a clip rectangle for subsequent plot operations.
Definition: plot.c:357
Generated on Sun Oct 20 2024 12:52:12 for NetSurf by doxygen 1.9.4