mirrors/netsurf
1
0
Fork 0
mirror of https://github.com/netsurf-browser/netsurf synced 2024-11-28 01:09:39 +03:00
Code Issues Packages Projects Releases Wiki Activity
8435195ea4
netsurf/render/table.c
John Mark Bell ff60007458 Fix build with NDEBUG defined 
svn path=/trunk/netsurf/; revision=12154
2011-04-03 22:23:14 +00:00

997 lines
28 KiB
C
Raw Blame History

/*
* Copyright 2005 James Bursa <bursa@users.sourceforge.net>
* Copyright 2005 Richard Wilson <info@tinct.net>
*
* 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/>.
*/
/** \file
* Table processing and layout (implementation).
*/
#include <assert.h>
#include "css/css.h"
#include "css/utils.h"
#include "render/box.h"
#include "render/table.h"
#include "utils/log.h"
#include "utils/talloc.h"
/* Define to enable verbose table debug */
#undef TABLE_DEBUG
/**
* Container for border values during table border calculations
*/
struct border {
enum css_border_style_e style; /**< border-style */
enum css_border_color_e color; /**< border-color type */
css_color c; /**< border-color value */
css_fixed width; /**< border-width length */
css_unit unit; /**< border-width units */
};
static void table_used_left_border_for_cell(struct box *cell);
static void table_used_top_border_for_cell(struct box *cell);
static void table_used_right_border_for_cell(struct box *cell);
static void table_used_bottom_border_for_cell(struct box *cell);
static bool table_border_is_more_eyecatching(const struct border *a,
box_type a_src, const struct border *b, box_type b_src);
static void table_cell_top_process_table(struct box *table, struct border *a,
box_type *a_src);
static bool table_cell_top_process_group(struct box *cell, struct box *group,
struct border *a, box_type *a_src);
static bool table_cell_top_process_row(struct box *cell, struct box *row,
struct border *a, box_type *a_src);
/**
* Determine the column width types for a table.
*
* \param table box of type BOX_TABLE
* \return true on success, false on memory exhaustion
*
* The table->col array is allocated and type and width are filled in for each
* column.
*/
bool table_calculate_column_types(struct box *table)
{
unsigned int i, j;
struct column *col;
struct box *row_group, *row, *cell;
if (table->col)
/* table->col already constructed, for example frameset table */
return true;
table->col = col = talloc_array(table, struct column, table->columns);
if (!col)
return false;
for (i = 0; i != table->columns; i++) {
col[i].type = COLUMN_WIDTH_UNKNOWN;
col[i].width = 0;
col[i].positioned = true;
}
/* 1st pass: cells with colspan 1 only */
for (row_group = table->children; row_group; row_group =row_group->next)
for (row = row_group->children; row; row = row->next)
for (cell = row->children; cell; cell = cell->next) {
enum css_width_e type;
css_fixed value = 0;
css_unit unit = CSS_UNIT_PX;
assert(cell->type == BOX_TABLE_CELL);
assert(cell->style);
if (cell->columns != 1)
continue;
i = cell->start_column;
if (css_computed_position(cell->style) !=
CSS_POSITION_ABSOLUTE &&
css_computed_position(cell->style) !=
CSS_POSITION_FIXED) {
col[i].positioned = false;
}
type = css_computed_width(cell->style, &value, &unit);
/* fixed width takes priority over any other width type */
if (col[i].type != COLUMN_WIDTH_FIXED &&
type == CSS_WIDTH_SET && unit != CSS_UNIT_PCT) {
col[i].type = COLUMN_WIDTH_FIXED;
col[i].width = FIXTOINT(nscss_len2px(value, unit,
cell->style));
if (col[i].width < 0)
col[i].width = 0;
continue;
}
if (col[i].type != COLUMN_WIDTH_UNKNOWN)
continue;
if (type == CSS_WIDTH_SET && unit == CSS_UNIT_PCT) {
col[i].type = COLUMN_WIDTH_PERCENT;
col[i].width = FIXTOINT(value);
if (col[i].width < 0)
col[i].width = 0;
} else if (type == CSS_WIDTH_AUTO) {
col[i].type = COLUMN_WIDTH_AUTO;
}
}
/* 2nd pass: cells which span multiple columns */
for (row_group = table->children; row_group; row_group =row_group->next)
for (row = row_group->children; row; row = row->next)
for (cell = row->children; cell; cell = cell->next) {
unsigned int fixed_columns = 0, percent_columns = 0,
auto_columns = 0, unknown_columns = 0;
int fixed_width = 0, percent_width = 0;
enum css_width_e type;
css_fixed value = 0;
css_unit unit = CSS_UNIT_PX;
if (cell->columns == 1)
continue;
i = cell->start_column;
for (j = i; j < i + cell->columns; j++) {
col[j].positioned = false;
}
/* count column types in spanned cells */
for (j = 0; j != cell->columns; j++) {
if (col[i + j].type == COLUMN_WIDTH_FIXED) {
fixed_width += col[i + j].width;
fixed_columns++;
} else if (col[i + j].type == COLUMN_WIDTH_PERCENT) {
percent_width += col[i + j].width;
percent_columns++;
} else if (col[i + j].type == COLUMN_WIDTH_AUTO) {
auto_columns++;
} else {
unknown_columns++;
}
}
if (!unknown_columns)
continue;
type = css_computed_width(cell->style, &value, &unit);
/* if cell is fixed width, and all spanned columns are fixed
* or unknown width, split extra width among unknown columns */
if (type == CSS_WIDTH_SET && unit != CSS_UNIT_PCT &&
fixed_columns + unknown_columns ==
cell->columns) {
int width = (FIXTOFLT(nscss_len2px(value, unit,
cell->style)) - fixed_width) /
unknown_columns;
if (width < 0)
width = 0;
for (j = 0; j != cell->columns; j++) {
if (col[i + j].type == COLUMN_WIDTH_UNKNOWN) {
col[i + j].type = COLUMN_WIDTH_FIXED;
col[i + j].width = width;
}
}
}
/* as above for percentage width */
if (type == CSS_WIDTH_SET && unit == CSS_UNIT_PCT &&
percent_columns + unknown_columns ==
cell->columns) {
int width = (FIXTOFLT(value) -
percent_width) / unknown_columns;
if (width < 0)
width = 0;
for (j = 0; j != cell->columns; j++) {
if (col[i + j].type == COLUMN_WIDTH_UNKNOWN) {
col[i + j].type = COLUMN_WIDTH_PERCENT;
col[i + j].width = width;
}
}
}
}
/* use AUTO if no width type was specified */
for (i = 0; i != table->columns; i++) {
if (col[i].type == COLUMN_WIDTH_UNKNOWN)
col[i].type = COLUMN_WIDTH_AUTO;
}
#ifdef TABLE_DEBUG
for (i = 0; i != table->columns; i++)
LOG(("table %p, column %u: type %s, width %i", table, i,
((const char *[]) {"UNKNOWN", "FIXED", "AUTO",
"PERCENT", "RELATIVE"})[col[i].type],
col[i].width));
#endif
return true;
}
/**
* Calculate used values of border-{trbl}-{style,color,width} for table cells.
*
* \param cell Table cell to consider
*
* \post \a cell's border array is populated
*/
void table_used_border_for_cell(struct box *cell)
{
int side;
assert(cell->type == BOX_TABLE_CELL);
if (css_computed_border_collapse(cell->style) ==
CSS_BORDER_COLLAPSE_SEPARATE) {
css_fixed width = 0;
css_unit unit = CSS_UNIT_PX;
/* Left border */
cell->border[LEFT].style =
css_computed_border_left_style(cell->style);
css_computed_border_left_color(cell->style,
&cell->border[LEFT].c);
css_computed_border_left_width(cell->style, &width, &unit);
cell->border[LEFT].width =
FIXTOINT(nscss_len2px(width, unit, cell->style));
/* Top border */
cell->border[TOP].style =
css_computed_border_top_style(cell->style);
css_computed_border_top_color(cell->style,
&cell->border[TOP].c);
css_computed_border_top_width(cell->style, &width, &unit);
cell->border[TOP].width =
FIXTOINT(nscss_len2px(width, unit, cell->style));
/* Right border */
cell->border[RIGHT].style =
css_computed_border_right_style(cell->style);
css_computed_border_right_color(cell->style,
&cell->border[RIGHT].c);
css_computed_border_right_width(cell->style, &width, &unit);
cell->border[RIGHT].width =
FIXTOINT(nscss_len2px(width, unit, cell->style));
/* Bottom border */
cell->border[BOTTOM].style =
css_computed_border_bottom_style(cell->style);
css_computed_border_bottom_color(cell->style,
&cell->border[BOTTOM].c);
css_computed_border_bottom_width(cell->style, &width, &unit);
cell->border[BOTTOM].width =
FIXTOINT(nscss_len2px(width, unit, cell->style));
} else {
/* Left border */
table_used_left_border_for_cell(cell);
/* Top border */
table_used_top_border_for_cell(cell);
/* Right border */
table_used_right_border_for_cell(cell);
/* Bottom border */
table_used_bottom_border_for_cell(cell);
}
/* Finally, ensure that any borders configured as
* hidden or none have zero width. (c.f. layout_find_dimensions) */
for (side = 0; side != 4; side++) {
if (cell->border[side].style == CSS_BORDER_STYLE_HIDDEN ||
cell->border[side].style ==
CSS_BORDER_STYLE_NONE)
cell->border[side].width = 0;
}
}
/******************************************************************************
* Helpers for used border calculations *
******************************************************************************/
/**
* Calculate used values of border-left-{style,color,width}
*
* \param cell Table cell to consider
*/
void table_used_left_border_for_cell(struct box *cell)
{
struct border a, b;
box_type a_src, b_src;
/** \todo Need column and column_group, too */
/* Initialise to computed left border for cell */
a.style = css_computed_border_left_style(cell->style);
a.color = css_computed_border_left_color(cell->style, &a.c);
css_computed_border_left_width(cell->style, &a.width, &a.unit);
a.width = nscss_len2px(a.width, a.unit, cell->style);
a.unit = CSS_UNIT_PX;
a_src = BOX_TABLE_CELL;
if (cell->prev != NULL || cell->start_column != 0) {
/* Cell to the left -- consider its right border */
struct box *prev = NULL;
if (cell->prev == NULL) {
struct box *row;
/* Spanned from a previous row */
for (row = cell->parent; row != NULL; row = row->prev) {
for (prev = row->children; prev != NULL;
prev = prev->next) {
if (prev->start_column +
prev->columns ==
cell->start_column)
break;
}
if (prev != NULL)
break;
}
assert(prev != NULL);
} else {
prev = cell->prev;
}
b.style = css_computed_border_right_style(prev->style);
b.color = css_computed_border_right_color(prev->style, &b.c);
css_computed_border_right_width(prev->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, prev->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_CELL;
if (table_border_is_more_eyecatching(&a, a_src, &b, b_src)) {
a = b;
a_src = b_src;
}
} else {
/* First cell in row, so consider rows and row group */
struct box *row = cell->parent;
struct box *group = row->parent;
struct box *table = group->parent;
unsigned int rows = cell->rows;
while (rows-- > 0 && row != NULL) {
/* Spanned rows -- consider their left border */
b.style = css_computed_border_left_style(row->style);
b.color = css_computed_border_left_color(
row->style, &b.c);
css_computed_border_left_width(
row->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, row->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_ROW;
if (table_border_is_more_eyecatching(&a, a_src,
&b, b_src)) {
a = b;
a_src = b_src;
}
row = row->next;
}
/** \todo can cells span row groups? */
/* Row group -- consider its left border */
b.style = css_computed_border_left_style(group->style);
b.color = css_computed_border_left_color(group->style, &b.c);
css_computed_border_left_width(group->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, group->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_ROW_GROUP;
if (table_border_is_more_eyecatching(&a, a_src, &b, b_src)) {
a = b;
a_src = b_src;
}
/* The table itself -- consider its left border */
b.style = css_computed_border_left_style(table->style);
b.color = css_computed_border_left_color(table->style, &b.c);
css_computed_border_left_width(table->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, table->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE;
if (table_border_is_more_eyecatching(&a, a_src, &b, b_src)) {
a = b;
a_src = b_src;
}
}
/* a now contains the used left border for the cell */
cell->border[LEFT].style = a.style;
cell->border[LEFT].c = a.c;
cell->border[LEFT].width =
FIXTOINT(nscss_len2px(a.width, a.unit, cell->style));
}
/**
* Calculate used values of border-top-{style,color,width}
*
* \param cell Table cell to consider
*/
void table_used_top_border_for_cell(struct box *cell)
{
struct border a, b;
box_type a_src, b_src;
struct box *row = cell->parent;
bool process_group = false;
/* Initialise to computed top border for cell */
a.style = css_computed_border_top_style(cell->style);
css_computed_border_top_color(cell->style, &a.c);
css_computed_border_top_width(cell->style, &a.width, &a.unit);
a.width = nscss_len2px(a.width, a.unit, cell->style);
a.unit = CSS_UNIT_PX;
a_src = BOX_TABLE_CELL;
/* Top border of row */
b.style = css_computed_border_top_style(row->style);
css_computed_border_top_color(row->style, &b.c);
css_computed_border_top_width(row->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, row->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_ROW;
if (table_border_is_more_eyecatching(&a, a_src, &b, b_src)) {
a = b;
a_src = b_src;
}
if (row->prev != NULL) {
/* Consider row(s) above */
while (table_cell_top_process_row(cell, row->prev,
&a, &a_src) == false) {
if (row->prev->prev == NULL) {
/* Consider row group */
process_group = true;
break;
} else {
row = row->prev;
}
}
} else {
process_group = true;
}
if (process_group) {
struct box *group = row->parent;
/* Top border of row group */
b.style = css_computed_border_top_style(group->style);
b.color = css_computed_border_top_color(group->style, &b.c);
css_computed_border_top_width(group->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, group->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_ROW_GROUP;
if (table_border_is_more_eyecatching(&a, a_src, &b, b_src)) {
a = b;
a_src = b_src;
}
if (group->prev == NULL) {
/* Top border of table */
table_cell_top_process_table(group->parent, &a, &a_src);
} else {
/* Process previous group(s) */
while (table_cell_top_process_group(cell, group->prev,
&a, &a_src) == false) {
if (group->prev->prev == NULL) {
/* Top border of table */
table_cell_top_process_table(
group->parent,
&a, &a_src);
break;
} else {
group = group->prev;
}
}
}
}
/* a now contains the used top border for the cell */
cell->border[TOP].style = a.style;
cell->border[TOP].c = a.c;
cell->border[TOP].width =
FIXTOINT(nscss_len2px(a.width, a.unit, cell->style));
}
/**
* Calculate used values of border-right-{style,color,width}
*
* \param cell Table cell to consider
*/
void table_used_right_border_for_cell(struct box *cell)
{
struct border a, b;
box_type a_src, b_src;
/** \todo Need column and column_group, too */
/* Initialise to computed right border for cell */
a.style = css_computed_border_right_style(cell->style);
css_computed_border_right_color(cell->style, &a.c);
css_computed_border_right_width(cell->style, &a.width, &a.unit);
a.width = nscss_len2px(a.width, a.unit, cell->style);
a.unit = CSS_UNIT_PX;
a_src = BOX_TABLE_CELL;
if (cell->next != NULL || cell->start_column + cell->columns !=
cell->parent->parent->parent->columns) {
/* Cell is not at right edge of table -- no right border */
a.style = CSS_BORDER_STYLE_NONE;
a.width = 0;
a.unit = CSS_UNIT_PX;
} else {
/* Last cell in row, so consider rows and row group */
struct box *row = cell->parent;
struct box *group = row->parent;
struct box *table = group->parent;
unsigned int rows = cell->rows;
while (rows-- > 0 && row != NULL) {
/* Spanned rows -- consider their right border */
b.style = css_computed_border_right_style(row->style);
b.color = css_computed_border_right_color(
row->style, &b.c);
css_computed_border_right_width(
row->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, row->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_ROW;
if (table_border_is_more_eyecatching(&a, a_src,
&b, b_src)) {
a = b;
a_src = b_src;
}
row = row->next;
}
/** \todo can cells span row groups? */
/* Row group -- consider its right border */
b.style = css_computed_border_right_style(group->style);
b.color = css_computed_border_right_color(group->style, &b.c);
css_computed_border_right_width(group->style,
&b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, group->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_ROW_GROUP;
if (table_border_is_more_eyecatching(&a, a_src, &b, b_src)) {
a = b;
a_src = b_src;
}
/* The table itself -- consider its right border */
b.style = css_computed_border_right_style(table->style);
b.color = css_computed_border_right_color(table->style, &b.c);
css_computed_border_right_width(table->style,
&b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, table->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE;
if (table_border_is_more_eyecatching(&a, a_src, &b, b_src)) {
a = b;
a_src = b_src;
}
}
/* a now contains the used right border for the cell */
cell->border[RIGHT].style = a.style;
cell->border[RIGHT].c = a.c;
cell->border[RIGHT].width =
FIXTOINT(nscss_len2px(a.width, a.unit, cell->style));
}
/**
* Calculate used values of border-bottom-{style,color,width}
*
* \param cell Table cell to consider
*/
void table_used_bottom_border_for_cell(struct box *cell)
{
struct border a, b;
box_type a_src, b_src;
struct box *row = cell->parent;
unsigned int rows = cell->rows;
/* Initialise to computed bottom border for cell */
a.style = css_computed_border_bottom_style(cell->style);
css_computed_border_bottom_color(cell->style, &a.c);
css_computed_border_bottom_width(cell->style, &a.width, &a.unit);
a.width = nscss_len2px(a.width, a.unit, cell->style);
a.unit = CSS_UNIT_PX;
a_src = BOX_TABLE_CELL;
while (rows-- > 0 && row != NULL)
row = row->next;
/** \todo Can cells span row groups? */
if (row != NULL) {
/* Cell is not at bottom edge of table -- no bottom border */
a.style = CSS_BORDER_STYLE_NONE;
a.width = 0;
a.unit = CSS_UNIT_PX;
} else {
/* Cell at bottom of table, so consider row and row group */
struct box *row = cell->parent;
struct box *group = row->parent;
struct box *table = group->parent;
/* Bottom border of row */
b.style = css_computed_border_bottom_style(row->style);
b.color = css_computed_border_bottom_color(row->style, &b.c);
css_computed_border_bottom_width(row->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, row->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_ROW;
if (table_border_is_more_eyecatching(&a, a_src, &b, b_src)) {
a = b;
a_src = b_src;
}
/* Row group -- consider its bottom border */
b.style = css_computed_border_bottom_style(group->style);
b.color = css_computed_border_bottom_color(group->style, &b.c);
css_computed_border_bottom_width(group->style,
&b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, group->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_ROW_GROUP;
if (table_border_is_more_eyecatching(&a, a_src, &b, b_src)) {
a = b;
a_src = b_src;
}
/* The table itself -- consider its bottom border */
b.style = css_computed_border_bottom_style(table->style);
b.color = css_computed_border_bottom_color(table->style, &b.c);
css_computed_border_bottom_width(table->style,
&b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, table->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE;
if (table_border_is_more_eyecatching(&a, a_src, &b, b_src)) {
a = b;
a_src = b_src;
}
}
/* a now contains the used bottom border for the cell */
cell->border[BOTTOM].style = a.style;
cell->border[BOTTOM].c = a.c;
cell->border[BOTTOM].width =
FIXTOINT(nscss_len2px(a.width, a.unit, cell->style));
}
/**
* Determine if a border style is more eyecatching than another
*
* \param a Reference border style
* \param a_src Source of \a a
* \param b Candidate border style
* \param b_src Source of \a b
* \return True if \a b is more eyecatching than \a a
*/
bool table_border_is_more_eyecatching(const struct border *a,
box_type a_src, const struct border *b, box_type b_src)
{
css_fixed awidth, bwidth;
int impact = 0;
/* See CSS 2.1 $17.6.2.1 */
/* 1 + 2 -- hidden beats everything, none beats nothing */
if (a->style == CSS_BORDER_STYLE_HIDDEN ||
b->style == CSS_BORDER_STYLE_NONE)
return false;
if (b->style == CSS_BORDER_STYLE_HIDDEN ||
a->style == CSS_BORDER_STYLE_NONE)
return true;
/* 3a -- wider borders beat narrow ones */
/* The widths must be absolute, which will be the case
* if they've come from a computed style. */
assert(a->unit != CSS_UNIT_EM && a->unit != CSS_UNIT_EX);
assert(b->unit != CSS_UNIT_EM && b->unit != CSS_UNIT_EX);
awidth = nscss_len2px(a->width, a->unit, NULL);
bwidth = nscss_len2px(b->width, b->unit, NULL);
if (awidth < bwidth)
return true;
else if (bwidth < awidth)
return false;
/* 3b -- sort by style */
switch (a->style) {
case CSS_BORDER_STYLE_DOUBLE: impact++;
case CSS_BORDER_STYLE_SOLID: impact++;
case CSS_BORDER_STYLE_DASHED: impact++;
case CSS_BORDER_STYLE_DOTTED: impact++;
case CSS_BORDER_STYLE_RIDGE: impact++;
case CSS_BORDER_STYLE_OUTSET: impact++;
case CSS_BORDER_STYLE_GROOVE: impact++;
case CSS_BORDER_STYLE_INSET: impact++;
default:
break;
}
switch (b->style) {
case CSS_BORDER_STYLE_DOUBLE: impact--;
case CSS_BORDER_STYLE_SOLID: impact--;
case CSS_BORDER_STYLE_DASHED: impact--;
case CSS_BORDER_STYLE_DOTTED: impact--;
case CSS_BORDER_STYLE_RIDGE: impact--;
case CSS_BORDER_STYLE_OUTSET: impact--;
case CSS_BORDER_STYLE_GROOVE: impact--;
case CSS_BORDER_STYLE_INSET: impact--;
default:
break;
}
if (impact < 0)
return true;
else if (impact > 0)
return false;
/* 4a -- sort by origin */
impact = 0;
switch (a_src) {
case BOX_TABLE_CELL: impact++;
case BOX_TABLE_ROW: impact++;
case BOX_TABLE_ROW_GROUP: impact++;
/** \todo COL/COL_GROUP */
case BOX_TABLE: impact++;
default:
break;
}
switch (b_src) {
case BOX_TABLE_CELL: impact--;
case BOX_TABLE_ROW: impact--;
case BOX_TABLE_ROW_GROUP: impact--;
/** \todo COL/COL_GROUP */
case BOX_TABLE: impact--;
default:
break;
}
if (impact < 0)
return true;
else if (impact > 0)
return false;
/* 4b -- furthest left (if direction: ltr) and towards top wins */
/** \todo Currently assumes b satisifies this */
return true;
}
/******************************************************************************
* Helpers for top border collapsing *
******************************************************************************/
/**
* Process a table
*
* \param table Table to process
* \param a Current border style for cell
* \param a_src Source of \a a
*
* \post \a a will be updated with most eyecatching style
* \post \a a_src will be updated also
*/
void table_cell_top_process_table(struct box *table, struct border *a,
box_type *a_src)
{
struct border b;
box_type b_src;
/* Top border of table */
b.style = css_computed_border_top_style(table->style);
b.color = css_computed_border_top_color(table->style, &b.c);
css_computed_border_top_width(table->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, table->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE;
if (table_border_is_more_eyecatching(a, *a_src, &b, b_src)) {
*a = b;
*a_src = b_src;
}
}
/**
* Process a group
*
* \param cell Cell being considered
* \param group Group to process
* \param a Current border style for cell
* \param a_src Source of \a a
* \return true if group has non-empty rows, false otherwise
*
* \post \a a will be updated with most eyecatching style
* \post \a a_src will be updated also
*/
bool table_cell_top_process_group(struct box *cell, struct box *group,
struct border *a, box_type *a_src)
{
struct border b;
box_type b_src;
/* Bottom border of group */
b.style = css_computed_border_bottom_style(group->style);
b.color = css_computed_border_bottom_color(group->style, &b.c);
css_computed_border_bottom_width(group->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, group->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_ROW_GROUP;
if (table_border_is_more_eyecatching(a, *a_src, &b, b_src)) {
*a = b;
*a_src = b_src;
}
if (group->last != NULL) {
/* Process rows in group, starting with last */
struct box *row = group->last;
while (table_cell_top_process_row(cell, row,
a, a_src) == false) {
if (row->prev == NULL) {
return false;
} else {
row = row->prev;
}
}
} else {
/* Group is empty, so consider its top border */
b.style = css_computed_border_top_style(group->style);
b.color = css_computed_border_top_color(group->style, &b.c);
css_computed_border_top_width(group->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, group->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_ROW_GROUP;
if (table_border_is_more_eyecatching(a, *a_src, &b, b_src)) {
*a = b;
*a_src = b_src;
}
return false;
}
return true;
}
/**
* Process a row
*
* \param cell Cell being considered
* \param row Row to process
* \param a Current border style for cell
* \param a_src Source of \a a
* \return true if row has cells, false otherwise
*
* \post \a a will be updated with most eyecatching style
* \post \a a_src will be updated also
*/
bool table_cell_top_process_row(struct box *cell, struct box *row,
struct border *a, box_type *a_src)
{
struct border b;
box_type b_src;
/* Bottom border of row */
b.style = css_computed_border_bottom_style(row->style);
b.color = css_computed_border_bottom_color(row->style, &b.c);
css_computed_border_bottom_width(row->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, row->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_ROW;
if (table_border_is_more_eyecatching(a, *a_src, &b, b_src)) {
*a = b;
*a_src = b_src;
}
if (row->children == NULL) {
/* Row is empty, so consider its top border */
b.style = css_computed_border_top_style(row->style);
b.color = css_computed_border_top_color(row->style, &b.c);
css_computed_border_top_width(row->style, &b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit, row->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_ROW;
if (table_border_is_more_eyecatching(a, *a_src, &b, b_src)) {
*a = b;
*a_src = b_src;
}
return false;
} else {
/* Process cells that are directly above the cell being
* considered. They may not be in this row, but in one of the
* rows above it in the case where rowspan > 1. */
struct box *c;
bool processed = false;
while (processed == false) {
for (c = row->children; c != NULL; c = c->next) {
/* Ignore cells to the left */
if (c->start_column + c->columns <
cell->start_column)
continue;
/* Ignore cells to the right */
if (c->start_column >= cell->start_column +
cell->columns)
continue;
/* Flag that we've processed a cell */
processed = true;
/* Consider bottom border */
b.style = css_computed_border_bottom_style(
c->style);
b.color = css_computed_border_bottom_color(
c->style, &b.c);
css_computed_border_bottom_width(c->style,
&b.width, &b.unit);
b.width = nscss_len2px(b.width, b.unit,
c->style);
b.unit = CSS_UNIT_PX;
b_src = BOX_TABLE_CELL;
if (table_border_is_more_eyecatching(a, *a_src,
&b, b_src)) {
*a = b;
*a_src = b_src;
}
}
if (processed == false) {
/* There must be a preceding row */
assert(row->prev != NULL);
row = row->prev;
}
}
}
return true;
}
Reference in New Issue View Git Blame Copy Permalink