: TableLayout(table)

, m_hasPercent(false)

, m_effectiveLogicalWidthDirty(true)

{

{

Layout& columnLayout = m_layoutStruct[effCol];

// Check if this column is collapsed.

if (CheckedPtr colElement = m_table->colElement(effCol); colElement && colElement->style().visibility() == Visibility::Collapse) {

columnLayout.effectiveLogicalWidth = CSS::Keyword::Auto { };

columnLayout.effectiveMinLogicalWidth = 0;

columnLayout.effectiveMaxLogicalWidth = 0;

columnLayout.minLogicalWidth = 0;

columnLayout.maxLogicalWidth = 0;

columnLayout.logicalWidth = CSS::Keyword::Auto { };

return;

}

RenderTableCell* fixedContributor = nullptr;

RenderTableCell* maxContributor = nullptr;

for (auto& child : childrenOfType<RenderObject>(*m_table)) {

if (CheckedPtr column = dynamicDowncast<RenderTableCol>(child)) {

// RenderTableCols 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 its

// ancestors as dirty.

column->clearNeedsPreferredLogicalWidthsUpdate();

} else if (CheckedPtr section = dynamicDowncast<RenderTableSection>(child)) {

unsigned numRows = section->numRows();

for (unsigned i = 0; i < numRows; ++i) {

auto current = section->cellAt(i, effCol);

auto* cell = current.primaryCell();

if (current.inColSpan || !cell)

continue;

bool cellHasContent = cell->firstChild()

|| cell->style().border().hasBorder()

|| !Style::isKnownZero(cell->style().paddingBox())

|| cell->style().hasBackground();

if (cellHasContent)

columnLayout.emptyCellsOnly = false;

// A cell originates in this column. Ensure we have

// a min/max width of at least 1px for this column now.

columnLayout.minLogicalWidth = std::max(columnLayout.minLogicalWidth, 0.f);

columnLayout.maxLogicalWidth = std::max(columnLayout.maxLogicalWidth, 0.f);

if (cell->isOrthogonal())

cell->clearIntrinsicPadding();

if (cell->colSpan() == 1) {

columnLayout.minLogicalWidth = std::max(cell->minLogicalWidthForColumnSizing().ceilToFloat(), columnLayout.minLogicalWidth);

float maxPreferredWidth = cell->maxLogicalWidthForColumnSizing().ceilToFloat();

if (maxPreferredWidth > columnLayout.maxLogicalWidth) {

columnLayout.maxLogicalWidth = maxPreferredWidth;

maxContributor = cell;

}

// All browsers implement a size limit on the cell's max width.

// Our limit is based on KHTML's representation that used 16 bits widths.

// FIXME: Other browsers have a lower limit for the cell's max width.

const float cCellMaxWidth = 32760;

auto [ cellLogicalWidth, cellUsedZoom ] = cell->styleOrColLogicalWidth();

if (auto fixedCellLogicalWidth = cellLogicalWidth.tryFixed()) {

if (fixedCellLogicalWidth->resolveZoom(cellUsedZoom) > cCellMaxWidth)

cellLogicalWidth = Style::PreferredSize::Fixed { cCellMaxWidth };

}

WTF::switchOn(cellLogicalWidth,

[&](const Style::PreferredSize::Fixed& fixedCellLogicalWidth) {

// ignore width=0

if (fixedCellLogicalWidth.isPositive() && !columnLayout.logicalWidth.isPercentOrCalculated()) {

float logicalWidth = cell->adjustBorderBoxLogicalWidthForBoxSizing(fixedCellLogicalWidth);

// Honor the cell's CSS max-width constraint.

if (auto fixedMaxWidth = cell->style().logicalMaxWidth().tryFixed())

logicalWidth = std::min(logicalWidth, cell->adjustBorderBoxLogicalWidthForBoxSizing(*fixedMaxWidth).toFloat());

if (auto fixedColumnLayoutLogicalWidth = columnLayout.logicalWidth.tryFixed()) {

// Nav/IE weirdness

if ((logicalWidth > fixedColumnLayoutLogicalWidth->resolveZoom(cellUsedZoom))

|| ((fixedColumnLayoutLogicalWidth->resolveZoom(cellUsedZoom) == logicalWidth) && (maxContributor == cell))) {

columnLayout.logicalWidth = Style::PreferredSize::Fixed { logicalWidth };

fixedContributor = cell;

}

} else {

columnLayout.logicalWidth = Style::PreferredSize::Fixed { logicalWidth };

fixedContributor = cell;

}

}

},

[&](const Style::PreferredSize::Percentage& percentageCellLogicalWidth) {

m_hasPercent = true;

if (auto percentageColumnLayoutLogicalWidth = columnLayout.logicalWidth.tryPercentage(); percentageCellLogicalWidth.value > 0 && (!percentageColumnLayoutLogicalWidth || percentageCellLogicalWidth.value > percentageColumnLayoutLogicalWidth->value))

columnLayout.logicalWidth = cellLogicalWidth;

},

[&](const Style::PreferredSize::Calc&) {

columnLayout.logicalWidth = CSS::Keyword::Auto { };

},

[&](const auto&) { }

);

} else if (!effCol || section->primaryCellAt(i, effCol - 1) != cell) {

// If a cell originates in this spanning column ensure we have a min/max width of at least 1px for it.

columnLayout.minLogicalWidth = std::max(columnLayout.minLogicalWidth, cell->maxLogicalWidthForColumnSizing() ? 1.f : 0.f);

// This spanning cell originates in this column. Insert the cell into spanning cells list.

insertSpanCell(cell);

}

}

}

}

// Nav/IE weirdness

if (auto fixedColumnLayoutLogicalWidth = columnLayout.logicalWidth.tryFixed()) {

if (m_table->document().inQuirksMode() && columnLayout.maxLogicalWidth > fixedColumnLayoutLogicalWidth->resolveZoom(Style::ZoomFactor { columnLayout.usedZoom })

&& fixedContributor != maxContributor) {

columnLayout.logicalWidth = CSS::Keyword::Auto { };

fixedContributor = nullptr;

}

}

columnLayout.maxLogicalWidth = std::max(columnLayout.maxLogicalWidth, columnLayout.minLogicalWidth);

{

m_hasPercent = false;

m_effectiveLogicalWidthDirty = true;

unsigned nEffCols = m_table->numEffCols();

m_layoutStruct.resizeToFit(nEffCols);

m_layoutStruct.fill(Layout());

m_spanCells.fill(0);

Style::PreferredSize groupLogicalWidth = CSS::Keyword::Auto { };

unsigned currentColumn = 0;

for (RenderTableCol* column = m_table->firstColumn(); column; column = column->nextColumn()) {

if (column->isTableColumnGroupWithColumnChildren())

groupLogicalWidth = column->style().logicalWidth();

else {

auto colLogicalWidth = column->style().logicalWidth();

// FIXME: calc() on tables should be handled consistently with other lengths.

if (colLogicalWidth.isCalculated() || colLogicalWidth.isAuto())

colLogicalWidth = groupLogicalWidth;

if (colLogicalWidth.isSpecified() && colLogicalWidth.isKnownZero())

colLogicalWidth = CSS::Keyword::Auto { };

unsigned span = column->span();

// Apply width to all columns covered by this col element.

if (!colLogicalWidth.isAuto()) {

for (unsigned spanOffset = 0; spanOffset < span; ++spanOffset) {

unsigned effCol = m_table->colToEffCol(currentColumn + spanOffset);

if (effCol < nEffCols && m_table->spanOfEffCol(effCol) == 1) {

m_layoutStruct[effCol].usedZoom = column->style().usedZoom();

m_layoutStruct[effCol].logicalWidth = colLogicalWidth;

if (auto fixedColLogicalWidth = colLogicalWidth.tryFixed(); fixedColLogicalWidth && m_layoutStruct[effCol].maxLogicalWidth < fixedColLogicalWidth->resolveZoom(column->style().usedZoomForLength()))

m_layoutStruct[effCol].maxLogicalWidth = fixedColLogicalWidth->resolveZoom(column->style().usedZoomForLength());

}

}

}

currentColumn += span;

}

// For the last column in a column-group, we invalidate our group logical width.

if (column->isTableColumn() && !column->nextSibling())

groupLogicalWidth = CSS::Keyword::Auto { };

}

for (unsigned i = 0; i < nEffCols; i++)

recalcColumn(i);

for (auto& section : childrenOfType<RenderTableSection>(*m_table)) {

section.clearNeedsPreferredWidthsUpdate();

for (auto* row = section.firstRow(); row; row = row->nextRow())

row->clearNeedsPreferredWidthsUpdate();

}

{

RenderBlock* containingBlock = table.containingBlock();

while (containingBlock && !is<RenderView>(containingBlock)) {

// It doesn't matter if our table is auto or fixed: auto means we don't

// scale. Fixed doesn't care if we do or not because it doesn't depend

// on the cell contents' preferred widths.

if (is<RenderTableCell>(containingBlock))

return false;

// The max logical width of a table may be "infinity" (or tableMaxWidth, to be more exact) if the sum if the

// columns' percentages is 100% or more, AND there is at least one column that has a non-percentage-based positive

// logical width. In such situations no table logical width will be large enough to satisfy the constraint

// set by the contents. So the idea is to use ~infinity to make sure we use all available size in the containing

// block. However, this just doesn't work if this is a flex or grid item, so disallow scaling in that case.

if (isAnyOf<RenderFlexibleBox, RenderGrid>(containingBlock))

return false;

containingBlock = containingBlock->containingBlock();

}

return true;

{

fullRecalc();

float spanMaxLogicalWidth = calcEffectiveLogicalWidth();

minWidth = 0;

maxWidth = 0;

float maxPercent = 0;

float maxNonPercent = 0;

bool scaleColumnsForSelf = intrinsics == TableIntrinsics::ForLayout;

float remainingPercent = 100;

for (size_t i = 0; i < m_layoutStruct.size(); ++i) {

minWidth += m_layoutStruct[i].effectiveMinLogicalWidth;

maxWidth += m_layoutStruct[i].effectiveMaxLogicalWidth;

if (scaleColumnsForSelf) {

if (auto percentageEffectiveLogicalWidth = m_layoutStruct[i].effectiveLogicalWidth.tryPercentage()) {

float percent = std::min(percentageEffectiveLogicalWidth->value, remainingPercent);

// When percent columns meet or exceed 100% and there are remaining

// columns, the other browsers (FF, Edge) use an artificially high max

// width, so we do too. Instead of division by zero, logicalWidth and

// maxNonPercent are set to tableMaxWidth.

// Issue: https://github.com/w3c/csswg-drafts/issues/1501

float logicalWidth = (percent > 0) ? m_layoutStruct[i].effectiveMaxLogicalWidth * 100 / percent : tableMaxWidth;

maxPercent = std::max(logicalWidth, maxPercent);

remainingPercent -= percent;

} else

maxNonPercent += m_layoutStruct[i].effectiveMaxLogicalWidth;

}

}

if (scaleColumnsForSelf) {

if (maxNonPercent > 0)

maxNonPercent = (remainingPercent > 0) ? maxNonPercent * 100 / remainingPercent : tableMaxWidth;

m_scaledWidthFromPercentColumns = std::min(LayoutUnit(tableMaxWidth), LayoutUnit(std::max(maxPercent, maxNonPercent)));

if (m_scaledWidthFromPercentColumns > maxWidth && shouldScaleColumnsForParent(*m_table))

maxWidth = m_scaledWidthFromPercentColumns;

}

if (intrinsics == TableIntrinsics::ForKeyword && m_layoutStruct.isEmpty()) {

ASSERT(!minWidth);

ASSERT(!maxWidth);

minWidth = m_table->bordersPaddingAndSpacingInRowDirection();

maxWidth = minWidth;

}

maxWidth = std::max(maxWidth, LayoutUnit(spanMaxLogicalWidth));

{

if (auto fixedTableLogicalWidth = m_table->style().logicalWidth().tryFixed(); fixedTableLogicalWidth && fixedTableLogicalWidth->isPositive()) {

LayoutUnit minContentWidth = minWidth;

LayoutUnit tableFixedWidth = m_table->overridingBorderBoxLogicalWidth().value_or(LayoutUnit { fixedTableLogicalWidth->resolveZoom(m_table->style().usedZoomForLength()) });

LayoutUnit clampedWidth = std::max(minContentWidth, std::max(minWidth, tableFixedWidth));

minWidth = clampedWidth;

maxWidth = clampedWidth;

if (auto fixedMaxWidth = m_table->style().logicalMaxWidth().tryFixed()) {

LayoutUnit maxAllowedWidth { fixedMaxWidth->resolveZoom(m_table->style().usedZoomForLength()) };

minWidth = std::min(minWidth, maxAllowedWidth);

minWidth = std::max(minWidth, minContentWidth);

maxWidth = minWidth;

}

}

{

float maxLogicalWidth = 0;

size_t nEffCols = m_layoutStruct.size();

float spacingInRowDirection = m_table->hBorderSpacing();

for (size_t i = 0; i < nEffCols; ++i) {

m_layoutStruct[i].effectiveLogicalWidth = m_layoutStruct[i].logicalWidth;

m_layoutStruct[i].effectiveMinLogicalWidth = m_layoutStruct[i].minLogicalWidth;

m_layoutStruct[i].effectiveMaxLogicalWidth = m_layoutStruct[i].maxLogicalWidth;

}

for (size_t i = 0; i < m_spanCells.size(); ++i) {

RenderTableCell* cell = m_spanCells[i];

if (!cell)

break;

unsigned span = cell->colSpan();

auto [ cellLogicalWidth, cellUsedZoom ] = cell->styleOrColLogicalWidth();

if (cellLogicalWidth.isKnownZero())

cellLogicalWidth = CSS::Keyword::Auto { };

unsigned effCol = m_table->colToEffCol(cell->col());

size_t lastCol = effCol;

if (cell->isOrthogonal())

cell->clearIntrinsicPadding();

float cellMinLogicalWidth = cell->minLogicalWidthForColumnSizing() + spacingInRowDirection;

float cellMaxLogicalWidth = cell->maxLogicalWidthForColumnSizing() + spacingInRowDirection;

float totalPercent = 0;

float spanMinLogicalWidth = 0;

float spanMaxLogicalWidth = 0;

bool allColsArePercent = true;

bool allColsAreFixed = true;

bool haveAuto = false;

bool spanHasEmptyCellsOnly = true;

float fixedWidth = 0;

while (lastCol < nEffCols && span > 0) {

auto& columnLayout = m_layoutStruct[lastCol];

auto fallbackCase = [&] {

// If the column is a percentage width, do not let the spanning cell overwrite the

// width value. This caused a mis-rendering on amazon.com.

// Sample snippet:

// <table border=2 width=100%><

// <tr><td>1</td><td colspan=2>2-3</tr>

// <tr><td>1</td><td colspan=2 width=100%>2-3</td></tr>

// </table>

if (auto percentageEffectiveLogicalWidth = columnLayout.effectiveLogicalWidth.tryPercentage())

totalPercent += percentageEffectiveLogicalWidth->value;

else {

columnLayout.effectiveLogicalWidth = CSS::Keyword::Auto { };

allColsArePercent = false;

}

allColsAreFixed = false;

};

WTF::switchOn(columnLayout.logicalWidth,

[&](const Style::PreferredSize::Percentage& percentage) {

totalPercent += percentage.value;

allColsAreFixed = false;

},

[&](const Style::PreferredSize::Fixed& fixed) {

if (fixed.isPositive()) {

fixedWidth += fixed.resolveZoom(Style::ZoomFactor { columnLayout.usedZoom });

allColsArePercent = false;

// IE resets effWidth to Auto here, but this breaks the konqueror about page and seems to be some bad

// legacy behavior anyway. mozilla doesn't do this so I decided we don't neither.

return;

}

haveAuto = true;

fallbackCase();

},

[&](const CSS::Keyword::Auto&) {

haveAuto = true;

fallbackCase();

},

[&](const auto&) {

fallbackCase();

}

);

if (!columnLayout.emptyCellsOnly)

spanHasEmptyCellsOnly = false;

span -= m_table->spanOfEffCol(lastCol);

spanMinLogicalWidth += columnLayout.effectiveMinLogicalWidth;

spanMaxLogicalWidth += columnLayout.effectiveMaxLogicalWidth;

lastCol++;

cellMinLogicalWidth -= spacingInRowDirection;

cellMaxLogicalWidth -= spacingInRowDirection;

}

// adjust table max width if needed

if (auto percentageCellLogicalWidth = cellLogicalWidth.tryPercentage()) {

if (totalPercent > percentageCellLogicalWidth->value || allColsArePercent) {

// can't satisfy this condition, treat as variable

cellLogicalWidth = CSS::Keyword::Auto { };

} else {

maxLogicalWidth = std::max(maxLogicalWidth, std::max(spanMaxLogicalWidth, cellMaxLogicalWidth) * 100 / percentageCellLogicalWidth->value);

// all non percent columns in the span get percent values to sum up correctly.

float percentMissing = percentageCellLogicalWidth->value - totalPercent;

float totalWidth = 0;

for (unsigned pos = effCol; pos < lastCol; ++pos) {

if (!m_layoutStruct[pos].effectiveLogicalWidth.isPercentOrCalculated())

totalWidth += m_layoutStruct[pos].effectiveMaxLogicalWidth;

}

for (unsigned pos = effCol; pos < lastCol; ++pos) {

if (!m_layoutStruct[pos].effectiveLogicalWidth.isPercentOrCalculated()) {

// Handle the case when there's only one cell with 'width: percent' and it's empty.

auto percent = percentMissing * (totalWidth ? m_layoutStruct[pos].effectiveMaxLogicalWidth / totalWidth : 1);

totalWidth -= m_layoutStruct[pos].effectiveMaxLogicalWidth;

percentMissing -= percent;

if (percent > 0)

m_layoutStruct[pos].effectiveLogicalWidth = Style::PreferredSize::Percentage { percent };

else

m_layoutStruct[pos].effectiveLogicalWidth = CSS::Keyword::Auto { };

}

if (totalWidth <= 0)

break;

}

}

}

// make sure minWidth and maxWidth of the spanning cell are honored

if (cellMinLogicalWidth > spanMinLogicalWidth) {

if (allColsAreFixed) {

for (unsigned pos = effCol; fixedWidth > 0 && pos < lastCol; ++pos) {

// NOTE: The unchecked use of tryFixed() here is allowed because `allColsAreFixed` is true.

// FIXME: Find a more type safe way to enforce this invariant.

auto fixedLogicalWidth = m_layoutStruct[pos].logicalWidth.tryFixed()->resolveZoom(Style::ZoomFactor { m_layoutStruct[effCol].usedZoom });

float cellLogicalWidth = std::max(m_layoutStruct[pos].effectiveMinLogicalWidth, cellMinLogicalWidth * fixedLogicalWidth / fixedWidth);

fixedWidth -= fixedLogicalWidth;

cellMinLogicalWidth -= cellLogicalWidth;

m_layoutStruct[pos].effectiveMinLogicalWidth = cellLogicalWidth;

}

} else if (allColsArePercent) {

// In this case, we just split the colspan's min and max widths following the percentage.

#if ASSERT_ENABLED

float allocatedMinLogicalWidth = 0;

#endif

float allocatedMaxLogicalWidth = 0;

for (unsigned pos = effCol; pos < lastCol; ++pos) {

ASSERT(m_layoutStruct[pos].logicalWidth.isPercent() || m_layoutStruct[pos].effectiveLogicalWidth.isPercent());

// |allColsArePercent| means that either the logicalWidth *or* the effectiveLogicalWidth are percents, handle both of them here.

auto percentageLogicalWidth = m_layoutStruct[pos].logicalWidth.tryPercentage();

auto percentageEffectiveLogicalWidth = m_layoutStruct[pos].effectiveLogicalWidth.tryPercentage();

ASSERT(percentageLogicalWidth || percentageEffectiveLogicalWidth);

float percent = percentageLogicalWidth ? percentageLogicalWidth->value : percentageEffectiveLogicalWidth->value;

float columnMinLogicalWidth = percent * cellMinLogicalWidth / totalPercent;

float columnMaxLogicalWidth = percent * cellMaxLogicalWidth / totalPercent;

m_layoutStruct[pos].effectiveMinLogicalWidth = std::max(m_layoutStruct[pos].effectiveMinLogicalWidth, columnMinLogicalWidth);

m_layoutStruct[pos].effectiveMaxLogicalWidth = columnMaxLogicalWidth;

#if ASSERT_ENABLED

allocatedMinLogicalWidth += columnMinLogicalWidth;

#endif

allocatedMaxLogicalWidth += columnMaxLogicalWidth;

}

ASSERT(allocatedMinLogicalWidth < cellMinLogicalWidth || WTF::areEssentiallyEqual(allocatedMinLogicalWidth, cellMinLogicalWidth));

ASSERT(allocatedMaxLogicalWidth < cellMaxLogicalWidth || WTF::areEssentiallyEqual(allocatedMaxLogicalWidth, cellMaxLogicalWidth));

cellMaxLogicalWidth -= allocatedMaxLogicalWidth;

} else if (!allColsAreFixed && fixedWidth <= 0 && totalPercent > 0 && haveAuto) {

// This branch handles the case where a percentage colspan cell has already

// converted AUTO columns to effective percentages. We need to verify that:

// 1. There are columns with original logicalWidth = auto.

// 2. Those auto columns were converted to effective percentages.

bool hasConvertedAutoColumns = false;

for (unsigned pos = effCol; pos < lastCol; ++pos) {

// Check if this was originally an AUTO column that got converted to percentage.

if (m_layoutStruct[pos].logicalWidth.isAuto() && m_layoutStruct[pos].effectiveLogicalWidth.isPercentOrCalculated()) {

hasConvertedAutoColumns = true;

break;

}

}

// Additionally, verify the current cell is NOT a percentage cell (percentage cells are handled earlier).

bool currentCellIsNotPercentage = !cellLogicalWidth.isPercentOrCalculated();

// Only use percentage-based distribution if auto columns were actually converted AND we're processing a non-percentage colspan

if (hasConvertedAutoColumns && currentCellIsNotPercentage) {

// By this point, the earlier code has converted auto columns to effectiveLogicalWidth percentages,

// so we can use the same percentage-based distribution as the allColsArePercent case.

#if ASSERT_ENABLED

float allocatedMinLogicalWidth = 0;

#endif

float allocatedMaxLogicalWidth = 0;

// Calculate total effective percent (includes both original percent columns and converted auto columns)

float totalEffectivePercent = 0;

for (unsigned pos = effCol; pos < lastCol; ++pos) {

if (auto percentageEffectiveLogicalWidth = m_layoutStruct[pos].effectiveLogicalWidth.tryPercentage())

totalEffectivePercent += percentageEffectiveLogicalWidth->value;

}

// If all columns now have effective percentages, distribute accordingly

if (totalEffectivePercent > 0) {

for (unsigned pos = effCol; pos < lastCol; ++pos) {

auto percentageEffectiveLogicalWidth = m_layoutStruct[pos].effectiveLogicalWidth.tryPercentage();

if (percentageEffectiveLogicalWidth) {

float percent = percentageEffectiveLogicalWidth->value;

float columnMinLogicalWidth = percent * cellMinLogicalWidth / totalEffectivePercent;

float columnMaxLogicalWidth = percent * cellMaxLogicalWidth / totalEffectivePercent;

m_layoutStruct[pos].effectiveMinLogicalWidth = std::max(m_layoutStruct[pos].effectiveMinLogicalWidth, columnMinLogicalWidth);

m_layoutStruct[pos].effectiveMaxLogicalWidth = columnMaxLogicalWidth;

#if ASSERT_ENABLED

allocatedMinLogicalWidth += columnMinLogicalWidth;

#endif

allocatedMaxLogicalWidth += columnMaxLogicalWidth;

}

}

ASSERT(allocatedMinLogicalWidth < cellMinLogicalWidth || WTF::areEssentiallyEqual(allocatedMinLogicalWidth, cellMinLogicalWidth));

ASSERT(allocatedMaxLogicalWidth < cellMaxLogicalWidth || WTF::areEssentiallyEqual(allocatedMaxLogicalWidth, cellMaxLogicalWidth));

cellMaxLogicalWidth -= allocatedMaxLogicalWidth;

}

}

} else {

float remainingMaxLogicalWidth = spanMaxLogicalWidth;

float remainingMinLogicalWidth = spanMinLogicalWidth;

// Give min to variable first, to fixed second, and to others third.

for (unsigned pos = effCol; remainingMaxLogicalWidth >= 0 && pos < lastCol; ++pos) {

if (auto fixedLogicalWidth = m_layoutStruct[pos].logicalWidth.tryFixed(); fixedLogicalWidth && haveAuto && fixedWidth <= cellMinLogicalWidth) {

float colMinLogicalWidth = std::max(m_layoutStruct[pos].effectiveMinLogicalWidth, fixedLogicalWidth->resolveZoom(Style::ZoomFactor { m_layoutStruct[pos].usedZoom }));

fixedWidth -= fixedLogicalWidth->resolveZoom(Style::ZoomFactor { m_layoutStruct[pos].usedZoom });

remainingMinLogicalWidth -= m_layoutStruct[pos].effectiveMinLogicalWidth;

remainingMaxLogicalWidth -= m_layoutStruct[pos].effectiveMaxLogicalWidth;

cellMinLogicalWidth -= colMinLogicalWidth;

m_layoutStruct[pos].effectiveMinLogicalWidth = colMinLogicalWidth;

}

}

for (unsigned pos = effCol; remainingMaxLogicalWidth >= 0 && pos < lastCol && remainingMinLogicalWidth < cellMinLogicalWidth; ++pos) {

if (!(m_layoutStruct[pos].logicalWidth.isFixed() && haveAuto && fixedWidth <= cellMinLogicalWidth)) {

float colMinLogicalWidth = std::max(m_layoutStruct[pos].effectiveMinLogicalWidth, remainingMaxLogicalWidth ? cellMinLogicalWidth * m_layoutStruct[pos].effectiveMaxLogicalWidth / remainingMaxLogicalWidth : cellMinLogicalWidth);

colMinLogicalWidth = std::min(m_layoutStruct[pos].effectiveMinLogicalWidth + (cellMinLogicalWidth - remainingMinLogicalWidth), colMinLogicalWidth);

remainingMaxLogicalWidth -= m_layoutStruct[pos].effectiveMaxLogicalWidth;

remainingMinLogicalWidth -= m_layoutStruct[pos].effectiveMinLogicalWidth;

cellMinLogicalWidth -= colMinLogicalWidth;

m_layoutStruct[pos].effectiveMinLogicalWidth = colMinLogicalWidth;

}

}

}

}

if (!cellLogicalWidth.isPercentOrCalculated()) {

if (cellMaxLogicalWidth > spanMaxLogicalWidth) {

for (unsigned pos = effCol; spanMaxLogicalWidth >= 0 && pos < lastCol; ++pos) {

float colMaxLogicalWidth = std::max(m_layoutStruct[pos].effectiveMaxLogicalWidth, spanMaxLogicalWidth ? cellMaxLogicalWidth * m_layoutStruct[pos].effectiveMaxLogicalWidth / spanMaxLogicalWidth : cellMaxLogicalWidth);

spanMaxLogicalWidth -= m_layoutStruct[pos].effectiveMaxLogicalWidth;

cellMaxLogicalWidth -= colMaxLogicalWidth;

m_layoutStruct[pos].effectiveMaxLogicalWidth = colMaxLogicalWidth;

}

}

} else {

for (unsigned pos = effCol; pos < lastCol; ++pos)

m_layoutStruct[pos].maxLogicalWidth = std::max(m_layoutStruct[pos].maxLogicalWidth, m_layoutStruct[pos].minLogicalWidth);

}

// treat span ranges consisting of empty cells only as if they had content

if (spanHasEmptyCellsOnly) {

for (unsigned pos = effCol; pos < lastCol; ++pos)

m_layoutStruct[pos].emptyCellsOnly = false;

}

}

m_effectiveLogicalWidthDirty = false;

return std::min<float>(maxLogicalWidth, tableMaxWidth);

{

ASSERT_ARG(cell, cell && cell->colSpan() != 1);

if (!cell || cell->colSpan() == 1)

return;

unsigned size = m_spanCells.size();

if (!size || m_spanCells[size-1] != 0) {

m_spanCells.grow(size + 10);

for (unsigned i = 0; i < 10; i++)

m_spanCells[size + i] = 0;

size += 10;

}

// add them in sort. This is a slow algorithm, and a binary search or a fast sorting after collection would be better

unsigned pos = 0;

unsigned span = cell->colSpan();

while (pos < m_spanCells.size() && m_spanCells[pos] && span > m_spanCells[pos]->colSpan())

++pos;

memmoveSpan(m_spanCells.mutableSpan().subspan(pos + 1), m_spanCells.subspan(pos, size - (pos + 1)));

m_spanCells[pos] = cell;

{

// table layout based on the values collected in the layout structure.

float tableLogicalWidth = m_table->logicalWidth() - m_table->bordersPaddingAndSpacingInRowDirection();

float available = tableLogicalWidth;

size_t nEffCols = m_table->numEffCols();

// 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 (nEffCols != m_layoutStruct.size()) {

fullRecalc();

// FIXME: Table layout shouldn't modify our table structure (but does due to columns and column-groups).

nEffCols = m_table->numEffCols();

}

if (m_effectiveLogicalWidthDirty)

calcEffectiveLogicalWidth();

bool havePercent = false;

int numFixed = 0;

size_t numberOfNonEmptyAuto = 0;

std::optional<float> totalAuto;

float totalFixed = 0;

float totalPercent = 0;

float allocAuto = 0;

unsigned numAutoEmptyCellsOnly = 0;

// fill up every cell with its minWidth

for (size_t i = 0; i < nEffCols; ++i) {

// Check if this column is collapsed

if (CheckedPtr colElement = m_table->colElement(i); colElement && colElement->style().visibility() == Visibility::Collapse) {

m_layoutStruct[i].computedLogicalWidth = 0;

continue;

}

float cellLogicalWidth = m_layoutStruct[i].effectiveMinLogicalWidth;

m_layoutStruct[i].computedLogicalWidth = cellLogicalWidth;

available -= cellLogicalWidth;

WTF::switchOn(m_layoutStruct[i].effectiveLogicalWidth,

[&](const Style::PreferredSize::Fixed&) {

numFixed++;

totalFixed += m_layoutStruct[i].effectiveMaxLogicalWidth;

},

[&](const Style::PreferredSize::Percentage& percentageLogicalWidth) {

havePercent = true;

totalPercent += percentageLogicalWidth.value;

},

[&](const CSS::Keyword::Auto&) {

if (m_layoutStruct[i].emptyCellsOnly)

numAutoEmptyCellsOnly++;

else {

++numberOfNonEmptyAuto;

totalAuto = totalAuto.value_or(0.f) + m_layoutStruct[i].effectiveMaxLogicalWidth;

allocAuto += cellLogicalWidth;

}

},

[&](const auto&) { }

);

}

// allocate width to percent cols

if (available > 0 && havePercent) {

for (size_t i = 0; i < nEffCols; ++i) {

if (CheckedPtr colElement = m_table->colElement(i); colElement && colElement->style().visibility() == Visibility::Collapse)

continue;

auto& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;

if (logicalWidth.isPercentOrCalculated()) {

float cellLogicalWidth = std::max<float>(m_layoutStruct[i].effectiveMinLogicalWidth, Style::evaluateMinimum<float>(logicalWidth, tableLogicalWidth, Style::ZoomFactor { m_layoutStruct[i].usedZoom }));

available += m_layoutStruct[i].computedLogicalWidth - cellLogicalWidth;

m_layoutStruct[i].computedLogicalWidth = cellLogicalWidth;

}

}

if (totalPercent > 100) {

// remove overallocated space from the last columns

float excess = tableLogicalWidth * (totalPercent - 100) / 100;

for (unsigned i = nEffCols; i; ) {

--i;

if (CheckedPtr colElement = m_table->colElement(i); colElement && colElement->style().visibility() == Visibility::Collapse)

continue;

if (m_layoutStruct[i].effectiveLogicalWidth.isPercentOrCalculated()) {

float cellLogicalWidth = m_layoutStruct[i].computedLogicalWidth;

float reduction = std::min(cellLogicalWidth, excess);

// the lines below might look inconsistent, but that's the way it's handled in mozilla

excess -= reduction;

float newLogicalWidth = std::max(m_layoutStruct[i].effectiveMinLogicalWidth, cellLogicalWidth - reduction);

available += cellLogicalWidth - newLogicalWidth;

m_layoutStruct[i].computedLogicalWidth = newLogicalWidth;

}

}

}

}

// then allocate width to fixed cols

if (available > 0) {

for (size_t i = 0; i < nEffCols; ++i) {

if (CheckedPtr colElement = m_table->colElement(i); colElement && colElement->style().visibility() == Visibility::Collapse)

continue;

auto& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;

auto usedZoom = m_layoutStruct[i].usedZoom;

if (auto fixedLogicalWidth = logicalWidth.tryFixed(); fixedLogicalWidth && fixedLogicalWidth->resolveZoom(Style::ZoomFactor { usedZoom }) > m_layoutStruct[i].computedLogicalWidth) {

available += m_layoutStruct[i].computedLogicalWidth - fixedLogicalWidth->resolveZoom(Style::ZoomFactor { usedZoom });

m_layoutStruct[i].computedLogicalWidth = fixedLogicalWidth->resolveZoom(Style::ZoomFactor { usedZoom });

}

}

}

// now satisfy variable

if (available > 0 && numberOfNonEmptyAuto) {

ASSERT(totalAuto);

available += allocAuto; // this gets redistributed.

auto equalWidthForZeroLengthColumns = std::optional<float> { };

if (!*totalAuto) {

// All columns in this table are (non-empty)zero length with 'width: auto'.

equalWidthForZeroLengthColumns = available / numberOfNonEmptyAuto;

}

for (size_t i = 0; i < nEffCols; ++i) {

if (CheckedPtr colElement = m_table->colElement(i); colElement && colElement->style().visibility() == Visibility::Collapse)

continue;

auto& column = m_layoutStruct[i];

if (!column.effectiveLogicalWidth.isAuto() || column.emptyCellsOnly)

continue;

auto columnWidthCandidate = equalWidthForZeroLengthColumns ? *equalWidthForZeroLengthColumns : available * column.effectiveMaxLogicalWidth / *totalAuto;

column.computedLogicalWidth = std::max(column.computedLogicalWidth, columnWidthCandidate);

available -= column.computedLogicalWidth;

if (!equalWidthForZeroLengthColumns) {

*totalAuto -= column.effectiveMaxLogicalWidth;

if (*totalAuto <= 0)

break;

}

}

}

// spread over fixed columns

if (available > 0 && numFixed) {

for (size_t i = 0; i < nEffCols; ++i) {

if (CheckedPtr colElement = m_table->colElement(i); colElement && colElement->style().visibility() == Visibility::Collapse)

continue;

auto& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;

if (logicalWidth.isFixed()) {

float cellLogicalWidth = available * m_layoutStruct[i].effectiveMaxLogicalWidth / totalFixed;

available -= cellLogicalWidth;

totalFixed -= m_layoutStruct[i].effectiveMaxLogicalWidth;

m_layoutStruct[i].computedLogicalWidth += cellLogicalWidth;

}

}

}

// spread over percent columns

if (available > 0 && m_hasPercent && totalPercent < 100) {

for (size_t i = 0; i < nEffCols; ++i) {

if (CheckedPtr colElement = m_table->colElement(i); colElement && colElement->style().visibility() == Visibility::Collapse)

continue;

auto& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;

if (auto percentageLogicalWidth = logicalWidth.tryPercentage()) {

float cellLogicalWidth = available * percentageLogicalWidth->value / totalPercent;

available -= cellLogicalWidth;

totalPercent -= percentageLogicalWidth->value;

m_layoutStruct[i].computedLogicalWidth += cellLogicalWidth;

if (!available || !totalPercent)

break;

}

}

}

// spread over the rest

if (available > 0 && nEffCols > numAutoEmptyCellsOnly) {

unsigned total = nEffCols - numAutoEmptyCellsOnly;

// Count collapsed columns to subtract from total

unsigned numCollapsed = 0;

for (size_t i = 0; i < nEffCols; ++i) {

if (CheckedPtr colElement = m_table->colElement(i); colElement && colElement->style().visibility() == Visibility::Collapse)

numCollapsed++;

}

total -= numCollapsed;

// still have some width to spread

for (unsigned i = nEffCols; i && total > 0; ) {

--i;

if (CheckedPtr colElement = m_table->colElement(i); colElement && colElement->style().visibility() == Visibility::Collapse)

continue;

// variable columns with empty cells only don't get any width

if (m_layoutStruct[i].effectiveLogicalWidth.isAuto() && m_layoutStruct[i].emptyCellsOnly)

continue;

float cellLogicalWidth = available / total;

available -= cellLogicalWidth;

total--;

m_layoutStruct[i].computedLogicalWidth += cellLogicalWidth;

}

}

if (available > 0 && numAutoEmptyCellsOnly && nEffCols == numAutoEmptyCellsOnly) {

// All columns in this table are empty with 'width: auto'.

auto equalWidthForColumns = available / numAutoEmptyCellsOnly;

for (size_t i = 0; i < nEffCols; ++i) {

if (CheckedPtr colElement = m_table->colElement(i); colElement && colElement->style().visibility() == Visibility::Collapse)

continue;

auto& column = m_layoutStruct[i];

column.computedLogicalWidth = equalWidthForColumns;

available -= column.computedLogicalWidth;

}

}

// If we have over-allocated, reduce every cell according to the difference between desired width and min-width

// this seems to produce to the pixel exact results with IE. Wonder if some of this also holds for width distributing.

// Need to reduce cells with the following prioritization:

// This is basically the reverse of how we grew the cells.

if (available < 0)

available = shrinkCellWidthForType<CSS::Keyword::Auto>(available);

if (available < 0)

available = shrinkCellWidthForType<Style::PreferredSize::Fixed>(available);

if (available < 0)

available = shrinkCellWidthForType<Style::PreferredSize::Percentage>(available);

LayoutUnit pos;

for (size_t i = 0; i < nEffCols; ++i) {

m_table->setColumnPosition(i, pos);

if (CheckedPtr colElement = m_table->colElement(i); colElement && colElement->style().visibility() == Visibility::Collapse) {

// Don't add width or spacing for collapsed columns.

continue;

}

pos += LayoutUnit::fromFloatCeil(m_layoutStruct[i].computedLogicalWidth) + m_table->hBorderSpacing();

}

m_table->setColumnPosition(m_table->columnPositions().size() - 1, pos);

{

unsigned nEffCols = m_table->numEffCols();

float logicalWidthBeyondMin = 0;

for (unsigned i = nEffCols; i; ) {

--i;

auto& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;

if (WTF::holdsAlternative<T>(logicalWidth))

logicalWidthBeyondMin += m_layoutStruct[i].computedLogicalWidth - m_layoutStruct[i].effectiveMinLogicalWidth;

}

for (unsigned i = nEffCols; i && logicalWidthBeyondMin > 0; ) {

--i;

auto& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;

if (WTF::holdsAlternative<T>(logicalWidth)) {

float minMaxDiff = m_layoutStruct[i].computedLogicalWidth - m_layoutStruct[i].effectiveMinLogicalWidth;

float reduce = available * minMaxDiff / logicalWidthBeyondMin;

m_layoutStruct[i].computedLogicalWidth += reduce;

available -= reduce;

logicalWidthBeyondMin -= minMaxDiff;

if (available >= 0)

break;

}

}

return available;