blob: 8c68cf9937fd2712ffbc7e2dee3cd4bb760d9b76 [file] [log] [blame]
/*
* Copyright (C) 2002 Lars Knoll (knoll@kde.org)
* (C) 2002 Dirk Mueller (mueller@kde.org)
* Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "core/layout/TableLayoutAlgorithmFixed.h"
#include "core/frame/UseCounter.h"
#include "core/layout/LayoutTable.h"
#include "core/layout/LayoutTableCell.h"
#include "core/layout/LayoutTableCol.h"
#include "core/layout/LayoutTableSection.h"
#include "platform/LayoutUnit.h"
/*
The text below is from the CSS 2.1 specs.
Fixed table layout
With this (fast) algorithm, the horizontal layout of the table does
not depend on the contents of the cells; it only depends on the
table's width, the width of the columns, and borders or cell
spacing.
The table's width may be specified explicitly with the 'width'
property. A value of 'auto' (for both 'display: table' and 'display:
inline-table') means use the automatic table layout algorithm.
In the fixed table layout algorithm, the width of each column is
determined as follows:
1. A column element with a value other than 'auto' for the 'width'
property sets the width for that column.
2. Otherwise, a cell in the first row with a value other than
'auto' for the 'width' property sets the width for that column. If
the cell spans more than one column, the width is divided over the
columns.
3. Any remaining columns equally divide the remaining horizontal
table space (minus borders or cell spacing).
The width of the table is then the greater of the value of the
'width' property for the table element and the sum of the column
widths (plus cell spacing or borders). If the table is wider than
the columns, the extra space should be distributed over the columns.
In this manner, the user agent can begin to lay out the table once
the entire first row has been received. Cells in subsequent rows do
not affect column widths. Any cell that has content that overflows
uses the 'overflow' property to determine whether to clip the
overflow content.
*/
namespace blink {
TableLayoutAlgorithmFixed::TableLayoutAlgorithmFixed(LayoutTable* table)
: TableLayoutAlgorithm(table), recorded_width_difference_(false) {}
int TableLayoutAlgorithmFixed::CalcWidthArray() {
// FIXME: We might want to wait until we have all of the first row before
// computing for the first time.
int used_width = 0;
// iterate over all <col> elements
unsigned n_eff_cols = table_->NumEffectiveColumns();
width_.resize(n_eff_cols);
width_.Fill(Length(kAuto));
unsigned current_effective_column = 0;
for (LayoutTableCol* col = table_->FirstColumn(); col;
col = col->NextColumn()) {
// LayoutTableCols don't have the concept of preferred logical width, but we
// need to clear their dirty bits so that if we call
// setPreferredWidthsDirty(true) on a col or one of its descendants, we'll
// mark it's ancestors as dirty.
col->ClearPreferredLogicalWidthsDirtyBits();
// Width specified by column-groups that have column child does not affect
// column width in fixed layout tables
if (col->IsTableColumnGroupWithColumnChildren())
continue;
Length col_style_logical_width = col->Style()->LogicalWidth();
int effective_col_width = 0;
if (col_style_logical_width.IsFixed() &&
col_style_logical_width.Value() > 0)
effective_col_width = col_style_logical_width.Value();
unsigned span = col->Span();
while (span) {
unsigned span_in_current_effective_column;
if (current_effective_column >= n_eff_cols) {
table_->AppendEffectiveColumn(span);
n_eff_cols++;
width_.push_back(Length());
span_in_current_effective_column = span;
} else {
if (span < table_->SpanOfEffectiveColumn(current_effective_column)) {
table_->SplitEffectiveColumn(current_effective_column, span);
n_eff_cols++;
width_.push_back(Length());
}
span_in_current_effective_column =
table_->SpanOfEffectiveColumn(current_effective_column);
}
// TODO(alancutter): Make this work correctly for calc lengths.
if ((col_style_logical_width.IsFixed() ||
col_style_logical_width.IsPercent()) &&
col_style_logical_width.IsPositive()) {
width_[current_effective_column] = col_style_logical_width;
width_[current_effective_column] *= span_in_current_effective_column;
used_width += effective_col_width * span_in_current_effective_column;
}
span -= span_in_current_effective_column;
current_effective_column++;
}
}
// Iterate over the first row in case some are unspecified.
LayoutTableSection* section = table_->TopNonEmptySection();
if (!section)
return used_width;
unsigned current_column = 0;
LayoutTableRow* first_row = section->FirstRow();
for (LayoutTableCell* cell = first_row->FirstCell(); cell;
cell = cell->NextCell()) {
Length logical_width = cell->StyleOrColLogicalWidth();
// FIXME: calc() on tables should be handled consistently with other
// lengths. See bug: https://crbug.com/382725
if (logical_width.IsCalculated())
logical_width = Length(); // Make it Auto
unsigned span = cell->ColSpan();
int fixed_border_box_logical_width = 0;
// FIXME: Support other length types. If the width is non-auto, it should
// probably just use LayoutBox::computeLogicalWidthUsing to compute the
// width.
if (logical_width.IsFixed() && logical_width.IsPositive()) {
fixed_border_box_logical_width =
cell->AdjustBorderBoxLogicalWidthForBoxSizing(logical_width.Value())
.ToInt();
logical_width.SetValue(fixed_border_box_logical_width);
}
unsigned used_span = 0;
while (used_span < span && current_column < n_eff_cols) {
float e_span = table_->SpanOfEffectiveColumn(current_column);
// Only set if no col element has already set it.
if (width_[current_column].IsAuto() && !logical_width.IsAuto()) {
width_[current_column] = logical_width;
width_[current_column] *= e_span / span;
used_width += fixed_border_box_logical_width * e_span / span;
}
used_span += e_span;
++current_column;
}
// TableLayoutAlgorithmFixed doesn't use min/maxPreferredLogicalWidths, but
// we need to clear the dirty bit on the cell so that we'll correctly mark
// its ancestors dirty in case we later call
// setPreferredLogicalWidthsDirty() on it later.
if (cell->PreferredLogicalWidthsDirty())
cell->ClearPreferredLogicalWidthsDirty();
}
return used_width;
}
void TableLayoutAlgorithmFixed::ComputeIntrinsicLogicalWidths(
LayoutUnit& min_width,
LayoutUnit& max_width) {
min_width = max_width = LayoutUnit(CalcWidthArray());
}
void TableLayoutAlgorithmFixed::ApplyPreferredLogicalWidthQuirks(
LayoutUnit& min_width,
LayoutUnit& max_width) const {
Length table_logical_width = table_->Style()->LogicalWidth();
if (table_logical_width.IsFixed() && table_logical_width.IsPositive()) {
min_width = max_width = LayoutUnit(
max(min_width,
LayoutUnit(table_logical_width.Value() -
table_->BordersPaddingAndSpacingInRowDirection()))
.Floor());
}
/*
<table style="width:100%; background-color:red"><tr><td>
<table style="background-color:blue"><tr><td>
<table style="width:100%; background-color:green;
table-layout:fixed"><tr><td>
Content
</td></tr></table>
</td></tr></table>
</td></tr></table>
*/
// In this example, the two inner tables should be as large as the outer
// table. We can achieve this effect by making the maxwidth of fixed tables
// with percentage widths be infinite.
if (table_->Style()->LogicalWidth().IsPercentOrCalc() &&
max_width < kTableMaxWidth)
max_width = LayoutUnit(kTableMaxWidth);
}
void TableLayoutAlgorithmFixed::UpdateLayout() {
int table_logical_width = (table_->LogicalWidth() -
table_->BordersPaddingAndSpacingInRowDirection())
.ToInt();
unsigned n_eff_cols = table_->NumEffectiveColumns();
// FIXME: It is possible to be called without having properly updated our
// internal representation. This means that our preferred logical widths were
// not recomputed as expected.
if (n_eff_cols != width_.size()) {
CalcWidthArray();
// FIXME: Table layout shouldn't modify our table structure (but does due to
// columns and column-groups).
n_eff_cols = table_->NumEffectiveColumns();
}
Vector<int> calc_width(n_eff_cols, 0);
unsigned num_auto = 0;
unsigned auto_span = 0;
int total_fixed_width = 0;
int total_percent_width = 0;
float total_percent = 0;
// Compute requirements and try to satisfy fixed and percent widths.
// Percentages are of the table's width, so for example
// for a table width of 100px with columns (40px, 10%), the 10% compute
// to 10px here, and will scale up to 20px in the final (80px, 20px).
for (unsigned i = 0; i < n_eff_cols; i++) {
if (width_[i].IsFixed()) {
calc_width[i] = width_[i].Value();
total_fixed_width += calc_width[i];
} else if (width_[i].IsPercent()) {
// TODO(alancutter): Make this work correctly for calc lengths.
calc_width[i] =
ValueForLength(width_[i], LayoutUnit(table_logical_width)).ToInt();
total_percent_width += calc_width[i];
total_percent += width_[i].Percent();
} else if (width_[i].IsAuto()) {
num_auto++;
auto_span += table_->SpanOfEffectiveColumn(i);
}
}
int hspacing = table_->HBorderSpacing();
int total_width = total_fixed_width + total_percent_width;
if (!num_auto || total_width > table_logical_width) {
// If there are no auto columns, or if the total is too wide, take
// what we have and scale it to fit as necessary.
if (total_width != table_logical_width) {
// Fixed widths only scale up
if (total_fixed_width && total_width < table_logical_width) {
int first_pass_fixed_width_total = total_fixed_width;
total_fixed_width = 0;
int width_available_for_fixed =
table_logical_width - total_percent_width;
for (unsigned i = 0; i < n_eff_cols; i++) {
if (width_[i].IsFixed()) {
int legacy_expanded_width =
calc_width[i] * table_logical_width / total_width;
if (!recorded_width_difference_) {
int future_expanded_width = calc_width[i] *
width_available_for_fixed /
first_pass_fixed_width_total;
if (future_expanded_width != legacy_expanded_width) {
recorded_width_difference_ = true;
UseCounter::Count(
table_->GetDocument(),
WebFeature::kFixedWidthTableDistributionChanged);
}
}
calc_width[i] = legacy_expanded_width;
total_fixed_width += calc_width[i];
}
}
}
if (total_percent) {
total_percent_width = 0;
for (unsigned i = 0; i < n_eff_cols; i++) {
// TODO(alancutter): Make this work correctly for calc lengths.
if (width_[i].IsPercent()) {
calc_width[i] = width_[i].Percent() *
(table_logical_width - total_fixed_width) /
total_percent;
total_percent_width += calc_width[i];
}
}
}
total_width = total_fixed_width + total_percent_width;
}
} else {
// Divide the remaining width among the auto columns.
DCHECK_GE(auto_span, num_auto);
int remaining_width = table_logical_width - total_fixed_width -
total_percent_width -
hspacing * (auto_span - num_auto);
int last_auto = 0;
for (unsigned i = 0; i < n_eff_cols; i++) {
if (width_[i].IsAuto()) {
unsigned span = table_->SpanOfEffectiveColumn(i);
int w = remaining_width * span / auto_span;
calc_width[i] = w + hspacing * (span - 1);
remaining_width -= w;
if (!remaining_width)
break;
last_auto = i;
DCHECK_GE(auto_span, span);
auto_span -= span;
}
}
// Last one gets the remainder.
if (remaining_width)
calc_width[last_auto] += remaining_width;
total_width = table_logical_width;
}
if (total_width < table_logical_width) {
// Spread extra space over columns.
int remaining_width = table_logical_width - total_width;
int total = n_eff_cols;
while (total) {
int w = remaining_width / total;
remaining_width -= w;
calc_width[--total] += w;
}
if (n_eff_cols > 0)
calc_width[n_eff_cols - 1] += remaining_width;
}
DCHECK_EQ(table_->EffectiveColumnPositions().size(), n_eff_cols + 1);
int pos = 0;
for (unsigned i = 0; i < n_eff_cols; i++) {
table_->SetEffectiveColumnPosition(i, pos);
pos += calc_width[i] + hspacing;
}
// The extra position is for the imaginary column after the last column.
table_->SetEffectiveColumnPosition(n_eff_cols, pos);
}
void TableLayoutAlgorithmFixed::WillChangeTableLayout() {
// When switching table layout algorithm, we need to dirty the preferred
// logical widths as we cleared the bits without computing them.
// (see calcWidthArray above.) This optimization is preferred to always
// computing the logical widths we never intended to use.
table_->RecalcSectionsIfNeeded();
table_->MarkAllCellsWidthsDirtyAndOrNeedsLayout(LayoutTable::kMarkDirtyOnly);
}
} // namespace blink