2003-06-30 16:44:03 +04:00
|
|
|
/*
|
2007-08-20 06:39:49 +04:00
|
|
|
* Copyright 2005-2007 James Bursa <bursa@users.sourceforge.net>
|
2003-06-30 16:44:03 +04:00
|
|
|
* Copyright 2003 Phil Mellor <monkeyson@users.sourceforge.net>
|
2005-03-26 04:12:27 +03:00
|
|
|
* Copyright 2005 John M Bell <jmb202@ecs.soton.ac.uk>
|
2010-06-04 13:35:08 +04:00
|
|
|
* Copyright 2008 Michael Drake <tlsa@netsurf-browser.org>
|
2007-08-08 20:16:03 +04:00
|
|
|
*
|
|
|
|
* This file is part of NetSurf, http://www.netsurf-browser.org/
|
|
|
|
*
|
|
|
|
* NetSurf is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; version 2 of the License.
|
|
|
|
*
|
|
|
|
* NetSurf is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2002-05-04 23:57:18 +04:00
|
|
|
*/
|
|
|
|
|
2017-01-20 00:15:08 +03:00
|
|
|
/**
|
|
|
|
* \file
|
|
|
|
* implementation of box tree manipulation.
|
2004-07-19 18:31:31 +04:00
|
|
|
*/
|
|
|
|
|
2002-05-04 23:57:18 +04:00
|
|
|
#include <assert.h>
|
2003-07-15 02:57:45 +04:00
|
|
|
#include <stdbool.h>
|
2007-08-20 06:39:49 +04:00
|
|
|
#include <stdio.h>
|
2002-05-04 23:57:18 +04:00
|
|
|
#include <string.h>
|
2012-03-25 00:55:22 +04:00
|
|
|
#include <dom/dom.h>
|
2016-04-26 14:50:16 +03:00
|
|
|
|
|
|
|
#include "utils/nsoption.h"
|
|
|
|
#include "utils/log.h"
|
|
|
|
#include "utils/talloc.h"
|
2019-11-12 21:34:39 +03:00
|
|
|
#include "utils/nsurl.h"
|
2016-06-06 10:59:23 +03:00
|
|
|
#include "netsurf/misc.h"
|
|
|
|
#include "netsurf/content.h"
|
|
|
|
#include "netsurf/mouse.h"
|
2016-06-06 16:47:27 +03:00
|
|
|
#include "css/utils.h"
|
|
|
|
#include "css/dump.h"
|
2011-05-10 02:49:17 +04:00
|
|
|
#include "desktop/scrollbar.h"
|
2016-04-26 14:50:16 +03:00
|
|
|
#include "desktop/gui_internal.h"
|
2019-11-12 21:34:39 +03:00
|
|
|
#include "desktop/search.h"
|
2016-04-26 14:50:16 +03:00
|
|
|
|
2018-05-10 13:34:26 +03:00
|
|
|
#include "html/box.h"
|
|
|
|
#include "html/form_internal.h"
|
|
|
|
#include "html/html_internal.h"
|
2019-11-12 21:34:39 +03:00
|
|
|
#include "html/interaction.h"
|
2005-03-26 04:12:27 +03:00
|
|
|
|
2004-08-02 00:28:02 +04:00
|
|
|
#define box_is_float(box) (box->type == BOX_FLOAT_LEFT || \
|
|
|
|
box->type == BOX_FLOAT_RIGHT)
|
|
|
|
|
2010-04-28 01:38:41 +04:00
|
|
|
/**
|
|
|
|
* Destructor for box nodes which own styles
|
|
|
|
*
|
2011-10-03 19:56:47 +04:00
|
|
|
* \param b The box being destroyed.
|
|
|
|
* \return 0 to allow talloc to continue destroying the tree.
|
2010-04-28 01:38:41 +04:00
|
|
|
*/
|
2011-10-03 19:56:47 +04:00
|
|
|
static int box_talloc_destructor(struct box *b)
|
2010-04-28 01:38:41 +04:00
|
|
|
{
|
2013-10-25 18:47:49 +04:00
|
|
|
struct html_scrollbar_data *data;
|
|
|
|
|
2011-03-02 21:27:41 +03:00
|
|
|
if ((b->flags & STYLE_OWNED) && b->style != NULL) {
|
2010-04-28 01:38:41 +04:00
|
|
|
css_computed_style_destroy(b->style);
|
2011-01-20 00:15:23 +03:00
|
|
|
b->style = NULL;
|
|
|
|
}
|
2018-05-10 13:34:26 +03:00
|
|
|
|
2011-01-20 00:15:23 +03:00
|
|
|
if (b->styles != NULL) {
|
|
|
|
css_select_results_destroy(b->styles);
|
|
|
|
b->styles = NULL;
|
2010-04-28 01:38:41 +04:00
|
|
|
}
|
2011-10-04 00:28:29 +04:00
|
|
|
|
|
|
|
if (b->href != NULL)
|
|
|
|
nsurl_unref(b->href);
|
2011-10-29 15:37:05 +04:00
|
|
|
|
2012-11-30 16:29:54 +04:00
|
|
|
if (b->id != NULL) {
|
2011-10-29 15:37:05 +04:00
|
|
|
lwc_string_unref(b->id);
|
2012-11-30 16:29:54 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (b->node != NULL) {
|
|
|
|
dom_node_unref(b->node);
|
|
|
|
}
|
|
|
|
|
2013-10-25 18:47:49 +04:00
|
|
|
if (b->scroll_x != NULL) {
|
|
|
|
data = scrollbar_get_data(b->scroll_x);
|
|
|
|
scrollbar_destroy(b->scroll_x);
|
|
|
|
free(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (b->scroll_y != NULL) {
|
|
|
|
data = scrollbar_get_data(b->scroll_y);
|
|
|
|
scrollbar_destroy(b->scroll_y);
|
|
|
|
free(data);
|
|
|
|
}
|
|
|
|
|
2010-04-28 01:38:41 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-06-27 03:27:30 +04:00
|
|
|
/**
|
2003-10-09 19:22:48 +04:00
|
|
|
* Create a box tree node.
|
2004-12-10 01:22:13 +03:00
|
|
|
*
|
2011-01-05 22:36:05 +03:00
|
|
|
* \param styles selection results for the box, or NULL
|
|
|
|
* \param style computed style for the box (not copied), or 0
|
|
|
|
* \param style_owned whether style is owned by this box
|
2011-10-04 00:28:29 +04:00
|
|
|
* \param href href for the box (copied), or 0
|
2011-01-05 22:36:05 +03:00
|
|
|
* \param target target for the box (not copied), or 0
|
|
|
|
* \param title title for the box (not copied), or 0
|
|
|
|
* \param id id for the box (not copied), or 0
|
|
|
|
* \param context context for allocations
|
2004-12-10 01:22:13 +03:00
|
|
|
* \return allocated and initialised box, or 0 on memory exhaustion
|
2011-01-05 22:36:05 +03:00
|
|
|
*
|
|
|
|
* styles is always owned by the box, if it is set.
|
|
|
|
* style is only owned by the box in the case of implied boxes.
|
2002-06-27 03:27:30 +04:00
|
|
|
*/
|
|
|
|
|
2011-01-05 22:36:05 +03:00
|
|
|
struct box * box_create(css_select_results *styles, css_computed_style *style,
|
2018-05-10 13:34:26 +03:00
|
|
|
bool style_owned, nsurl *href, const char *target,
|
2011-10-29 15:37:05 +04:00
|
|
|
const char *title, lwc_string *id, void *context)
|
2002-06-27 03:27:30 +04:00
|
|
|
{
|
2004-02-02 03:22:59 +03:00
|
|
|
unsigned int i;
|
2004-08-14 16:57:02 +04:00
|
|
|
struct box *box;
|
2004-12-10 01:22:13 +03:00
|
|
|
|
2005-04-09 13:47:37 +04:00
|
|
|
box = talloc(context, struct box);
|
2006-02-16 02:09:55 +03:00
|
|
|
if (!box) {
|
2004-12-10 01:22:13 +03:00
|
|
|
return 0;
|
2006-02-16 02:09:55 +03:00
|
|
|
}
|
2011-10-03 19:56:47 +04:00
|
|
|
|
|
|
|
talloc_set_destructor(box, box_talloc_destructor);
|
|
|
|
|
2003-07-05 20:16:15 +04:00
|
|
|
box->type = BOX_INLINE;
|
2011-03-02 20:50:51 +03:00
|
|
|
box->flags = 0;
|
2011-03-02 22:16:03 +03:00
|
|
|
box->flags = style_owned ? (box->flags | STYLE_OWNED) : box->flags;
|
2011-01-05 22:36:05 +03:00
|
|
|
box->styles = styles;
|
2002-06-27 03:27:30 +04:00
|
|
|
box->style = style;
|
2004-08-14 16:57:02 +04:00
|
|
|
box->x = box->y = 0;
|
2002-09-19 23:54:43 +04:00
|
|
|
box->width = UNKNOWN_WIDTH;
|
2004-08-14 16:57:02 +04:00
|
|
|
box->height = 0;
|
|
|
|
box->descendant_x0 = box->descendant_y0 = 0;
|
|
|
|
box->descendant_x1 = box->descendant_y1 = 0;
|
|
|
|
for (i = 0; i != 4; i++)
|
2009-07-24 03:05:34 +04:00
|
|
|
box->margin[i] = box->padding[i] = box->border[i].width = 0;
|
2009-08-14 14:37:33 +04:00
|
|
|
box->scroll_x = box->scroll_y = NULL;
|
2004-08-14 16:57:02 +04:00
|
|
|
box->min_width = 0;
|
2002-09-18 23:36:28 +04:00
|
|
|
box->max_width = UNKNOWN_MAX_WIDTH;
|
2009-07-24 03:05:34 +04:00
|
|
|
box->byte_offset = 0;
|
2004-08-14 16:57:02 +04:00
|
|
|
box->text = NULL;
|
|
|
|
box->length = 0;
|
2003-07-05 01:17:53 +04:00
|
|
|
box->space = 0;
|
2011-10-04 00:28:29 +04:00
|
|
|
box->href = (href == NULL) ? NULL : nsurl_ref(href);
|
2005-08-23 02:49:52 +04:00
|
|
|
box->target = target;
|
2005-04-09 13:47:37 +04:00
|
|
|
box->title = title;
|
2004-08-14 16:57:02 +04:00
|
|
|
box->columns = 1;
|
|
|
|
box->rows = 1;
|
2003-07-07 01:10:12 +04:00
|
|
|
box->start_column = 0;
|
2004-08-14 16:57:02 +04:00
|
|
|
box->next = NULL;
|
|
|
|
box->prev = NULL;
|
|
|
|
box->children = NULL;
|
|
|
|
box->last = NULL;
|
|
|
|
box->parent = NULL;
|
2005-06-06 00:54:37 +04:00
|
|
|
box->inline_end = NULL;
|
2004-08-14 16:57:02 +04:00
|
|
|
box->float_children = NULL;
|
2008-10-13 01:22:28 +04:00
|
|
|
box->float_container = NULL;
|
2004-08-14 16:57:02 +04:00
|
|
|
box->next_float = NULL;
|
2016-01-20 22:24:12 +03:00
|
|
|
box->cached_place_below_level = 0;
|
2006-11-05 15:58:24 +03:00
|
|
|
box->list_marker = NULL;
|
2004-08-14 16:57:02 +04:00
|
|
|
box->col = NULL;
|
|
|
|
box->gadget = NULL;
|
|
|
|
box->usemap = NULL;
|
2005-04-09 13:47:37 +04:00
|
|
|
box->id = id;
|
2004-08-14 16:57:02 +04:00
|
|
|
box->background = NULL;
|
|
|
|
box->object = NULL;
|
|
|
|
box->object_params = NULL;
|
2011-06-15 00:00:18 +04:00
|
|
|
box->iframe = NULL;
|
2012-11-30 16:29:54 +04:00
|
|
|
box->node = NULL;
|
2004-08-14 16:57:02 +04:00
|
|
|
|
2002-06-27 03:27:30 +04:00
|
|
|
return box;
|
|
|
|
}
|
2002-05-04 23:57:18 +04:00
|
|
|
|
2003-10-09 19:22:48 +04:00
|
|
|
/**
|
2005-03-26 04:12:27 +03:00
|
|
|
* Add a child to a box tree node.
|
2005-01-01 17:51:35 +03:00
|
|
|
*
|
2005-03-26 04:12:27 +03:00
|
|
|
* \param parent box giving birth
|
|
|
|
* \param child box to link as last child of parent
|
2002-08-18 20:46:45 +04:00
|
|
|
*/
|
|
|
|
|
2005-03-26 04:12:27 +03:00
|
|
|
void box_add_child(struct box *parent, struct box *child)
|
2002-08-18 20:46:45 +04:00
|
|
|
{
|
2005-06-06 00:54:37 +04:00
|
|
|
assert(parent);
|
|
|
|
assert(child);
|
|
|
|
|
2005-03-26 04:12:27 +03:00
|
|
|
if (parent->children != 0) { /* has children already */
|
|
|
|
parent->last->next = child;
|
|
|
|
child->prev = parent->last;
|
|
|
|
} else { /* this is the first child */
|
|
|
|
parent->children = child;
|
|
|
|
child->prev = 0;
|
2003-01-02 16:26:43 +03:00
|
|
|
}
|
|
|
|
|
2005-03-26 04:12:27 +03:00
|
|
|
parent->last = child;
|
|
|
|
child->parent = parent;
|
2002-08-18 20:46:45 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-03-26 04:12:27 +03:00
|
|
|
/**
|
|
|
|
* Insert a new box as a sibling to a box in a tree.
|
|
|
|
*
|
|
|
|
* \param box box already in tree
|
|
|
|
* \param new_box box to link into tree as next sibling
|
|
|
|
*/
|
2005-01-01 17:51:35 +03:00
|
|
|
|
2005-03-26 04:12:27 +03:00
|
|
|
void box_insert_sibling(struct box *box, struct box *new_box)
|
|
|
|
{
|
|
|
|
new_box->parent = box->parent;
|
|
|
|
new_box->prev = box;
|
|
|
|
new_box->next = box->next;
|
|
|
|
box->next = new_box;
|
|
|
|
if (new_box->next)
|
|
|
|
new_box->next->prev = new_box;
|
|
|
|
else if (new_box->parent)
|
|
|
|
new_box->parent->last = new_box;
|
2002-08-18 20:46:45 +04:00
|
|
|
}
|
2002-09-08 22:11:56 +04:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2005-04-20 16:24:41 +04:00
|
|
|
* Unlink a box from the box tree and then free it recursively.
|
|
|
|
*
|
|
|
|
* \param box box to unlink and free recursively.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void box_unlink_and_free(struct box *box)
|
|
|
|
{
|
|
|
|
struct box *parent = box->parent;
|
|
|
|
struct box *next = box->next;
|
|
|
|
struct box *prev = box->prev;
|
|
|
|
|
|
|
|
if (parent) {
|
|
|
|
if (parent->children == box)
|
|
|
|
parent->children = next;
|
|
|
|
if (parent->last == box)
|
|
|
|
parent->last = next ? next : prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (prev)
|
|
|
|
prev->next = next;
|
|
|
|
if (next)
|
|
|
|
next->prev = prev;
|
|
|
|
|
|
|
|
box_free(box);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Free a box tree recursively.
|
2005-03-26 04:12:27 +03:00
|
|
|
*
|
|
|
|
* \param box box to free recursively
|
|
|
|
*
|
2005-04-09 13:47:37 +04:00
|
|
|
* The box and all its children is freed.
|
2002-09-08 22:11:56 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
void box_free(struct box *box)
|
|
|
|
{
|
2003-09-20 01:23:19 +04:00
|
|
|
struct box *child, *next;
|
2002-09-08 22:11:56 +04:00
|
|
|
|
2003-09-20 01:23:19 +04:00
|
|
|
/* free children first */
|
|
|
|
for (child = box->children; child; child = next) {
|
|
|
|
next = child->next;
|
|
|
|
box_free(child);
|
|
|
|
}
|
2006-06-27 00:16:24 +04:00
|
|
|
|
2002-09-08 22:11:56 +04:00
|
|
|
/* last this box */
|
2003-01-02 16:26:43 +03:00
|
|
|
box_free_box(box);
|
|
|
|
}
|
|
|
|
|
2004-05-21 18:26:59 +04:00
|
|
|
|
|
|
|
/**
|
2005-03-26 04:12:27 +03:00
|
|
|
* Free the data in a single box structure.
|
|
|
|
*
|
|
|
|
* \param box box to free
|
2004-05-21 18:26:59 +04:00
|
|
|
*/
|
|
|
|
|
2003-01-02 16:26:43 +03:00
|
|
|
void box_free_box(struct box *box)
|
|
|
|
{
|
2011-03-02 22:30:08 +03:00
|
|
|
if (!(box->flags & CLONE)) {
|
2004-05-21 18:26:59 +04:00
|
|
|
if (box->gadget)
|
|
|
|
form_free_control(box->gadget);
|
2009-08-14 14:37:33 +04:00
|
|
|
if (box->scroll_x != NULL)
|
2011-05-10 02:49:17 +04:00
|
|
|
scrollbar_destroy(box->scroll_x);
|
2009-08-14 14:37:33 +04:00
|
|
|
if (box->scroll_y != NULL)
|
2011-05-10 02:49:17 +04:00
|
|
|
scrollbar_destroy(box->scroll_y);
|
2011-01-05 22:36:05 +03:00
|
|
|
if (box->styles != NULL)
|
|
|
|
css_select_results_destroy(box->styles);
|
2002-12-30 01:27:35 +03:00
|
|
|
}
|
2002-12-30 05:06:03 +03:00
|
|
|
|
2005-04-09 13:47:37 +04:00
|
|
|
talloc_free(box);
|
2002-09-08 22:11:56 +04:00
|
|
|
}
|
2002-12-30 01:27:35 +03:00
|
|
|
|
2005-03-26 04:12:27 +03:00
|
|
|
|
2004-07-18 03:32:09 +04:00
|
|
|
/**
|
|
|
|
* Find the absolute coordinates of a box.
|
|
|
|
*
|
|
|
|
* \param box the box to calculate coordinates of
|
|
|
|
* \param x updated to x coordinate
|
|
|
|
* \param y updated to y coordinate
|
|
|
|
*/
|
|
|
|
|
|
|
|
void box_coords(struct box *box, int *x, int *y)
|
|
|
|
{
|
|
|
|
*x = box->x;
|
|
|
|
*y = box->y;
|
|
|
|
while (box->parent) {
|
2004-08-02 00:28:02 +04:00
|
|
|
if (box_is_float(box)) {
|
2019-08-05 23:14:27 +03:00
|
|
|
assert(box->float_container);
|
|
|
|
box = box->float_container;
|
|
|
|
} else {
|
2004-07-18 03:32:09 +04:00
|
|
|
box = box->parent;
|
2019-08-05 23:14:27 +03:00
|
|
|
}
|
2011-05-10 02:49:17 +04:00
|
|
|
*x += box->x - scrollbar_get_offset(box->scroll_x);
|
|
|
|
*y += box->y - scrollbar_get_offset(box->scroll_y);
|
2004-07-18 03:32:09 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-02-16 02:09:55 +03:00
|
|
|
/**
|
|
|
|
* Find the bounds of a box.
|
|
|
|
*
|
|
|
|
* \param box the box to calculate bounds of
|
|
|
|
* \param r receives bounds
|
|
|
|
*/
|
|
|
|
|
|
|
|
void box_bounds(struct box *box, struct rect *r)
|
|
|
|
{
|
|
|
|
int width, height;
|
|
|
|
|
|
|
|
box_coords(box, &r->x0, &r->y0);
|
|
|
|
|
|
|
|
width = box->padding[LEFT] + box->width + box->padding[RIGHT];
|
|
|
|
height = box->padding[TOP] + box->height + box->padding[BOTTOM];
|
|
|
|
|
|
|
|
r->x1 = r->x0 + width;
|
|
|
|
r->y1 = r->y0 + height;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-08-31 19:26:50 +04:00
|
|
|
/**
|
|
|
|
* Determine if a point lies within a box.
|
|
|
|
*
|
2018-01-04 02:58:18 +03:00
|
|
|
* \param[in] len_ctx CSS length conversion context to use.
|
|
|
|
* \param[in] box Box to consider
|
|
|
|
* \param[in] x Coordinate relative to box
|
|
|
|
* \param[in] y Coordinate relative to box
|
|
|
|
* \param[out] physically If function returning true, physically is set true
|
|
|
|
* iff point is within the box's physical dimensions and
|
|
|
|
* false if the point is not within the box's physical
|
|
|
|
* dimensions but is in the area defined by the box's
|
|
|
|
* descendants. If function returns false, physically
|
|
|
|
* is undefined.
|
2014-08-31 19:26:50 +04:00
|
|
|
* \return true if the point is within the box or a descendant box
|
|
|
|
*
|
|
|
|
* This is a helper function for box_at_point().
|
|
|
|
*/
|
|
|
|
|
2018-01-04 02:58:18 +03:00
|
|
|
static bool box_contains_point(
|
|
|
|
const nscss_len_ctx *len_ctx,
|
|
|
|
const struct box *box,
|
|
|
|
int x,
|
|
|
|
int y,
|
|
|
|
bool *physically)
|
2014-08-31 19:26:50 +04:00
|
|
|
{
|
|
|
|
css_computed_clip_rect css_rect;
|
|
|
|
|
|
|
|
if (box->style != NULL &&
|
|
|
|
css_computed_position(box->style) ==
|
|
|
|
CSS_POSITION_ABSOLUTE &&
|
|
|
|
css_computed_clip(box->style, &css_rect) ==
|
|
|
|
CSS_CLIP_RECT) {
|
|
|
|
/* We have an absolutly positioned box with a clip rect */
|
|
|
|
struct rect r = {
|
|
|
|
.x0 = box->border[LEFT].width,
|
|
|
|
.y0 = box->border[TOP].width,
|
|
|
|
.x1 = box->padding[LEFT] + box->width +
|
|
|
|
box->border[RIGHT].width +
|
|
|
|
box->padding[RIGHT],
|
|
|
|
.y1 = box->padding[TOP] + box->height +
|
|
|
|
box->border[BOTTOM].width +
|
|
|
|
box->padding[BOTTOM]
|
|
|
|
};
|
|
|
|
if (x >= r.x0 && x < r.x1 && y >= r.y0 && y < r.y1)
|
|
|
|
*physically = true;
|
|
|
|
else
|
|
|
|
*physically = false;
|
|
|
|
|
|
|
|
/* Adjust rect to css clip region */
|
|
|
|
if (css_rect.left_auto == false) {
|
2018-01-04 02:58:18 +03:00
|
|
|
r.x0 += FIXTOINT(nscss_len2px(len_ctx,
|
2014-08-31 19:26:50 +04:00
|
|
|
css_rect.left, css_rect.lunit,
|
|
|
|
box->style));
|
|
|
|
}
|
|
|
|
if (css_rect.top_auto == false) {
|
2018-01-04 02:58:18 +03:00
|
|
|
r.y0 += FIXTOINT(nscss_len2px(len_ctx,
|
2014-08-31 19:26:50 +04:00
|
|
|
css_rect.top, css_rect.tunit,
|
|
|
|
box->style));
|
|
|
|
}
|
|
|
|
if (css_rect.right_auto == false) {
|
|
|
|
r.x1 = box->border[LEFT].width +
|
2018-01-04 02:58:18 +03:00
|
|
|
FIXTOINT(nscss_len2px(len_ctx,
|
2014-08-31 19:26:50 +04:00
|
|
|
css_rect.right,
|
|
|
|
css_rect.runit,
|
|
|
|
box->style));
|
|
|
|
}
|
|
|
|
if (css_rect.bottom_auto == false) {
|
|
|
|
r.y1 = box->border[TOP].width +
|
2018-01-04 02:58:18 +03:00
|
|
|
FIXTOINT(nscss_len2px(len_ctx,
|
2014-08-31 19:26:50 +04:00
|
|
|
css_rect.bottom,
|
|
|
|
css_rect.bunit,
|
|
|
|
box->style));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Test if point is in clipped box */
|
|
|
|
if (x >= r.x0 && x < r.x1 && y >= r.y0 && y < r.y1) {
|
|
|
|
/* inside clip area */
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Not inside clip area */
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (x >= -box->border[LEFT].width &&
|
|
|
|
x < box->padding[LEFT] + box->width +
|
|
|
|
box->padding[RIGHT] + box->border[RIGHT].width &&
|
|
|
|
y >= -box->border[TOP].width &&
|
|
|
|
y < box->padding[TOP] + box->height +
|
|
|
|
box->padding[BOTTOM] + box->border[BOTTOM].width) {
|
|
|
|
*physically = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (box->list_marker && box->list_marker->x - box->x <= x +
|
|
|
|
box->list_marker->border[LEFT].width &&
|
|
|
|
x < box->list_marker->x - box->x +
|
|
|
|
box->list_marker->padding[LEFT] +
|
|
|
|
box->list_marker->width +
|
|
|
|
box->list_marker->border[RIGHT].width +
|
|
|
|
box->list_marker->padding[RIGHT] &&
|
|
|
|
box->list_marker->y - box->y <= y +
|
|
|
|
box->list_marker->border[TOP].width &&
|
|
|
|
y < box->list_marker->y - box->y +
|
|
|
|
box->list_marker->padding[TOP] +
|
|
|
|
box->list_marker->height +
|
|
|
|
box->list_marker->border[BOTTOM].width +
|
|
|
|
box->list_marker->padding[BOTTOM]) {
|
|
|
|
*physically = true;
|
|
|
|
return true;
|
|
|
|
}
|
2018-05-10 13:34:26 +03:00
|
|
|
if ((box->style && css_computed_overflow_x(box->style) ==
|
2014-08-31 19:26:50 +04:00
|
|
|
CSS_OVERFLOW_VISIBLE) || !box->style) {
|
|
|
|
if (box->descendant_x0 <= x &&
|
|
|
|
x < box->descendant_x1) {
|
|
|
|
*physically = false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
2018-05-10 13:34:26 +03:00
|
|
|
if ((box->style && css_computed_overflow_y(box->style) ==
|
2014-08-31 19:26:50 +04:00
|
|
|
CSS_OVERFLOW_VISIBLE) || !box->style) {
|
|
|
|
if (box->descendant_y0 <= y &&
|
|
|
|
y < box->descendant_y1) {
|
|
|
|
*physically = false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-08-31 19:24:35 +04:00
|
|
|
/** Direction to move in a box-tree walk */
|
|
|
|
enum box_walk_dir {
|
|
|
|
BOX_WALK_CHILDREN,
|
|
|
|
BOX_WALK_PARENT,
|
|
|
|
BOX_WALK_NEXT_SIBLING,
|
|
|
|
BOX_WALK_FLOAT_CHILDREN,
|
|
|
|
BOX_WALK_NEXT_FLOAT_SIBLING,
|
|
|
|
BOX_WALK_FLOAT_CONTAINER
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Move from box to next box in given direction, adjusting for box coord change
|
|
|
|
*
|
|
|
|
* \param b box to move from from
|
|
|
|
* \param dir direction to move in
|
|
|
|
* \param x box's global x-coord, updated to position of next box
|
|
|
|
* \param y box's global y-coord, updated to position of next box
|
|
|
|
*
|
|
|
|
* If no box can be found in given direction, NULL is returned.
|
|
|
|
*/
|
|
|
|
static inline struct box *box_move_xy(struct box *b, enum box_walk_dir dir,
|
|
|
|
int *x, int *y)
|
|
|
|
{
|
2015-05-03 19:23:44 +03:00
|
|
|
struct box *rb = NULL;
|
|
|
|
|
2014-08-31 19:24:35 +04:00
|
|
|
switch (dir) {
|
|
|
|
case BOX_WALK_CHILDREN:
|
|
|
|
b = b->children;
|
|
|
|
if (b == NULL)
|
2015-05-03 19:23:44 +03:00
|
|
|
break;
|
2014-08-31 19:24:35 +04:00
|
|
|
*x += b->x;
|
|
|
|
*y += b->y;
|
|
|
|
if (!box_is_float(b)) {
|
2015-05-03 19:23:44 +03:00
|
|
|
rb = b;
|
|
|
|
break;
|
2014-08-31 19:24:35 +04:00
|
|
|
}
|
2018-09-07 14:53:51 +03:00
|
|
|
/* fall through */
|
2014-08-31 19:24:35 +04:00
|
|
|
|
|
|
|
case BOX_WALK_NEXT_SIBLING:
|
|
|
|
do {
|
|
|
|
*x -= b->x;
|
|
|
|
*y -= b->y;
|
|
|
|
b = b->next;
|
|
|
|
if (b == NULL)
|
|
|
|
break;
|
|
|
|
*x += b->x;
|
|
|
|
*y += b->y;
|
|
|
|
} while (box_is_float(b));
|
2015-05-03 19:23:44 +03:00
|
|
|
rb = b;
|
|
|
|
break;
|
2014-08-31 19:24:35 +04:00
|
|
|
|
|
|
|
case BOX_WALK_PARENT:
|
|
|
|
*x -= b->x;
|
|
|
|
*y -= b->y;
|
2015-05-03 19:23:44 +03:00
|
|
|
rb = b->parent;
|
|
|
|
break;
|
2014-08-31 19:24:35 +04:00
|
|
|
|
|
|
|
case BOX_WALK_FLOAT_CHILDREN:
|
|
|
|
b = b->float_children;
|
|
|
|
if (b == NULL)
|
2015-05-03 19:23:44 +03:00
|
|
|
break;
|
2014-08-31 19:24:35 +04:00
|
|
|
*x += b->x;
|
|
|
|
*y += b->y;
|
2015-05-03 19:23:44 +03:00
|
|
|
rb = b;
|
|
|
|
break;
|
2014-08-31 19:24:35 +04:00
|
|
|
|
|
|
|
case BOX_WALK_NEXT_FLOAT_SIBLING:
|
|
|
|
*x -= b->x;
|
|
|
|
*y -= b->y;
|
|
|
|
b = b->next_float;
|
|
|
|
if (b == NULL)
|
2015-05-03 19:23:44 +03:00
|
|
|
break;
|
2014-08-31 19:24:35 +04:00
|
|
|
*x += b->x;
|
|
|
|
*y += b->y;
|
2015-05-03 19:23:44 +03:00
|
|
|
rb = b;
|
|
|
|
break;
|
2014-08-31 19:24:35 +04:00
|
|
|
|
|
|
|
case BOX_WALK_FLOAT_CONTAINER:
|
|
|
|
*x -= b->x;
|
|
|
|
*y -= b->y;
|
2015-05-03 19:23:44 +03:00
|
|
|
rb = b->float_container;
|
|
|
|
break;
|
2014-08-31 19:24:35 +04:00
|
|
|
|
|
|
|
default:
|
|
|
|
assert(0 && "Bad box walk type.");
|
|
|
|
}
|
2015-05-03 19:23:44 +03:00
|
|
|
|
|
|
|
return rb;
|
2014-08-31 19:24:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Itterator for walking to next box in interaction order
|
|
|
|
*
|
|
|
|
* \param b box to find next box from
|
|
|
|
* \param x box's global x-coord, updated to position of next box
|
|
|
|
* \param y box's global y-coord, updated to position of next box
|
|
|
|
* \param skip_children whether to skip box's children
|
|
|
|
*
|
|
|
|
* This walks to a boxes float children before its children. When walking
|
|
|
|
* children, floating boxes are skipped.
|
|
|
|
*/
|
|
|
|
static inline struct box *box_next_xy(struct box *b, int *x, int *y,
|
|
|
|
bool skip_children)
|
|
|
|
{
|
|
|
|
struct box *n;
|
|
|
|
int tx, ty;
|
|
|
|
|
|
|
|
assert(b != NULL);
|
|
|
|
|
|
|
|
if (skip_children) {
|
|
|
|
/* Caller is not interested in any kind of children */
|
|
|
|
goto skip_children;
|
|
|
|
}
|
|
|
|
|
|
|
|
tx = *x; ty = *y;
|
|
|
|
n = box_move_xy(b, BOX_WALK_FLOAT_CHILDREN, &tx, &ty);
|
|
|
|
if (n) {
|
|
|
|
/* Next node is float child */
|
|
|
|
*x = tx;
|
|
|
|
*y = ty;
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
done_float_children:
|
|
|
|
|
|
|
|
tx = *x; ty = *y;
|
|
|
|
n = box_move_xy(b, BOX_WALK_CHILDREN, &tx, &ty);
|
|
|
|
if (n) {
|
|
|
|
/* Next node is child */
|
|
|
|
*x = tx;
|
|
|
|
*y = ty;
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
skip_children:
|
|
|
|
tx = *x; ty = *y;
|
|
|
|
n = box_move_xy(b, BOX_WALK_NEXT_FLOAT_SIBLING, &tx, &ty);
|
|
|
|
if (n) {
|
|
|
|
/* Go to next float sibling */
|
|
|
|
*x = tx;
|
|
|
|
*y = ty;
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (box_is_float(b)) {
|
|
|
|
/* Done floats, but the float container may have children,
|
|
|
|
* or siblings, or ansestors with siblings. Change to
|
|
|
|
* float container and move past handling its float children.
|
|
|
|
*/
|
|
|
|
b = box_move_xy(b, BOX_WALK_FLOAT_CONTAINER, x, y);
|
|
|
|
goto done_float_children;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Go to next sibling, or nearest ancestor with next sibling. */
|
|
|
|
while (b) {
|
|
|
|
while (!b->next && b->parent) {
|
|
|
|
b = box_move_xy(b, BOX_WALK_PARENT, x, y);
|
|
|
|
if (box_is_float(b)) {
|
|
|
|
/* Go on to next float, if there is one */
|
|
|
|
goto skip_children;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!b->next) {
|
|
|
|
/* No more boxes */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
tx = *x; ty = *y;
|
|
|
|
n = box_move_xy(b, BOX_WALK_NEXT_SIBLING, &tx, &ty);
|
|
|
|
if (n) {
|
|
|
|
/* Go to non-float (ancestor) sibling */
|
|
|
|
*x = tx;
|
|
|
|
*y = ty;
|
|
|
|
return n;
|
|
|
|
|
|
|
|
} else if (b->parent) {
|
|
|
|
b = box_move_xy(b, BOX_WALK_PARENT, x, y);
|
|
|
|
if (box_is_float(b)) {
|
|
|
|
/* Go on to next float, if there is one */
|
|
|
|
goto skip_children;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* No more boxes */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(b != NULL);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2004-07-18 03:32:09 +04:00
|
|
|
/**
|
|
|
|
* Find the boxes at a point.
|
|
|
|
*
|
2018-01-04 02:58:18 +03:00
|
|
|
* \param len_ctx CSS length conversion context for document.
|
2004-07-18 03:32:09 +04:00
|
|
|
* \param box box to search children of
|
2004-10-18 01:10:19 +04:00
|
|
|
* \param x point to find, in global document coordinates
|
2004-07-18 03:32:09 +04:00
|
|
|
* \param y point to find, in global document coordinates
|
|
|
|
* \param box_x position of box, in global document coordinates, updated
|
|
|
|
* to position of returned box, if any
|
|
|
|
* \param box_y position of box, in global document coordinates, updated
|
|
|
|
* to position of returned box, if any
|
|
|
|
* \return box at given point, or 0 if none found
|
|
|
|
*
|
2006-02-16 02:09:55 +03:00
|
|
|
* To find all the boxes in the hierarchy at a certain point, use code like
|
2004-07-18 03:32:09 +04:00
|
|
|
* this:
|
|
|
|
* \code
|
|
|
|
* struct box *box = top_of_document_to_search;
|
|
|
|
* int box_x = 0, box_y = 0;
|
|
|
|
*
|
2018-01-04 02:58:18 +03:00
|
|
|
* while ((box = box_at_point(len_ctx, box, x, y, &box_x, &box_y))) {
|
2004-07-18 03:32:09 +04:00
|
|
|
* // process box
|
|
|
|
* }
|
|
|
|
* \endcode
|
|
|
|
*/
|
|
|
|
|
2018-01-04 02:58:18 +03:00
|
|
|
struct box *box_at_point(const nscss_len_ctx *len_ctx,
|
|
|
|
struct box *box, const int x, const int y,
|
2012-08-21 18:27:52 +04:00
|
|
|
int *box_x, int *box_y)
|
2004-07-18 03:32:09 +04:00
|
|
|
{
|
2014-08-31 19:24:35 +04:00
|
|
|
bool skip_children;
|
2009-04-27 14:20:44 +04:00
|
|
|
bool physically;
|
2014-08-04 17:59:13 +04:00
|
|
|
|
2004-07-18 03:32:09 +04:00
|
|
|
assert(box);
|
|
|
|
|
2014-08-31 19:24:35 +04:00
|
|
|
skip_children = false;
|
|
|
|
while ((box = box_next_xy(box, box_x, box_y, skip_children))) {
|
2018-01-04 02:58:18 +03:00
|
|
|
if (box_contains_point(len_ctx, box, x - *box_x, y - *box_y,
|
2009-04-27 14:20:44 +04:00
|
|
|
&physically)) {
|
2014-08-31 19:24:35 +04:00
|
|
|
*box_x -= scrollbar_get_offset(box->scroll_x);
|
|
|
|
*box_y -= scrollbar_get_offset(box->scroll_y);
|
2008-04-07 13:00:21 +04:00
|
|
|
|
2014-08-31 19:24:35 +04:00
|
|
|
if (physically)
|
|
|
|
return box;
|
2006-05-25 02:55:37 +04:00
|
|
|
|
2014-08-31 19:24:35 +04:00
|
|
|
skip_children = false;
|
2004-08-02 00:28:02 +04:00
|
|
|
} else {
|
2014-08-31 19:24:35 +04:00
|
|
|
skip_children = true;
|
2004-08-02 00:28:02 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-31 19:24:35 +04:00
|
|
|
return NULL;
|
2004-07-18 03:32:09 +04:00
|
|
|
}
|
2004-07-18 21:38:01 +04:00
|
|
|
|
|
|
|
|
2010-06-04 13:35:08 +04:00
|
|
|
/**
|
|
|
|
* Check whether box is nearer mouse coordinates than current nearest box
|
|
|
|
*
|
|
|
|
* \param box box to test
|
|
|
|
* \param bx position of box, in global document coordinates
|
|
|
|
* \param by position of box, in global document coordinates
|
|
|
|
* \param x mouse point, in global document coordinates
|
|
|
|
* \param y mouse point, in global document coordinates
|
|
|
|
* \param dir direction in which to search (-1 = above-left,
|
|
|
|
* +1 = below-right)
|
|
|
|
* \param nearest nearest text box found, or NULL if none
|
|
|
|
* updated if box is nearer than existing nearest
|
|
|
|
* \param tx position of text_box, in global document coordinates
|
|
|
|
* updated if box is nearer than existing nearest
|
|
|
|
* \param ty position of text_box, in global document coordinates
|
|
|
|
* updated if box is nearer than existing nearest
|
|
|
|
* \param nr_xd distance to nearest text box found
|
|
|
|
* updated if box is nearer than existing nearest
|
2014-11-10 23:15:14 +03:00
|
|
|
* \param nr_yd distance to nearest text box found
|
2010-06-04 13:35:08 +04:00
|
|
|
* updated if box is nearer than existing nearest
|
|
|
|
* \return true if mouse point is inside box
|
|
|
|
*/
|
|
|
|
|
2014-09-06 02:00:18 +04:00
|
|
|
static bool box_nearer_text_box(struct box *box, int bx, int by,
|
2010-06-04 13:35:08 +04:00
|
|
|
int x, int y, int dir, struct box **nearest, int *tx, int *ty,
|
|
|
|
int *nr_xd, int *nr_yd)
|
|
|
|
{
|
|
|
|
int w = box->padding[LEFT] + box->width + box->padding[RIGHT];
|
|
|
|
int h = box->padding[TOP] + box->height + box->padding[BOTTOM];
|
|
|
|
int y1 = by + h;
|
|
|
|
int x1 = bx + w;
|
|
|
|
int yd = INT_MAX;
|
|
|
|
int xd = INT_MAX;
|
|
|
|
|
|
|
|
if (x >= bx && x1 > x && y >= by && y1 > y) {
|
|
|
|
*nearest = box;
|
|
|
|
*tx = bx;
|
|
|
|
*ty = by;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (box->parent->list_marker != box) {
|
|
|
|
if (dir < 0) {
|
|
|
|
/* consider only those children (partly) above-left */
|
|
|
|
if (by <= y && bx < x) {
|
|
|
|
yd = y <= y1 ? 0 : y - y1;
|
|
|
|
xd = x <= x1 ? 0 : x - x1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* consider only those children (partly) below-right */
|
|
|
|
if (y1 > y && x1 > x) {
|
|
|
|
yd = y > by ? 0 : by - y;
|
|
|
|
xd = x > bx ? 0 : bx - x;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* give y displacement precedence over x */
|
|
|
|
if (yd < *nr_yd || (yd == *nr_yd && xd <= *nr_xd)) {
|
|
|
|
*nr_yd = yd;
|
|
|
|
*nr_xd = xd;
|
|
|
|
*nearest = box;
|
|
|
|
*tx = bx;
|
|
|
|
*ty = by;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Pick the text box child of 'box' that is closest to and above-left
|
|
|
|
* (dir -ve) or below-right (dir +ve) of the point 'x,y'
|
|
|
|
*
|
|
|
|
* \param box parent box
|
|
|
|
* \param bx position of box, in global document coordinates
|
|
|
|
* \param by position of box, in global document coordinates
|
|
|
|
* \param fx position of float parent, in global document coordinates
|
|
|
|
* \param fy position of float parent, in global document coordinates
|
|
|
|
* \param x mouse point, in global document coordinates
|
|
|
|
* \param y mouse point, in global document coordinates
|
|
|
|
* \param dir direction in which to search (-1 = above-left,
|
|
|
|
* +1 = below-right)
|
|
|
|
* \param nearest nearest text box found, or NULL if none
|
|
|
|
* updated if a descendant of box is nearer than old nearest
|
|
|
|
* \param tx position of nearest, in global document coordinates
|
|
|
|
* updated if a descendant of box is nearer than old nearest
|
|
|
|
* \param ty position of nearest, in global document coordinates
|
|
|
|
* updated if a descendant of box is nearer than old nearest
|
|
|
|
* \param nr_xd distance to nearest text box found
|
|
|
|
* updated if a descendant of box is nearer than old nearest
|
2014-11-10 23:15:14 +03:00
|
|
|
* \param nr_yd distance to nearest text box found
|
2010-06-04 13:35:08 +04:00
|
|
|
* updated if a descendant of box is nearer than old nearest
|
|
|
|
* \return true if mouse point is inside text_box
|
|
|
|
*/
|
|
|
|
|
2014-09-06 02:00:18 +04:00
|
|
|
static bool box_nearest_text_box(struct box *box, int bx, int by,
|
2010-06-04 13:35:08 +04:00
|
|
|
int fx, int fy, int x, int y, int dir, struct box **nearest,
|
|
|
|
int *tx, int *ty, int *nr_xd, int *nr_yd)
|
|
|
|
{
|
|
|
|
struct box *child = box->children;
|
|
|
|
int c_bx, c_by;
|
|
|
|
int c_fx, c_fy;
|
|
|
|
bool in_box = false;
|
|
|
|
|
|
|
|
if (*nearest == NULL) {
|
|
|
|
*nr_xd = INT_MAX / 2; /* displacement of 'nearest so far' */
|
|
|
|
*nr_yd = INT_MAX / 2;
|
|
|
|
}
|
|
|
|
if (box->type == BOX_INLINE_CONTAINER) {
|
|
|
|
int bw = box->padding[LEFT] + box->width + box->padding[RIGHT];
|
|
|
|
int bh = box->padding[TOP] + box->height + box->padding[BOTTOM];
|
|
|
|
int b_y1 = by + bh;
|
|
|
|
int b_x1 = bx + bw;
|
|
|
|
if (x >= bx && b_x1 > x && y >= by && b_y1 > y) {
|
|
|
|
in_box = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while (child) {
|
|
|
|
if (child->type == BOX_FLOAT_LEFT ||
|
|
|
|
child->type == BOX_FLOAT_RIGHT) {
|
|
|
|
c_bx = fx + child->x -
|
2011-05-10 02:49:17 +04:00
|
|
|
scrollbar_get_offset(child->scroll_x);
|
2010-06-04 13:35:08 +04:00
|
|
|
c_by = fy + child->y -
|
2011-05-10 02:49:17 +04:00
|
|
|
scrollbar_get_offset(child->scroll_y);
|
2010-06-04 13:35:08 +04:00
|
|
|
} else {
|
|
|
|
c_bx = bx + child->x -
|
2011-05-10 02:49:17 +04:00
|
|
|
scrollbar_get_offset(child->scroll_x);
|
2010-06-04 13:35:08 +04:00
|
|
|
c_by = by + child->y -
|
2011-05-10 02:49:17 +04:00
|
|
|
scrollbar_get_offset(child->scroll_y);
|
2010-06-04 13:35:08 +04:00
|
|
|
}
|
|
|
|
if (child->float_children) {
|
|
|
|
c_fx = c_bx;
|
|
|
|
c_fy = c_by;
|
|
|
|
} else {
|
|
|
|
c_fx = fx;
|
|
|
|
c_fy = fy;
|
|
|
|
}
|
|
|
|
if (in_box && child->text && !child->object) {
|
|
|
|
if (box_nearer_text_box(child,
|
|
|
|
c_bx, c_by, x, y, dir, nearest,
|
|
|
|
tx, ty, nr_xd, nr_yd))
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
if (child->list_marker) {
|
|
|
|
if (box_nearer_text_box(
|
|
|
|
child->list_marker,
|
|
|
|
c_bx + child->list_marker->x,
|
|
|
|
c_by + child->list_marker->y,
|
|
|
|
x, y, dir, nearest,
|
|
|
|
tx, ty, nr_xd, nr_yd))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (box_nearest_text_box(child, c_bx, c_by,
|
|
|
|
c_fx, c_fy, x, y, dir, nearest, tx, ty,
|
|
|
|
nr_xd, nr_yd))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
child = child->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Peform pick text on browser window contents to locate the box under
|
|
|
|
* the mouse pointer, or nearest in the given direction if the pointer is
|
|
|
|
* not over a text box.
|
|
|
|
*
|
2011-08-31 21:53:40 +04:00
|
|
|
* \param html an HTML content
|
2010-06-04 13:35:08 +04:00
|
|
|
* \param x coordinate of mouse
|
|
|
|
* \param y coordinate of mouse
|
|
|
|
* \param dir direction to search (-1 = above-left, +1 = below-right)
|
|
|
|
* \param dx receives x ordinate of mouse relative to text box
|
|
|
|
* \param dy receives y ordinate of mouse relative to text box
|
|
|
|
*/
|
|
|
|
|
2011-08-31 21:53:40 +04:00
|
|
|
struct box *box_pick_text_box(struct html_content *html,
|
2010-06-04 13:35:08 +04:00
|
|
|
int x, int y, int dir, int *dx, int *dy)
|
|
|
|
{
|
|
|
|
struct box *text_box = NULL;
|
2011-08-31 21:53:40 +04:00
|
|
|
struct box *box;
|
|
|
|
int nr_xd, nr_yd;
|
|
|
|
int bx, by;
|
|
|
|
int fx, fy;
|
|
|
|
int tx, ty;
|
2010-06-04 13:35:08 +04:00
|
|
|
|
2011-08-31 21:53:40 +04:00
|
|
|
if (html == NULL)
|
|
|
|
return NULL;
|
2010-06-04 13:35:08 +04:00
|
|
|
|
2011-08-31 21:53:40 +04:00
|
|
|
box = html->layout;
|
|
|
|
bx = box->margin[LEFT];
|
|
|
|
by = box->margin[TOP];
|
|
|
|
fx = bx;
|
|
|
|
fy = by;
|
|
|
|
|
|
|
|
if (!box_nearest_text_box(box, bx, by, fx, fy, x, y,
|
|
|
|
dir, &text_box, &tx, &ty, &nr_xd, &nr_yd)) {
|
|
|
|
if (text_box && text_box->text && !text_box->object) {
|
|
|
|
int w = (text_box->padding[LEFT] +
|
|
|
|
text_box->width +
|
|
|
|
text_box->padding[RIGHT]);
|
|
|
|
int h = (text_box->padding[TOP] +
|
|
|
|
text_box->height +
|
|
|
|
text_box->padding[BOTTOM]);
|
|
|
|
int x1, y1;
|
|
|
|
|
|
|
|
y1 = ty + h;
|
|
|
|
x1 = tx + w;
|
|
|
|
|
|
|
|
/* ensure point lies within the text box */
|
|
|
|
if (x < tx) x = tx;
|
|
|
|
if (y < ty) y = ty;
|
|
|
|
if (y > y1) y = y1;
|
|
|
|
if (x > x1) x = x1;
|
|
|
|
}
|
2010-06-04 13:35:08 +04:00
|
|
|
}
|
|
|
|
|
2011-08-31 21:53:40 +04:00
|
|
|
/* return coordinates relative to box */
|
|
|
|
*dx = x - tx;
|
|
|
|
*dy = y - ty;
|
|
|
|
|
2010-06-04 13:35:08 +04:00
|
|
|
return text_box;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-08-07 02:19:13 +04:00
|
|
|
/**
|
2004-08-26 02:11:38 +04:00
|
|
|
* Find a box based upon its id attribute.
|
2004-08-07 02:19:13 +04:00
|
|
|
*
|
2005-03-26 04:12:27 +03:00
|
|
|
* \param box box tree to search
|
|
|
|
* \param id id to look for
|
|
|
|
* \return the box or 0 if not found
|
2004-08-07 02:19:13 +04:00
|
|
|
*/
|
2005-03-26 04:12:27 +03:00
|
|
|
|
2011-10-29 15:37:05 +04:00
|
|
|
struct box *box_find_by_id(struct box *box, lwc_string *id)
|
2004-08-07 02:19:13 +04:00
|
|
|
{
|
|
|
|
struct box *a, *b;
|
2011-10-29 15:37:05 +04:00
|
|
|
bool m;
|
2004-08-07 02:19:13 +04:00
|
|
|
|
2011-10-29 15:37:05 +04:00
|
|
|
if (box->id != NULL &&
|
|
|
|
lwc_string_isequal(id, box->id, &m) == lwc_error_ok &&
|
|
|
|
m == true)
|
2004-08-07 02:19:13 +04:00
|
|
|
return box;
|
|
|
|
|
|
|
|
for (a = box->children; a; a = a->next) {
|
2004-08-26 02:11:38 +04:00
|
|
|
if ((b = box_find_by_id(a, id)) != NULL)
|
2004-08-07 02:19:13 +04:00
|
|
|
return b;
|
|
|
|
}
|
|
|
|
|
2004-08-14 18:30:12 +04:00
|
|
|
return NULL;
|
2004-08-07 02:19:13 +04:00
|
|
|
}
|
2005-03-26 04:12:27 +03:00
|
|
|
|
|
|
|
|
2007-01-01 02:47:17 +03:00
|
|
|
/**
|
|
|
|
* Determine if a box is visible when the tree is rendered.
|
|
|
|
*
|
|
|
|
* \param box box to check
|
|
|
|
* \return true iff the box is rendered
|
|
|
|
*/
|
|
|
|
|
2007-01-14 16:02:09 +03:00
|
|
|
bool box_visible(struct box *box)
|
2007-01-01 02:47:17 +03:00
|
|
|
{
|
|
|
|
/* visibility: hidden */
|
2018-05-10 13:34:26 +03:00
|
|
|
if (box->style && css_computed_visibility(box->style) ==
|
2009-07-24 03:05:34 +04:00
|
|
|
CSS_VISIBILITY_HIDDEN)
|
2007-01-01 02:47:17 +03:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-03-26 04:12:27 +03:00
|
|
|
/**
|
2007-08-20 06:39:49 +04:00
|
|
|
* Print a box tree to a file.
|
2005-03-26 04:12:27 +03:00
|
|
|
*/
|
|
|
|
|
2014-07-13 21:07:12 +04:00
|
|
|
void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style)
|
2005-03-26 04:12:27 +03:00
|
|
|
{
|
|
|
|
unsigned int i;
|
2005-04-14 01:58:28 +04:00
|
|
|
struct box *c, *prev;
|
2005-03-26 04:12:27 +03:00
|
|
|
|
|
|
|
for (i = 0; i != depth; i++)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, " ");
|
2005-03-26 04:12:27 +03:00
|
|
|
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, "%p ", box);
|
|
|
|
fprintf(stream, "x%i y%i w%i h%i ", box->x, box->y,
|
2005-03-26 04:12:27 +03:00
|
|
|
box->width, box->height);
|
|
|
|
if (box->max_width != UNKNOWN_MAX_WIDTH)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, "min%i max%i ", box->min_width, box->max_width);
|
|
|
|
fprintf(stream, "(%i %i %i %i) ",
|
2005-03-26 04:12:27 +03:00
|
|
|
box->descendant_x0, box->descendant_y0,
|
|
|
|
box->descendant_x1, box->descendant_y1);
|
2008-10-13 01:22:28 +04:00
|
|
|
|
First merge of Adam Blokus' GSoC work from his branch 'branches/adamblokus/netsurf'.
Merged revisions 4212-4552,4554-4709,4711-4724 via svnmerge from
svn://svn.netsurf-browser.org/branches/adamblokus/netsurf
........
r4212 | adamblokus | 2008-05-26 19:42:31 +0200 (Mon, 26 May 2008) | 4 lines
Pdf plotting skeleton pinned on Print Preview in GTK.
Just creates a file and draws lines.
........
r4213 | adamblokus | 2008-05-27 00:11:03 +0200 (Tue, 27 May 2008) | 4 lines
Pdf plotter - added drawing some graphic primitives.
Still with limited functionality, but a snapshot of the
currently viewed page can be made and resembles the original.
........
r4214 | adamblokus | 2008-05-27 11:43:31 +0200 (Tue, 27 May 2008) | 2 lines
Corrected encoding name
........
r4215 | adamblokus | 2008-05-27 12:47:26 +0200 (Tue, 27 May 2008) | 3 lines
Colours and polygons added.
........
r4217 | adamblokus | 2008-05-27 21:39:35 +0200 (Tue, 27 May 2008) | 6 lines
Added rectangles, filled boxes and clipping.
Taken into consideration joty's comments.
Added a todo list for this part.
Added some debug stuff and checking boundaries.
........
r4218 | adamblokus | 2008-05-28 12:37:30 +0200 (Wed, 28 May 2008) | 2 lines
Added path ploting (not sure if valid argument order for bezier) and dashed/dotted line styles
........
r4221 | adamblokus | 2008-05-28 22:11:05 +0200 (Wed, 28 May 2008) | 3 lines
Some more options in graphic primitives and normalizing some parameters.
........
r4235 | adamblokus | 2008-05-31 22:54:56 +0200 (Sat, 31 May 2008) | 4 lines
Plotting changed as jmb suggested (is the least invasive one from the possible)
Added dummy bitmap plotting - way of plotting an image is determined by its type.
........
r4251 | adamblokus | 2008-06-03 17:12:15 +0200 (Tue, 03 Jun 2008) | 3 lines
Added plotting jpg and png images - quite a lot to improve in this code, but it seems to work ;)
........
r4263 | adamblokus | 2008-06-05 14:20:32 +0200 (Thu, 05 Jun 2008) | 3 lines
Added hadling images other than png and jpeg - with transparency.
........
r4267 | adamblokus | 2008-06-06 15:36:34 +0200 (Fri, 06 Jun 2008) | 5 lines
Added handling NULL-returns from all mallocs.
Added plot_bitmap_tile handling.
Changed code style a little.
........
r4327 | adamblokus | 2008-06-12 17:46:34 +0200 (Thu, 12 Jun 2008) | 5 lines
Added a first prototype of the paged-output organization.
Still not sure about naming, file locations etc.
Works with the same pdf plotting as before.
........
r4328 | adamblokus | 2008-06-13 13:52:15 +0200 (Fri, 13 Jun 2008) | 4 lines
Added primitive width adjustment and outputing the whole
website in multiple pages.
........
r4336 | joty | 2008-06-15 15:06:57 +0200 (Sun, 15 Jun 2008) | 1 line
Fix RISC OS build failure (change r4235 wasn't complete).
........
r4337 | joty | 2008-06-15 18:15:32 +0200 (Sun, 15 Jun 2008) | 16 lines
This enables "Export PDF" in RISC OS build:
- Docs/Doxyfile(PREDEFINED): Added WITH_PDF_EXPORT
- Makefile.sources(S_PDF): Add to RISC OS target as well.
- utils/config.h: Define WITH_PDF_EXPORT which controls if we want to have
PDF export functionality or not.
- riscos/save_pdf.c,riscos/save_pdf.h(save_as_pdf): Use PDF print API made
by Adam Blokus to write a PDF file under RISC OS.
- riscos/save.c: Call save_as_pdf added.
- riscos/menus.c: Add 'Export->PDF' menu entry.
- riscos/menus.h(menu_action): Added BROWSER_EXPORT_PDF.
- desktop/gui.h(gui_save_type): Added GUI_SAVE_PDF.
- desktop/print.c(print_run): Added return value.
- Makefile(CCACHE): Moved closed to the place where CC is set for the first time.
(LDFLAGS): Centralised adding all non-pkgconfig libraries and added Haru + PNG libs.
........
r4343 | adamblokus | 2008-06-16 01:08:52 +0200 (Mon, 16 Jun 2008) | 3 lines
Added margins and page size adjustment.
........
r4412 | adamblokus | 2008-06-21 20:22:07 +0200 (Sat, 21 Jun 2008) | 4 lines
Added 'fuzzy' margins on page bottom.
Disabled direct png embedding, because it is too unstable in Haru now.
........
r4421 | adamblokus | 2008-06-22 18:52:28 +0200 (Sun, 22 Jun 2008) | 2 lines
Added "Save as.." dialog and Export->PDF menu entry. Print preview still works with default path.
........
r4437 | adamblokus | 2008-06-25 02:44:46 +0200 (Wed, 25 Jun 2008) | 4 lines
Added skeleton of applying loose layout.
Minor code cleaning-up.
........
r4492 | adamblokus | 2008-07-02 09:02:42 +0200 (Wed, 02 Jul 2008) | 5 lines
Implemented the elementar ideas of the loose layout.
Added scaling in the printing routine.
Added some basic demonstrations.
........
r4493 | adamblokus | 2008-07-02 09:05:55 +0200 (Wed, 02 Jul 2008) | 3 lines
Cleaned up the loosing code - commited to much of leftover rubbish code.
........
r4507 | adamblokus | 2008-07-04 14:25:48 +0200 (Fri, 04 Jul 2008) | 4 lines
Added duplicating box tree and current content - window flickering during printing solved.
Minor error checking after new HPDF_Image_AddSMask call.
........
r4515 | adamblokus | 2008-07-06 22:28:16 +0200 (Sun, 06 Jul 2008) | 2 lines
Changes in loosen layout (image resizing).
........
r4517 | adamblokus | 2008-07-06 22:38:23 +0200 (Sun, 06 Jul 2008) | 2 lines
Added pdf font handling and rendering functions with the use of Haru functions.
........
r4555 | adamblokus | 2008-07-10 00:59:05 +0200 (Thu, 10 Jul 2008) | 2 lines
Added a very basic and still buggy GTK print implementation.
........
r4565 | adamblokus | 2008-07-10 14:50:16 +0200 (Thu, 10 Jul 2008) | 2 lines
Added gtk printing one more time - I have forgotten to add the main file.
........
r4566 | adamblokus | 2008-07-10 14:57:02 +0200 (Thu, 10 Jul 2008) | 2 lines
removed error with comment
........
r4569 | adamblokus | 2008-07-10 15:52:55 +0200 (Thu, 10 Jul 2008) | 5 lines
Major style improvements - added a lot of doxygen comments,
followed tlsa's style guide.
Added some more error checking, too.
........
r4575 | adamblokus | 2008-07-10 18:48:26 +0200 (Thu, 10 Jul 2008) | 2 lines
Cleaned up the code.
........
r4687 | adamblokus | 2008-07-17 14:17:19 +0200 (Thu, 17 Jul 2008) | 2 lines
Changed everything according to jmb's review plus some minor bug fixes to gtk_print.
........
r4688 | adamblokus | 2008-07-17 17:16:34 +0200 (Thu, 17 Jul 2008) | 2 lines
Solved the netsurf.glade clash from r4421.
........
r4693 | adamblokus | 2008-07-18 18:11:51 +0200 (Fri, 18 Jul 2008) | 2 lines
Fixed bug with wrong number of pages in gtk printing.
........
r4695 | adamblokus | 2008-07-18 19:59:24 +0200 (Fri, 18 Jul 2008) | 3 lines
- fixed uncommented line from the previous commit
- fixed bug with scale bigger than 1.0 (incorretly clipped page)
........
r4696 | adamblokus | 2008-07-18 23:28:00 +0200 (Fri, 18 Jul 2008) | 2 lines
Fixed bug in gtk_print_font_paint (and nsfont_paint).
........
r4697 | adamblokus | 2008-07-18 23:35:38 +0200 (Fri, 18 Jul 2008) | 2 lines
Bug fix in nsfont_paint.
........
r4711 | adamblokus | 2008-07-19 22:44:15 +0200 (Sat, 19 Jul 2008) | 2 lines
Added gtk_selection files.
........
r4712 | adamblokus | 2008-07-20 11:15:06 +0200 (Sun, 20 Jul 2008) | 2 lines
Addam missing glade files.
........
r4713 | joty | 2008-07-20 17:13:10 +0200 (Sun, 20 Jul 2008) | 1 line
Follow change r4517 for RISC OS and BeOS platforms : Added pdf font handling and rendering functions with the use of Haru functions.
........
r4714 | joty | 2008-07-20 18:19:50 +0200 (Sun, 20 Jul 2008) | 1 line
Declare haru_nsfont iso define an instance for each C source including the font_haru.h header. This fixes breakage of PDF export on RISC OS.
........
r4724 | adamblokus | 2008-07-23 03:30:08 +0200 (Wed, 23 Jul 2008) | 6 lines
Applied changes according to joty's review.
Added checking the dimensions of a plotted image to pdf plotter.
Commented out jpg embedding (it seems to cause some problems
I'll bring it back when I figure out what's wrong) .
Added back some files removed by mistake.
........
svn path=/trunk/netsurf/; revision=4741
2008-07-26 20:01:59 +04:00
|
|
|
fprintf(stream, "m(%i %i %i %i) ",
|
|
|
|
box->margin[TOP], box->margin[LEFT],
|
|
|
|
box->margin[BOTTOM], box->margin[RIGHT]);
|
2005-03-26 04:12:27 +03:00
|
|
|
|
|
|
|
switch (box->type) {
|
2007-08-20 06:39:49 +04:00
|
|
|
case BOX_BLOCK: fprintf(stream, "BLOCK "); break;
|
|
|
|
case BOX_INLINE_CONTAINER: fprintf(stream, "INLINE_CONTAINER "); break;
|
|
|
|
case BOX_INLINE: fprintf(stream, "INLINE "); break;
|
|
|
|
case BOX_INLINE_END: fprintf(stream, "INLINE_END "); break;
|
|
|
|
case BOX_INLINE_BLOCK: fprintf(stream, "INLINE_BLOCK "); break;
|
|
|
|
case BOX_TABLE: fprintf(stream, "TABLE [columns %i] ",
|
2005-03-26 04:12:27 +03:00
|
|
|
box->columns); break;
|
2007-08-20 06:39:49 +04:00
|
|
|
case BOX_TABLE_ROW: fprintf(stream, "TABLE_ROW "); break;
|
|
|
|
case BOX_TABLE_CELL: fprintf(stream, "TABLE_CELL [columns %i, "
|
2005-03-26 04:12:27 +03:00
|
|
|
"start %i, rows %i] ", box->columns,
|
|
|
|
box->start_column, box->rows); break;
|
2007-08-20 06:39:49 +04:00
|
|
|
case BOX_TABLE_ROW_GROUP: fprintf(stream, "TABLE_ROW_GROUP "); break;
|
|
|
|
case BOX_FLOAT_LEFT: fprintf(stream, "FLOAT_LEFT "); break;
|
|
|
|
case BOX_FLOAT_RIGHT: fprintf(stream, "FLOAT_RIGHT "); break;
|
|
|
|
case BOX_BR: fprintf(stream, "BR "); break;
|
|
|
|
case BOX_TEXT: fprintf(stream, "TEXT "); break;
|
|
|
|
default: fprintf(stream, "Unknown box type ");
|
2005-03-26 04:12:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (box->text)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, "%li '%.*s' ", (unsigned long) box->byte_offset,
|
2006-05-25 02:55:37 +04:00
|
|
|
(int) box->length, box->text);
|
2005-03-26 04:12:27 +03:00
|
|
|
if (box->space)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, "space ");
|
2010-03-28 16:56:39 +04:00
|
|
|
if (box->object) {
|
2018-05-10 13:34:26 +03:00
|
|
|
fprintf(stream, "(object '%s') ",
|
2011-12-04 18:55:23 +04:00
|
|
|
nsurl_access(hlcache_handle_get_url(box->object)));
|
2010-03-28 16:56:39 +04:00
|
|
|
}
|
2011-06-15 00:00:18 +04:00
|
|
|
if (box->iframe) {
|
|
|
|
fprintf(stream, "(iframe) ");
|
|
|
|
}
|
2008-01-28 16:48:59 +03:00
|
|
|
if (box->gadget)
|
|
|
|
fprintf(stream, "(gadget) ");
|
2014-07-13 21:07:12 +04:00
|
|
|
if (style && box->style)
|
2009-07-24 03:05:34 +04:00
|
|
|
nscss_dump_computed_style(stream, box->style);
|
2005-08-21 02:52:20 +04:00
|
|
|
if (box->href)
|
2011-10-04 00:28:29 +04:00
|
|
|
fprintf(stream, " -> '%s'", nsurl_access(box->href));
|
2005-08-21 02:52:20 +04:00
|
|
|
if (box->target)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, " |%s|", box->target);
|
2005-08-21 02:52:20 +04:00
|
|
|
if (box->title)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, " [%s]", box->title);
|
2005-08-21 02:52:20 +04:00
|
|
|
if (box->id)
|
2017-04-26 17:20:31 +03:00
|
|
|
fprintf(stream, " ID:%s", lwc_string_data(box->id));
|
2005-06-06 00:54:37 +04:00
|
|
|
if (box->type == BOX_INLINE || box->type == BOX_INLINE_END)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, " inline_end %p", box->inline_end);
|
2005-03-26 04:12:27 +03:00
|
|
|
if (box->float_children)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, " float_children %p", box->float_children);
|
2005-03-26 04:12:27 +03:00
|
|
|
if (box->next_float)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, " next_float %p", box->next_float);
|
2014-08-31 19:22:33 +04:00
|
|
|
if (box->float_container)
|
|
|
|
fprintf(stream, " float_container %p", box->float_container);
|
2005-07-02 21:49:40 +04:00
|
|
|
if (box->col) {
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, " (columns");
|
2005-07-02 21:49:40 +04:00
|
|
|
for (i = 0; i != box->columns; i++)
|
2008-04-20 19:49:25 +04:00
|
|
|
fprintf(stream, " (%s %s %i %i %i)",
|
2005-07-02 21:49:40 +04:00
|
|
|
((const char *[]) {"UNKNOWN", "FIXED",
|
|
|
|
"AUTO", "PERCENT", "RELATIVE"})
|
|
|
|
[box->col[i].type],
|
2008-04-20 19:49:25 +04:00
|
|
|
((const char *[]) {"normal",
|
|
|
|
"positioned"})
|
|
|
|
[box->col[i].positioned],
|
2005-07-02 21:49:40 +04:00
|
|
|
box->col[i].width,
|
|
|
|
box->col[i].min, box->col[i].max);
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, ")");
|
2005-07-02 21:49:40 +04:00
|
|
|
}
|
2017-04-26 17:20:31 +03:00
|
|
|
if (box->node != NULL) {
|
|
|
|
dom_string *name;
|
|
|
|
if (dom_node_get_node_name(box->node, &name) == DOM_NO_ERR) {
|
|
|
|
fprintf(stream, " <%s>", dom_string_data(name));
|
|
|
|
dom_string_unref(name);
|
|
|
|
}
|
|
|
|
}
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, "\n");
|
2005-03-26 04:12:27 +03:00
|
|
|
|
2006-11-05 15:58:24 +03:00
|
|
|
if (box->list_marker) {
|
|
|
|
for (i = 0; i != depth; i++)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, " ");
|
|
|
|
fprintf(stream, "list_marker:\n");
|
2014-07-13 21:07:12 +04:00
|
|
|
box_dump(stream, box->list_marker, depth + 1, style);
|
2006-11-05 15:58:24 +03:00
|
|
|
}
|
|
|
|
|
2005-04-17 20:42:37 +04:00
|
|
|
for (c = box->children; c && c->next; c = c->next)
|
2005-04-14 01:58:28 +04:00
|
|
|
;
|
|
|
|
if (box->last != c)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, "warning: box->last %p (should be %p) "
|
2005-04-14 01:58:28 +04:00
|
|
|
"(box %p)\n", box->last, c, box);
|
|
|
|
for (prev = 0, c = box->children; c; prev = c, c = c->next) {
|
|
|
|
if (c->parent != box)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, "warning: box->parent %p (should be "
|
2005-04-14 01:58:28 +04:00
|
|
|
"%p) (box on next line)\n",
|
|
|
|
c->parent, box);
|
|
|
|
if (c->prev != prev)
|
2007-08-20 06:39:49 +04:00
|
|
|
fprintf(stream, "warning: box->prev %p (should be "
|
2005-04-14 01:58:28 +04:00
|
|
|
"%p) (box on next line)\n",
|
|
|
|
c->prev, prev);
|
2014-07-13 21:07:12 +04:00
|
|
|
box_dump(stream, c, depth + 1, style);
|
2005-04-14 01:58:28 +04:00
|
|
|
}
|
2005-03-26 04:12:27 +03:00
|
|
|
}
|
First merge of Adam Blokus' GSoC work from his branch 'branches/adamblokus/netsurf'.
Merged revisions 4212-4552,4554-4709,4711-4724 via svnmerge from
svn://svn.netsurf-browser.org/branches/adamblokus/netsurf
........
r4212 | adamblokus | 2008-05-26 19:42:31 +0200 (Mon, 26 May 2008) | 4 lines
Pdf plotting skeleton pinned on Print Preview in GTK.
Just creates a file and draws lines.
........
r4213 | adamblokus | 2008-05-27 00:11:03 +0200 (Tue, 27 May 2008) | 4 lines
Pdf plotter - added drawing some graphic primitives.
Still with limited functionality, but a snapshot of the
currently viewed page can be made and resembles the original.
........
r4214 | adamblokus | 2008-05-27 11:43:31 +0200 (Tue, 27 May 2008) | 2 lines
Corrected encoding name
........
r4215 | adamblokus | 2008-05-27 12:47:26 +0200 (Tue, 27 May 2008) | 3 lines
Colours and polygons added.
........
r4217 | adamblokus | 2008-05-27 21:39:35 +0200 (Tue, 27 May 2008) | 6 lines
Added rectangles, filled boxes and clipping.
Taken into consideration joty's comments.
Added a todo list for this part.
Added some debug stuff and checking boundaries.
........
r4218 | adamblokus | 2008-05-28 12:37:30 +0200 (Wed, 28 May 2008) | 2 lines
Added path ploting (not sure if valid argument order for bezier) and dashed/dotted line styles
........
r4221 | adamblokus | 2008-05-28 22:11:05 +0200 (Wed, 28 May 2008) | 3 lines
Some more options in graphic primitives and normalizing some parameters.
........
r4235 | adamblokus | 2008-05-31 22:54:56 +0200 (Sat, 31 May 2008) | 4 lines
Plotting changed as jmb suggested (is the least invasive one from the possible)
Added dummy bitmap plotting - way of plotting an image is determined by its type.
........
r4251 | adamblokus | 2008-06-03 17:12:15 +0200 (Tue, 03 Jun 2008) | 3 lines
Added plotting jpg and png images - quite a lot to improve in this code, but it seems to work ;)
........
r4263 | adamblokus | 2008-06-05 14:20:32 +0200 (Thu, 05 Jun 2008) | 3 lines
Added hadling images other than png and jpeg - with transparency.
........
r4267 | adamblokus | 2008-06-06 15:36:34 +0200 (Fri, 06 Jun 2008) | 5 lines
Added handling NULL-returns from all mallocs.
Added plot_bitmap_tile handling.
Changed code style a little.
........
r4327 | adamblokus | 2008-06-12 17:46:34 +0200 (Thu, 12 Jun 2008) | 5 lines
Added a first prototype of the paged-output organization.
Still not sure about naming, file locations etc.
Works with the same pdf plotting as before.
........
r4328 | adamblokus | 2008-06-13 13:52:15 +0200 (Fri, 13 Jun 2008) | 4 lines
Added primitive width adjustment and outputing the whole
website in multiple pages.
........
r4336 | joty | 2008-06-15 15:06:57 +0200 (Sun, 15 Jun 2008) | 1 line
Fix RISC OS build failure (change r4235 wasn't complete).
........
r4337 | joty | 2008-06-15 18:15:32 +0200 (Sun, 15 Jun 2008) | 16 lines
This enables "Export PDF" in RISC OS build:
- Docs/Doxyfile(PREDEFINED): Added WITH_PDF_EXPORT
- Makefile.sources(S_PDF): Add to RISC OS target as well.
- utils/config.h: Define WITH_PDF_EXPORT which controls if we want to have
PDF export functionality or not.
- riscos/save_pdf.c,riscos/save_pdf.h(save_as_pdf): Use PDF print API made
by Adam Blokus to write a PDF file under RISC OS.
- riscos/save.c: Call save_as_pdf added.
- riscos/menus.c: Add 'Export->PDF' menu entry.
- riscos/menus.h(menu_action): Added BROWSER_EXPORT_PDF.
- desktop/gui.h(gui_save_type): Added GUI_SAVE_PDF.
- desktop/print.c(print_run): Added return value.
- Makefile(CCACHE): Moved closed to the place where CC is set for the first time.
(LDFLAGS): Centralised adding all non-pkgconfig libraries and added Haru + PNG libs.
........
r4343 | adamblokus | 2008-06-16 01:08:52 +0200 (Mon, 16 Jun 2008) | 3 lines
Added margins and page size adjustment.
........
r4412 | adamblokus | 2008-06-21 20:22:07 +0200 (Sat, 21 Jun 2008) | 4 lines
Added 'fuzzy' margins on page bottom.
Disabled direct png embedding, because it is too unstable in Haru now.
........
r4421 | adamblokus | 2008-06-22 18:52:28 +0200 (Sun, 22 Jun 2008) | 2 lines
Added "Save as.." dialog and Export->PDF menu entry. Print preview still works with default path.
........
r4437 | adamblokus | 2008-06-25 02:44:46 +0200 (Wed, 25 Jun 2008) | 4 lines
Added skeleton of applying loose layout.
Minor code cleaning-up.
........
r4492 | adamblokus | 2008-07-02 09:02:42 +0200 (Wed, 02 Jul 2008) | 5 lines
Implemented the elementar ideas of the loose layout.
Added scaling in the printing routine.
Added some basic demonstrations.
........
r4493 | adamblokus | 2008-07-02 09:05:55 +0200 (Wed, 02 Jul 2008) | 3 lines
Cleaned up the loosing code - commited to much of leftover rubbish code.
........
r4507 | adamblokus | 2008-07-04 14:25:48 +0200 (Fri, 04 Jul 2008) | 4 lines
Added duplicating box tree and current content - window flickering during printing solved.
Minor error checking after new HPDF_Image_AddSMask call.
........
r4515 | adamblokus | 2008-07-06 22:28:16 +0200 (Sun, 06 Jul 2008) | 2 lines
Changes in loosen layout (image resizing).
........
r4517 | adamblokus | 2008-07-06 22:38:23 +0200 (Sun, 06 Jul 2008) | 2 lines
Added pdf font handling and rendering functions with the use of Haru functions.
........
r4555 | adamblokus | 2008-07-10 00:59:05 +0200 (Thu, 10 Jul 2008) | 2 lines
Added a very basic and still buggy GTK print implementation.
........
r4565 | adamblokus | 2008-07-10 14:50:16 +0200 (Thu, 10 Jul 2008) | 2 lines
Added gtk printing one more time - I have forgotten to add the main file.
........
r4566 | adamblokus | 2008-07-10 14:57:02 +0200 (Thu, 10 Jul 2008) | 2 lines
removed error with comment
........
r4569 | adamblokus | 2008-07-10 15:52:55 +0200 (Thu, 10 Jul 2008) | 5 lines
Major style improvements - added a lot of doxygen comments,
followed tlsa's style guide.
Added some more error checking, too.
........
r4575 | adamblokus | 2008-07-10 18:48:26 +0200 (Thu, 10 Jul 2008) | 2 lines
Cleaned up the code.
........
r4687 | adamblokus | 2008-07-17 14:17:19 +0200 (Thu, 17 Jul 2008) | 2 lines
Changed everything according to jmb's review plus some minor bug fixes to gtk_print.
........
r4688 | adamblokus | 2008-07-17 17:16:34 +0200 (Thu, 17 Jul 2008) | 2 lines
Solved the netsurf.glade clash from r4421.
........
r4693 | adamblokus | 2008-07-18 18:11:51 +0200 (Fri, 18 Jul 2008) | 2 lines
Fixed bug with wrong number of pages in gtk printing.
........
r4695 | adamblokus | 2008-07-18 19:59:24 +0200 (Fri, 18 Jul 2008) | 3 lines
- fixed uncommented line from the previous commit
- fixed bug with scale bigger than 1.0 (incorretly clipped page)
........
r4696 | adamblokus | 2008-07-18 23:28:00 +0200 (Fri, 18 Jul 2008) | 2 lines
Fixed bug in gtk_print_font_paint (and nsfont_paint).
........
r4697 | adamblokus | 2008-07-18 23:35:38 +0200 (Fri, 18 Jul 2008) | 2 lines
Bug fix in nsfont_paint.
........
r4711 | adamblokus | 2008-07-19 22:44:15 +0200 (Sat, 19 Jul 2008) | 2 lines
Added gtk_selection files.
........
r4712 | adamblokus | 2008-07-20 11:15:06 +0200 (Sun, 20 Jul 2008) | 2 lines
Addam missing glade files.
........
r4713 | joty | 2008-07-20 17:13:10 +0200 (Sun, 20 Jul 2008) | 1 line
Follow change r4517 for RISC OS and BeOS platforms : Added pdf font handling and rendering functions with the use of Haru functions.
........
r4714 | joty | 2008-07-20 18:19:50 +0200 (Sun, 20 Jul 2008) | 1 line
Declare haru_nsfont iso define an instance for each C source including the font_haru.h header. This fixes breakage of PDF export on RISC OS.
........
r4724 | adamblokus | 2008-07-23 03:30:08 +0200 (Wed, 23 Jul 2008) | 6 lines
Applied changes according to joty's review.
Added checking the dimensions of a plotted image to pdf plotter.
Commented out jpg embedding (it seems to cause some problems
I'll bring it back when I figure out what's wrong) .
Added back some files removed by mistake.
........
svn path=/trunk/netsurf/; revision=4741
2008-07-26 20:01:59 +04:00
|
|
|
|
2019-11-06 02:05:42 +03:00
|
|
|
|
|
|
|
/* exported interface documented in html/box.h */
|
|
|
|
nserror
|
|
|
|
box_handle_scrollbars(struct content *c,
|
|
|
|
struct box *box,
|
|
|
|
bool bottom,
|
|
|
|
bool right)
|
2009-08-14 14:37:33 +04:00
|
|
|
{
|
2011-06-28 02:21:15 +04:00
|
|
|
struct html_scrollbar_data *data;
|
2011-05-10 14:41:57 +04:00
|
|
|
int visible_width, visible_height;
|
|
|
|
int full_width, full_height;
|
2019-11-06 02:05:42 +03:00
|
|
|
nserror res;
|
2011-05-10 14:41:57 +04:00
|
|
|
|
2009-08-14 14:37:33 +04:00
|
|
|
if (!bottom && box->scroll_x != NULL) {
|
2011-05-10 02:49:17 +04:00
|
|
|
data = scrollbar_get_data(box->scroll_x);
|
|
|
|
scrollbar_destroy(box->scroll_x);
|
2009-08-14 14:37:33 +04:00
|
|
|
free(data);
|
|
|
|
box->scroll_x = NULL;
|
|
|
|
}
|
2011-05-10 14:41:57 +04:00
|
|
|
|
2009-08-14 14:37:33 +04:00
|
|
|
if (!right && box->scroll_y != NULL) {
|
2011-05-10 02:49:17 +04:00
|
|
|
data = scrollbar_get_data(box->scroll_y);
|
|
|
|
scrollbar_destroy(box->scroll_y);
|
2009-08-14 14:37:33 +04:00
|
|
|
free(data);
|
|
|
|
box->scroll_y = NULL;
|
|
|
|
}
|
2011-05-10 14:41:57 +04:00
|
|
|
|
2019-11-06 02:05:42 +03:00
|
|
|
if (!bottom && !right) {
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
2011-05-10 14:41:57 +04:00
|
|
|
|
|
|
|
visible_width = box->width + box->padding[RIGHT] + box->padding[LEFT];
|
|
|
|
visible_height = box->height + box->padding[TOP] + box->padding[BOTTOM];
|
|
|
|
|
|
|
|
full_width = ((box->descendant_x1 - box->border[RIGHT].width) >
|
|
|
|
visible_width) ?
|
|
|
|
box->descendant_x1 + box->padding[RIGHT] :
|
|
|
|
visible_width;
|
|
|
|
full_height = ((box->descendant_y1 - box->border[BOTTOM].width) >
|
|
|
|
visible_height) ?
|
|
|
|
box->descendant_y1 + box->padding[BOTTOM] :
|
|
|
|
visible_height;
|
|
|
|
|
2009-08-14 14:37:33 +04:00
|
|
|
if (right) {
|
|
|
|
if (box->scroll_y == NULL) {
|
2011-06-28 02:21:15 +04:00
|
|
|
data = malloc(sizeof(struct html_scrollbar_data));
|
2009-08-14 14:37:33 +04:00
|
|
|
if (data == NULL) {
|
2019-11-06 02:05:42 +03:00
|
|
|
return NSERROR_NOMEM;
|
2009-08-14 14:37:33 +04:00
|
|
|
}
|
2011-06-28 02:21:15 +04:00
|
|
|
data->c = c;
|
2009-08-14 14:37:33 +04:00
|
|
|
data->box = box;
|
2019-11-06 02:05:42 +03:00
|
|
|
res = scrollbar_create(false,
|
|
|
|
visible_height,
|
|
|
|
full_height,
|
|
|
|
visible_height,
|
|
|
|
data,
|
|
|
|
html_overflow_scroll_callback,
|
|
|
|
&(box->scroll_y));
|
|
|
|
if (res != NSERROR_OK) {
|
|
|
|
return res;
|
2016-04-26 14:14:56 +03:00
|
|
|
}
|
2011-05-10 14:41:57 +04:00
|
|
|
} else {
|
2019-11-06 02:05:42 +03:00
|
|
|
scrollbar_set_extents(box->scroll_y,
|
|
|
|
visible_height,
|
|
|
|
visible_height,
|
|
|
|
full_height);
|
2011-05-10 14:41:57 +04:00
|
|
|
}
|
2009-08-14 14:37:33 +04:00
|
|
|
}
|
|
|
|
if (bottom) {
|
|
|
|
if (box->scroll_x == NULL) {
|
2011-06-28 02:21:15 +04:00
|
|
|
data = malloc(sizeof(struct html_scrollbar_data));
|
2009-08-14 14:37:33 +04:00
|
|
|
if (data == NULL) {
|
2019-11-06 02:05:42 +03:00
|
|
|
return NSERROR_OK;
|
2009-08-14 14:37:33 +04:00
|
|
|
}
|
2011-06-28 02:21:15 +04:00
|
|
|
data->c = c;
|
2009-08-14 14:37:33 +04:00
|
|
|
data->box = box;
|
2019-11-06 02:05:42 +03:00
|
|
|
res = scrollbar_create(true,
|
|
|
|
visible_width - (right ? SCROLLBAR_WIDTH : 0),
|
|
|
|
full_width,
|
|
|
|
visible_width,
|
|
|
|
data,
|
|
|
|
html_overflow_scroll_callback,
|
|
|
|
&box->scroll_x);
|
|
|
|
if (res != NSERROR_OK) {
|
|
|
|
return res;
|
2016-04-26 14:14:56 +03:00
|
|
|
}
|
2011-05-10 14:41:57 +04:00
|
|
|
} else {
|
2011-05-10 02:49:17 +04:00
|
|
|
scrollbar_set_extents(box->scroll_x,
|
2011-05-10 14:41:57 +04:00
|
|
|
visible_width -
|
2009-08-14 14:37:33 +04:00
|
|
|
(right ? SCROLLBAR_WIDTH : 0),
|
2011-05-10 14:41:57 +04:00
|
|
|
visible_width, full_width);
|
|
|
|
}
|
2009-08-14 14:37:33 +04:00
|
|
|
}
|
2018-05-10 13:34:26 +03:00
|
|
|
|
2019-11-06 02:05:42 +03:00
|
|
|
if (right && bottom) {
|
2011-05-10 02:49:17 +04:00
|
|
|
scrollbar_make_pair(box->scroll_x, box->scroll_y);
|
2019-11-06 02:05:42 +03:00
|
|
|
}
|
2018-05-10 13:34:26 +03:00
|
|
|
|
2019-11-06 02:05:42 +03:00
|
|
|
return NSERROR_OK;
|
2009-08-14 14:37:33 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determine if a box has a vertical scrollbar.
|
|
|
|
*
|
|
|
|
* \param box scrolling box
|
|
|
|
* \return the box has a vertical scrollbar
|
|
|
|
*/
|
|
|
|
|
|
|
|
bool box_vscrollbar_present(const struct box * const box)
|
|
|
|
{
|
2011-02-25 01:00:24 +03:00
|
|
|
return box->padding[TOP] + box->height + box->padding[BOTTOM] +
|
2009-08-14 14:37:33 +04:00
|
|
|
box->border[BOTTOM].width < box->descendant_y1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determine if a box has a horizontal scrollbar.
|
|
|
|
*
|
|
|
|
* \param box scrolling box
|
|
|
|
* \return the box has a horizontal scrollbar
|
|
|
|
*/
|
|
|
|
|
|
|
|
bool box_hscrollbar_present(const struct box * const box)
|
|
|
|
{
|
2011-02-25 01:00:24 +03:00
|
|
|
return box->padding[LEFT] + box->width + box->padding[RIGHT] +
|
2009-08-14 14:37:33 +04:00
|
|
|
box->border[RIGHT].width < box->descendant_x1;
|
|
|
|
}
|