You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdelibs/khtml/rendering/table_layout.cpp

1194 lines
39 KiB

/*
* This file is part of the HTML rendering engine for KDE.
*
* Copyright (C) 2002 Lars Knoll (knoll@kde.org)
* (C) 2002 Dirk Mueller (mueller@kde.org)
*
* 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 "table_layout.h"
#include "render_table.h"
#include <kglobal.h>
using namespace khtml;
// #define DEBUG_LAYOUT
/*
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.
_____________________________________________________
This is not quite true when comparing to IE. IE always honors
table-layout:fixed and treats a variable table width as 100%. Makes
a lot of sense, and is implemented here the same way.
*/
FixedTableLayout::FixedTableLayout( RenderTable *table )
: TableLayout ( table )
{
}
FixedTableLayout::~FixedTableLayout()
{
}
int FixedTableLayout::calcWidthArray()
{
int usedWidth = 0;
// iterate over all <col> elements
RenderObject *child = table->firstChild();
int cCol = 0;
int nEffCols = table->numEffCols();
width.resize( nEffCols );
width.fill( Length( Variable ) );
#ifdef DEBUG_LAYOUT
qDebug("FixedTableLayout::calcWidthArray()" );
qDebug(" col elements:");
#endif
Length grpWidth;
while ( child ) {
if ( child->isTableCol() ) {
RenderTableCol *col = static_cast<RenderTableCol *>(child);
int span = col->span();
if ( col->firstChild() ) {
grpWidth = col->style()->width();
} else {
Length w = col->style()->width();
if ( w.isVariable() )
w = grpWidth;
int effWidth = 0;
if ( w.isFixed() && w.value() > 0 ) {
effWidth = w.value();
effWidth = KMIN( effWidth, 32760 );
}
#ifdef DEBUG_LAYOUT
qDebug(" col element: effCol=%d, span=%d: %d w=%d type=%d",
cCol, span, effWidth, w.value(), w.type());
#endif
int usedSpan = 0;
int i = 0;
while ( usedSpan < span ) {
if( cCol + i >= nEffCols ) {
table->appendColumn( span - usedSpan );
nEffCols++;
width.resize( nEffCols );
width[nEffCols-1] = Length();
}
int eSpan = table->spanOfEffCol( cCol+i );
if ( (w.isFixed() || w.isPercent()) && w.value() > 0 ) {
width[cCol+i] = Length( w.value() * eSpan, w.type() );
usedWidth += effWidth * eSpan;
#ifdef DEBUG_LAYOUT
qDebug(" setting effCol %d (span=%d) to width %d(type=%d)",
cCol+i, eSpan, width[cCol+i].value(), width[cCol+i].type() );
#endif
}
usedSpan += eSpan;
i++;
}
cCol += i;
}
} else {
break;
}
RenderObject *next = child->firstChild();
if ( !next )
next = child->nextSibling();
if ( !next && child->parent()->isTableCol() ) {
next = child->parent()->nextSibling();
grpWidth = Length();
}
child = next;
}
#ifdef DEBUG_LAYOUT
qDebug(" first row:");
#endif
// iterate over the first row in case some are unspecified.
RenderTableSection *section = table->head;
if ( !section )
section = table->firstBody;
if ( !section )
section = table->foot;
if ( section && section->firstChild() ) {
cCol = 0;
// get the first cell in the first row
child = section->firstChild()->firstChild();
while ( child ) {
if ( child->isTableCell() ) {
RenderTableCell *cell = static_cast<RenderTableCell *>(child);
Length w = cell->styleOrColWidth();
int span = cell->colSpan();
int effWidth = 0;
if ( (w.isFixed() || w.isPercent()) && w.value() > 0 ) {
effWidth = w.value();
effWidth = kMin( effWidth, 32760 );
}
#ifdef DEBUG_LAYOUT
qDebug(" table cell: effCol=%d, span=%d: %d", cCol, span, effWidth);
#endif
int usedSpan = 0;
int i = 0;
while ( usedSpan < span ) {
Q_ASSERT( cCol + i < nEffCols );
int eSpan = table->spanOfEffCol( cCol+i );
// only set if no col element has already set it.
if ( width[cCol+i].isVariable() && !w.isVariable() ) {
width[cCol+i] = Length( w.value()*eSpan, w.type() );
usedWidth += effWidth*eSpan;
#ifdef DEBUG_LAYOUT
qDebug(" setting effCol %d (span=%d) to width %d(type=%d)",
cCol+i, eSpan, width[cCol+i].value(), width[cCol+i].type() );
#endif
}
#ifdef DEBUG_LAYOUT
else {
qDebug(" width of col %d already defined (span=%d)", cCol, table->spanOfEffCol( cCol ) );
}
#endif
usedSpan += eSpan;
i++;
}
cCol += i;
} else {
Q_ASSERT( false );
}
child = child->nextSibling();
}
}
return usedWidth;
}
void FixedTableLayout::calcMinMaxWidth()
{
// we might want to wait until we have all of the first row before
// layouting for the first time.
// only need to calculate the minimum width as the sum of the
// cols/cells with a fixed width.
//
// The maximum width is kMax( minWidth, tableWidth ) if table
// width is fixed. If table width is percent, we set maxWidth to
// unlimited.
int bs = table->bordersPaddingAndSpacing();
int tableWidth = 0;
if (table->style()->width().isFixed()) {
tableWidth = table->calcBoxWidth(table->style()->width().value());
}
int mw = calcWidthArray() + bs;
table->m_minWidth = kMin( kMax( mw, tableWidth ), 0x7fff );
table->m_maxWidth = table->m_minWidth;
if ( !tableWidth ) {
bool haveNonFixed = false;
for ( unsigned int i = 0; i < width.size(); i++ ) {
if ( !width[i].isFixed() ) {
haveNonFixed = true;
break;
}
}
if ( haveNonFixed )
table->m_maxWidth = 0x7fff;
}
#ifdef DEBUG_LAYOUT
qDebug("FixedTableLayout::calcMinMaxWidth: minWidth=%d, maxWidth=%d", table->m_minWidth, table->m_maxWidth );
#endif
}
void FixedTableLayout::layout()
{
int tableWidth = table->width() - table->bordersPaddingAndSpacing();
int available = tableWidth;
int nEffCols = table->numEffCols();
#ifdef DEBUG_LAYOUT
qDebug("FixedTableLayout::layout: tableWidth=%d, numEffCols=%d", tableWidth, nEffCols);
#endif
QMemArray<int> calcWidth;
calcWidth.resize( nEffCols );
calcWidth.fill( -1 );
// first assign fixed width
for ( int i = 0; i < nEffCols; i++ ) {
if ( width[i].isFixed() ) {
calcWidth[i] = width[i].value();
available -= width[i].value();
}
}
// assign percent width
if ( available > 0 ) {
int totalPercent = 0;
for ( int i = 0; i < nEffCols; i++ )
if ( width[i].isPercent() )
totalPercent += width[i].value();
// calculate how much to distribute to percent cells.
int base = tableWidth * totalPercent / 100;
if ( base > available )
base = available;
#ifdef DEBUG_LAYOUT
qDebug("FixedTableLayout::layout: assigning percent width, base=%d, totalPercent=%d", base, totalPercent);
#endif
for ( int i = 0; available > 0 && i < nEffCols; i++ ) {
if ( width[i].isPercent() ) {
// totalPercent may be 0 below if all %-width specifed are 0%. (#172557)
int w = totalPercent ? base * width[i].value() / totalPercent : 0;
available -= w;
calcWidth[i] = w;
}
}
}
// assign variable width
if ( available > 0 ) {
int totalVariable = 0;
for ( int i = 0; i < nEffCols; i++ )
if ( width[i].isVariable() )
totalVariable++;
for ( int i = 0; available > 0 && i < nEffCols; i++ ) {
if ( width[i].isVariable() ) {
// totalVariable may be 0 below if all the variable widths specified are 0.
int w = totalVariable ? available / totalVariable : 0;
available -= w;
calcWidth[i] = w;
totalVariable--;
}
}
}
for ( int i = 0; i < nEffCols; i++ )
if ( calcWidth[i] < 0 )
calcWidth[i] = 0; // IE gives min 1 px...
// spread extra space over columns
if ( available > 0 ) {
int total = nEffCols;
// still have some width to spread
int i = nEffCols;
while ( i-- ) {
int w = available / total;
available -= w;
total--;
calcWidth[i] += w;
}
}
int pos = 0;
int hspacing = table->borderHSpacing();
for ( int i = 0; i < nEffCols; i++ ) {
#ifdef DEBUG_LAYOUT
qDebug("col %d: %d (width %d)", i, pos, calcWidth[i] );
#endif
table->columnPos[i] = pos;
pos += calcWidth[i] + hspacing;
}
table->columnPos[table->columnPos.size()-1] = pos;
}
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
AutoTableLayout::AutoTableLayout( RenderTable* table )
: TableLayout( table )
{
percentagesDirty = true;
effWidthDirty = true;
total_percent = 0;
hasPercent = false;
}
AutoTableLayout::~AutoTableLayout()
{
}
/* recalculates the full structure needed to do layouting and minmax calculations.
This is usually calculated on the fly, but needs to be done fully when table cells change
dynamically
*/
void AutoTableLayout::recalcColumn( int effCol )
{
Layout &l = layoutStruct[effCol];
RenderObject *child = table->firstChild();
// first we iterate over all rows.
RenderTableCell *fixedContributor = 0;
RenderTableCell *maxContributor = 0;
while ( child ) {
if ( child->isTableSection() ) {
RenderTableSection *section = static_cast<RenderTableSection *>(child);
int numRows = section->numRows();
RenderTableCell *last = 0;
for ( int i = 0; i < numRows; i++ ) {
RenderTableCell *cell = section->cellAt( i, effCol );
if ( cell == (RenderTableCell *)-1 )
continue;
if ( cell && cell->colSpan() == 1 ) {
// A cell originates in this column. Ensure we have
// a min/max width of at least 1px for this column now.
l.minWidth = kMax(int( l.minWidth ), 1);
l.maxWidth = kMax(int( l.maxWidth ), 1);
if ( !cell->minMaxKnown() )
cell->calcMinMaxWidth();
if ( cell->minWidth() > l.minWidth )
l.minWidth = cell->minWidth();
if ( cell->maxWidth() > l.maxWidth ) {
l.maxWidth = cell->maxWidth();
maxContributor = cell;
}
Length w = cell->styleOrColWidth();
w.l.value = kMin( 32767, kMax( 0, w.value() ) );
switch( w.type() ) {
case Fixed:
// ignore width=0
if ( w.value() > 0 && !l.width.isPercent() ) {
int wval = cell->calcBoxWidth(w.value());
if ( l.width.isFixed() ) {
// Nav/IE weirdness
if ((wval > l.width.value()) ||
((l.width.value() == wval) && (maxContributor == cell))) {
l.width.l.value = wval;
fixedContributor = cell;
}
} else {
l.width = Length( wval, Fixed );
fixedContributor = cell;
}
}
break;
case Percent:
hasPercent = true;
if ( w.value() > 0 && (!l.width.isPercent() || w.value() > l.width.value() ) )
l.width = w;
break;
case Relative:
if ( w.isVariable() || (w.isRelative() && w.value() > l.width.value() ) )
l.width = w;
default:
break;
}
} else {
if ( cell && (!effCol || section->cellAt( i, effCol-1 ) != cell) ) {
// This spanning cell originates in this column. Ensure we have
// a min/max width of at least 1px for this column now.
l.minWidth = kMax(int( l.minWidth ), 1);
l.maxWidth = kMax(int( l.maxWidth ), 1);
insertSpanCell( cell );
}
last = cell;
}
}
}
child = child->nextSibling();
}
// Nav/IE weirdness
if ( l.width.isFixed() ) {
if ( table->style()->htmlHacks()
&& (l.maxWidth > l.width.value()) && (fixedContributor != maxContributor)) {
l.width = Length();
fixedContributor = 0;
}
}
l.maxWidth = kMax(l.maxWidth, int(l.minWidth));
#ifdef DEBUG_LAYOUT
qDebug("col %d, final min=%d, max=%d, width=%d(%d)", effCol, l.minWidth, l.maxWidth, l.width.value(), l.width.type() );
#endif
// ### we need to add col elements aswell
}
void AutoTableLayout::fullRecalc()
{
percentagesDirty = true;
hasPercent = false;
effWidthDirty = true;
int nEffCols = table->numEffCols();
layoutStruct.resize( nEffCols );
layoutStruct.fill( Layout() );
spanCells.fill( 0 );
RenderObject *child = table->firstChild();
Length grpWidth;
int cCol = 0;
while ( child ) {
if ( child->isTableCol() ) {
RenderTableCol *col = static_cast<RenderTableCol *>(child);
int span = col->span();
if ( col->firstChild() ) {
grpWidth = col->style()->width();
} else {
Length w = col->style()->width();
if ( w.isVariable() )
w = grpWidth;
if ( (w.isFixed() && w.value() == 0) ||
(w.isPercent() && w.value() == 0) )
w = Length();
int cEffCol = table->colToEffCol( cCol );
#ifdef DEBUG_LAYOUT
qDebug(" col element %d (eff=%d): Length=%d(%d), span=%d, effColSpan=%d", cCol, cEffCol, w.value(), w.type(), span, table->spanOfEffCol(cEffCol ) );
#endif
if ( !w.isVariable() && span == 1 && cEffCol < nEffCols ) {
if ( table->spanOfEffCol( cEffCol ) == 1 ) {
layoutStruct[cEffCol].width = w;
if (w.isFixed() && layoutStruct[cEffCol].maxWidth < w.value())
layoutStruct[cEffCol].maxWidth = w.value();
}
}
cCol += span;
}
} else {
break;
}
RenderObject *next = child->firstChild();
if ( !next )
next = child->nextSibling();
if ( !next && child->parent()->isTableCol() ) {
next = child->parent()->nextSibling();
grpWidth = Length();
}
child = next;
}
for ( int i = 0; i < nEffCols; i++ )
recalcColumn( i );
}
static bool shouldScaleColumns(RenderTable* table)
{
// A special case. If this table is not fixed width and contained inside
// a cell, then don't bloat the maxwidth by examining percentage growth.
bool scale = true;
while (table) {
Length tw = table->style()->width();
if ((tw.isVariable() || tw.isPercent()) && !table->isPositioned()) {
RenderBlock* cb = table->containingBlock();
while (cb && !cb->isCanvas() && !cb->isTableCell() &&
cb->style()->width().isVariable() && !cb->isPositioned())
cb = cb->containingBlock();
table = 0;
if (cb && cb->isTableCell() &&
(cb->style()->width().isVariable() || cb->style()->width().isPercent())) {
if (tw.isPercent())
scale = false;
else {
RenderTableCell* cell = static_cast<RenderTableCell*>(cb);
if (cell->colSpan() > 1 || cell->table()->style()->width().isVariable())
scale = false;
else
table = cell->table();
}
}
}
else
table = 0;
}
return scale;
}
void AutoTableLayout::calcMinMaxWidth()
{
#ifdef DEBUG_LAYOUT
qDebug("AutoTableLayout::calcMinMaxWidth");
#endif
fullRecalc();
int spanMaxWidth = calcEffectiveWidth();
int minWidth = 0;
int maxWidth = 0;
int maxPercent = 0;
int maxNonPercent = 0;
int remainingPercent = 100;
for ( unsigned int i = 0; i < layoutStruct.size(); i++ ) {
minWidth += layoutStruct[i].effMinWidth;
maxWidth += layoutStruct[i].effMaxWidth;
if ( layoutStruct[i].effWidth.isPercent() ) {
int percent = kMin(layoutStruct[i].effWidth.value(), remainingPercent);
int pw = ( layoutStruct[i].effMaxWidth * 100) / kMax(percent, 1);
remainingPercent -= percent;
maxPercent = kMax( pw, maxPercent );
} else {
maxNonPercent += layoutStruct[i].effMaxWidth;
}
}
if (shouldScaleColumns(table)) {
maxNonPercent = (maxNonPercent * 100 + 50) / kMax(remainingPercent, 1);
maxWidth = kMax( maxNonPercent, maxWidth );
maxWidth = kMax( maxWidth, maxPercent );
}
maxWidth = kMax( maxWidth, spanMaxWidth );
int bs = table->bordersPaddingAndSpacing();
minWidth += bs;
maxWidth += bs;
Length tw = table->style()->width();
if ( tw.isFixed() && tw.value() > 0 ) {
int width = table->calcBoxWidth(tw.value());
minWidth = kMax( minWidth, width );
maxWidth = minWidth;
}
table->m_maxWidth = kMin(maxWidth, 0x7fff);
table->m_minWidth = kMin(minWidth, 0x7fff);
#ifdef DEBUG_LAYOUT
qDebug(" minWidth=%d, maxWidth=%d", table->m_minWidth, table->m_maxWidth );
#endif
}
/*
This method takes care of colspans.
effWidth is the same as width for cells without colspans. If we have colspans, they get modified.
*/
int AutoTableLayout::calcEffectiveWidth()
{
int tMaxWidth = 0;
unsigned int nEffCols = layoutStruct.size();
int hspacing = table->borderHSpacing();
#ifdef DEBUG_LAYOUT
qDebug("AutoTableLayout::calcEffectiveWidth for %d cols", nEffCols );
#endif
for ( unsigned int i = 0; i < nEffCols; i++ ) {
layoutStruct[i].effWidth = layoutStruct[i].width;
layoutStruct[i].effMinWidth = layoutStruct[i].minWidth;
layoutStruct[i].effMaxWidth = layoutStruct[i].maxWidth;
}
for ( unsigned int i = 0; i < spanCells.size(); i++ ) {
RenderTableCell *cell = spanCells[i];
if ( !cell || cell == (RenderTableCell *)-1 )
break;
int span = cell->colSpan();
Length w = cell->styleOrColWidth();
if ( !w.isRelative() && w.value() == 0 )
w = Length(); // make it Variable
int col = table->colToEffCol( cell->col() );
unsigned int lastCol = col;
int cMinWidth = cell->minWidth() + hspacing;
int cMaxWidth = cell->maxWidth() + hspacing;
int totalPercent = 0;
int minWidth = 0;
int maxWidth = 0;
bool allColsArePercent = true;
bool allColsAreFixed = true;
bool haveVariable = false;
int fixedWidth = 0;
#ifdef DEBUG_LAYOUT
int cSpan = span;
#endif
while ( lastCol < nEffCols && span > 0 ) {
switch( layoutStruct[lastCol].width.type() ) {
case Percent:
totalPercent += layoutStruct[lastCol].width.value();
allColsAreFixed = false;
break;
case Fixed:
if (layoutStruct[lastCol].width.value() > 0) {
fixedWidth += layoutStruct[lastCol].width.value();
allColsArePercent = false;
// IE resets effWidth to Variable 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 either.
break;
}
// fall through
case Variable:
haveVariable = true;
// fall through
default:
// 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 (!layoutStruct[lastCol].effWidth.isPercent()) {
layoutStruct[lastCol].effWidth = Length();
allColsArePercent = false;
}
else
totalPercent += layoutStruct[lastCol].effWidth.value();
allColsAreFixed = false;
}
span -= table->spanOfEffCol( lastCol );
minWidth += layoutStruct[lastCol].effMinWidth;
maxWidth += layoutStruct[lastCol].effMaxWidth;
lastCol++;
cMinWidth -= hspacing;
cMaxWidth -= hspacing;
}
#ifdef DEBUG_LAYOUT
qDebug(" colspan cell %p at effCol %d, span %d, type %d, value %d cmin=%d min=%d fixedwidth=%d", cell, col, cSpan, w.type(), w.value(), cMinWidth, minWidth, fixedWidth );
#endif
// adjust table max width if needed
if ( w.isPercent() ) {
if ( totalPercent > w.value() || allColsArePercent ) {
// can't satify this condition, treat as variable
w = Length();
} else {
int spanMax = kMax( maxWidth, cMaxWidth );
#ifdef DEBUG_LAYOUT
qDebug(" adjusting tMaxWidth (%d): spanMax=%d, value=%d, totalPercent=%d", tMaxWidth, spanMax, w.value(), totalPercent );
#endif
tMaxWidth = kMax( tMaxWidth, spanMax * 100 / w.value() );
// all non percent columns in the span get percent values to sum up correctly.
int percentMissing = w.value() - totalPercent;
int totalWidth = 0;
for ( unsigned int pos = col; pos < lastCol; pos++ ) {
if ( !(layoutStruct[pos].width.isPercent() ) )
totalWidth += layoutStruct[pos].effMaxWidth;
}
for ( unsigned int pos = col; pos < lastCol && totalWidth > 0; pos++ ) {
if ( !(layoutStruct[pos].width.isPercent() ) ) {
int percent = percentMissing * layoutStruct[pos].effMaxWidth / totalWidth;
#ifdef DEBUG_LAYOUT
qDebug(" col %d: setting percent value %d effMaxWidth=%d totalWidth=%d", pos, percent, layoutStruct[pos].effMaxWidth, totalWidth );
#endif
totalWidth -= layoutStruct[pos].effMaxWidth;
percentMissing -= percent;
if ( percent > 0 )
layoutStruct[pos].effWidth = Length( percent, Percent );
else
layoutStruct[pos].effWidth = Length();
}
}
}
}
// make sure minWidth and maxWidth of the spanning cell are honoured
if ( cMinWidth > minWidth ) {
if ( allColsAreFixed ) {
#ifdef DEBUG_LAYOUT
qDebug("extending minWidth of cols %d-%d to %dpx currentMin=%d accroding to fixed sum %d", col, lastCol-1, cMinWidth, minWidth, fixedWidth );
#endif
for ( unsigned int pos = col; fixedWidth > 0 && pos < lastCol; pos++ ) {
int w = kMax( int( layoutStruct[pos].effMinWidth ), cMinWidth * layoutStruct[pos].width.value() / fixedWidth );
#ifdef DEBUG_LAYOUT
qDebug(" col %d: min=%d, effMin=%d, new=%d", pos, layoutStruct[pos].effMinWidth, layoutStruct[pos].effMinWidth, w );
#endif
fixedWidth -= layoutStruct[pos].width.value();
cMinWidth -= w;
layoutStruct[pos].effMinWidth = w;
}
} else if ( allColsArePercent ) {
int maxw = maxWidth;
int minw = minWidth;
int cminw = cMinWidth;
for ( unsigned int pos = col; maxw > 0 && pos < lastCol; pos++ ) {
if ( layoutStruct[pos].effWidth.isPercent() && layoutStruct[pos].effWidth.value()>0 && fixedWidth <= cMinWidth) {
int w = layoutStruct[pos].effMinWidth;
w = kMax( w, cminw*layoutStruct[pos].effWidth.value()/totalPercent );
w = kMin(layoutStruct[pos].effMinWidth+(cMinWidth-minw), w);
#ifdef DEBUG_LAYOUT
qDebug(" col %d: min=%d, effMin=%d, new=%d", pos, layoutStruct[pos].effMinWidth, layoutStruct[pos].effMinWidth, w );
#endif
maxw -= layoutStruct[pos].effMaxWidth;
minw -= layoutStruct[pos].effMinWidth;
cMinWidth -= w;
layoutStruct[pos].effMinWidth = w;
}
}
} else {
#ifdef DEBUG_LAYOUT
qDebug("extending minWidth of cols %d-%d to %dpx currentMin=%d", col, lastCol-1, cMinWidth, minWidth );
#endif
int maxw = maxWidth;
int minw = minWidth;
// Give min to variable first, to fixed second, and to others third.
for ( unsigned int pos = col; maxw > 0 && pos < lastCol; pos++ ) {
if ( layoutStruct[pos].width.isFixed() && haveVariable && fixedWidth <= cMinWidth ) {
int w = kMax( int( layoutStruct[pos].effMinWidth ), layoutStruct[pos].width.value() );
fixedWidth -= layoutStruct[pos].width.value();
minw -= layoutStruct[pos].effMinWidth;
#ifdef DEBUG_LAYOUT
qDebug(" col %d: min=%d, effMin=%d, new=%d", pos, layoutStruct[pos].effMinWidth, layoutStruct[pos].effMinWidth, w );
#endif
maxw -= layoutStruct[pos].effMaxWidth;
cMinWidth -= w;
layoutStruct[pos].effMinWidth = w;
}
}
for ( unsigned int pos = col; maxw > 0 && pos < lastCol && minw < cMinWidth; pos++ ) {
if ( !(layoutStruct[pos].width.isFixed() && haveVariable && fixedWidth <= cMinWidth) ) {
int w = kMax( int( layoutStruct[pos].effMinWidth ), cMinWidth * layoutStruct[pos].effMaxWidth / maxw );
w = kMin(layoutStruct[pos].effMinWidth+(cMinWidth-minw), w);
#ifdef DEBUG_LAYOUT
qDebug(" col %d: min=%d, effMin=%d, new=%d", pos, layoutStruct[pos].effMinWidth, layoutStruct[pos].effMinWidth, w );
#endif
maxw -= layoutStruct[pos].effMaxWidth;
minw -= layoutStruct[pos].effMinWidth;
cMinWidth -= w;
layoutStruct[pos].effMinWidth = w;
}
}
}
}
if ( !w.isPercent() ) {
if ( cMaxWidth > maxWidth ) {
#ifdef DEBUG_LAYOUT
qDebug("extending maxWidth of cols %d-%d to %dpx", col, lastCol-1, cMaxWidth );
#endif
for ( unsigned int pos = col; maxWidth > 0 && pos < lastCol; pos++ ) {
int w = kMax( int( layoutStruct[pos].effMaxWidth ), cMaxWidth * layoutStruct[pos].effMaxWidth / maxWidth );
#ifdef DEBUG_LAYOUT
qDebug(" col %d: max=%d, effMax=%d, new=%d", pos, layoutStruct[pos].effMaxWidth, layoutStruct[pos].effMaxWidth, w );
#endif
maxWidth -= layoutStruct[pos].effMaxWidth;
cMaxWidth -= w;
layoutStruct[pos].effMaxWidth = w;
}
}
} else {
for ( unsigned int pos = col; pos < lastCol; pos++ )
layoutStruct[pos].maxWidth = kMax(layoutStruct[pos].maxWidth, int(layoutStruct[pos].minWidth) );
}
}
effWidthDirty = false;
// qDebug("calcEffectiveWidth: tMaxWidth=%d", tMaxWidth );
return tMaxWidth;
}
/* gets all cells that originate in a column and have a cellspan > 1
Sorts them by increasing cellspan
*/
void AutoTableLayout::insertSpanCell( RenderTableCell *cell )
{
if ( !cell || cell == (RenderTableCell *)-1 || cell->colSpan() == 1 )
return;
// qDebug("inserting span cell %p with span %d", cell, cell->colSpan() );
int size = spanCells.size();
if ( !size || spanCells[size-1] != 0 ) {
spanCells.resize( size + 10 );
for ( int i = 0; i < 10; i++ )
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 int pos = 0;
int span = cell->colSpan();
while ( pos < spanCells.size() && spanCells[pos] && span > spanCells[pos]->colSpan() )
pos++;
memmove( spanCells.data()+pos+1, spanCells.data()+pos, (size-pos-1)*sizeof( RenderTableCell * ) );
spanCells[pos] = cell;
}
void AutoTableLayout::layout()
{
// table layout based on the values collected in the layout structure.
int tableWidth = table->width() - table->bordersPaddingAndSpacing();
int available = tableWidth;
int nEffCols = table->numEffCols();
if ( nEffCols != (int)layoutStruct.size() ) {
qWarning("WARNING: nEffCols is not equal to layoutstruct!" );
fullRecalc();
nEffCols = table->numEffCols();
}
#ifdef DEBUG_LAYOUT
qDebug("AutoTableLayout::layout()");
#endif
if ( effWidthDirty )
calcEffectiveWidth();
#ifdef DEBUG_LAYOUT
qDebug(" tableWidth=%d, nEffCols=%d", tableWidth, nEffCols );
for ( int i = 0; i < nEffCols; i++ ) {
qDebug(" effcol %d is of type %d value %d, minWidth=%d, maxWidth=%d",
i, layoutStruct[i].width.type(), layoutStruct[i].width.value(),
layoutStruct[i].minWidth, layoutStruct[i].maxWidth );
qDebug(" effective: type %d value %d, minWidth=%d, maxWidth=%d",
layoutStruct[i].effWidth.type(), layoutStruct[i].effWidth.value(),
layoutStruct[i].effMinWidth, layoutStruct[i].effMaxWidth );
}
#endif
bool havePercent = false;
bool haveRelative = false;
int totalRelative = 0;
int numVariable = 0;
int numFixed = 0;
int totalVariable = 0;
int totalFixed = 0;
int totalPercent = 0;
int allocVariable = 0;
// fill up every cell with it's minWidth
for ( int i = 0; i < nEffCols; i++ ) {
int w = layoutStruct[i].effMinWidth;
layoutStruct[i].calcWidth = w;
available -= w;
Length& width = layoutStruct[i].effWidth;
switch( width.type()) {
case Percent:
havePercent = true;
totalPercent += width.value();
break;
case Relative:
haveRelative = true;
totalRelative += width.value();
break;
case Fixed:
numFixed++;
totalFixed += layoutStruct[i].effMaxWidth;
// fall through
break;
case Variable:
case Static:
numVariable++;
totalVariable += layoutStruct[i].effMaxWidth;
allocVariable += w;
}
}
// allocate width to percent cols
if ( available > 0 && havePercent ) {
for ( int i = 0; i < nEffCols; i++ ) {
const Length &width = layoutStruct[i].effWidth;
if ( width.isPercent() ) {
int w = kMax ( int( layoutStruct[i].effMinWidth ), width.minWidth( tableWidth ) );
available += layoutStruct[i].calcWidth - w;
layoutStruct[i].calcWidth = w;
}
}
if ( totalPercent > 100 ) {
// remove overallocated space from the last columns
int excess = tableWidth*(totalPercent-100)/100;
for ( int i = nEffCols-1; i >= 0; i-- ) {
if ( layoutStruct[i].effWidth.isPercent() ) {
int w = layoutStruct[i].calcWidth;
int reduction = kMin( w, excess );
// the lines below might look inconsistent, but that's the way it's handled in mozilla
excess -= reduction;
int newWidth = kMax( int (layoutStruct[i].effMinWidth), w - reduction );
available += w - newWidth;
layoutStruct[i].calcWidth = newWidth;
//qDebug("col %d: reducing to %d px (reduction=%d)", i, newWidth, reduction );
}
}
}
}
#ifdef DEBUG_LAYOUT
qDebug("percent satisfied: available is %d", available);
#endif
// then allocate width to fixed cols
if ( available > 0 ) {
for ( int i = 0; i < nEffCols; ++i ) {
const Length &width = layoutStruct[i].effWidth;
if ( width.isFixed() && width.value() > layoutStruct[i].calcWidth ) {
available += layoutStruct[i].calcWidth - width.value();
layoutStruct[i].calcWidth = width.value();
}
}
}
#ifdef DEBUG_LAYOUT
qDebug("fixed satisfied: available is %d", available);
#endif
// now satisfy relative
if ( available > 0 ) {
for ( int i = 0; i < nEffCols; i++ ) {
const Length &width = layoutStruct[i].effWidth;
if ( width.isRelative() && width.value() ) {
// width=0* gets effMinWidth.
int w = width.value()*tableWidth/totalRelative;
available += layoutStruct[i].calcWidth - w;
layoutStruct[i].calcWidth = w;
}
}
}
// now satisfy variable
if ( available > 0 && numVariable ) {
available += allocVariable; // this gets redistributed
//qDebug("redistributing %dpx to %d variable columns. totalVariable=%d", available, numVariable, totalVariable );
for ( int i = 0; i < nEffCols; i++ ) {
const Length &width = layoutStruct[i].effWidth;
if ( width.isVariable() && totalVariable != 0 ) {
int w = kMax( int ( layoutStruct[i].calcWidth ),
available * layoutStruct[i].effMaxWidth / totalVariable );
available -= w;
totalVariable -= layoutStruct[i].effMaxWidth;
layoutStruct[i].calcWidth = w;
}
}
}
#ifdef DEBUG_LAYOUT
qDebug("variable satisfied: available is %d", available );
#endif
// spread over fixed colums
if ( available > 0 && numFixed) {
// still have some width to spread, distribute to fixed columns
for ( int i = 0; i < nEffCols; i++ ) {
const Length &width = layoutStruct[i].effWidth;
if ( width.isFixed() ) {
int w = available * layoutStruct[i].effMaxWidth / totalFixed;
available -= w;
totalFixed -= layoutStruct[i].effMaxWidth;
layoutStruct[i].calcWidth += w;
}
}
}
#ifdef DEBUG_LAYOUT
qDebug("after fixed distribution: available=%d", available );
#endif
// spread over percent colums
if ( available > 0 && hasPercent && totalPercent < 100) {
// still have some width to spread, distribute weighted to percent columns
for ( int i = 0; i < nEffCols; i++ ) {
const Length &width = layoutStruct[i].effWidth;
if ( width.isPercent() ) {
int w = available * width.value() / totalPercent;
available -= w;
totalPercent -= width.value();
layoutStruct[i].calcWidth += w;
if (!available || !totalPercent) break;
}
}
}
#ifdef DEBUG_LAYOUT
qDebug("after percent distribution: available=%d", available );
#endif
// spread over the rest
if ( available > 0 ) {
int total = nEffCols;
// still have some width to spread
int i = nEffCols;
while ( i-- ) {
int w = available / total;
available -= w;
total--;
layoutStruct[i].calcWidth += w;
}
}
#ifdef DEBUG_LAYOUT
qDebug("after equal distribution: available=%d", available );
#endif
// if we have overallocated, reduce every cell according to the difference between desired width and minwidth
// this seems to produce to the pixel exaxt results with IE. Wonder is some of this also holds for width distributing.
if ( available < 0 ) {
// Need to reduce cells with the following prioritization:
// (1) Variable
// (2) Relative
// (3) Fixed
// (4) Percent
// This is basically the reverse of how we grew the cells.
if (available < 0) {
int mw = 0;
for ( int i = nEffCols-1; i >= 0; i-- ) {
Length &width = layoutStruct[i].effWidth;
if (width.isVariable())
mw += layoutStruct[i].calcWidth - layoutStruct[i].effMinWidth;
}
for ( int i = nEffCols-1; i >= 0 && mw > 0; i-- ) {
Length &width = layoutStruct[i].effWidth;
if (width.isVariable()) {
int minMaxDiff = layoutStruct[i].calcWidth-layoutStruct[i].effMinWidth;
int reduce = available * minMaxDiff / mw;
layoutStruct[i].calcWidth += reduce;
available -= reduce;
mw -= minMaxDiff;
if ( available >= 0 )
break;
}
}
}
if (available < 0) {
int mw = 0;
for ( int i = nEffCols-1; i >= 0; i-- ) {
Length &width = layoutStruct[i].effWidth;
if (width.isRelative())
mw += layoutStruct[i].calcWidth - layoutStruct[i].effMinWidth;
}
for ( int i = nEffCols-1; i >= 0 && mw > 0; i-- ) {
Length &width = layoutStruct[i].effWidth;
if (width.isRelative()) {
int minMaxDiff = layoutStruct[i].calcWidth-layoutStruct[i].effMinWidth;
int reduce = available * minMaxDiff / mw;
layoutStruct[i].calcWidth += reduce;
available -= reduce;
mw -= minMaxDiff;
if ( available >= 0 )
break;
}
}
}
if (available < 0) {
int mw = 0;
for ( int i = nEffCols-1; i >= 0; i-- ) {
Length &width = layoutStruct[i].effWidth;
if (width.isFixed())
mw += layoutStruct[i].calcWidth - layoutStruct[i].effMinWidth;
}
for ( int i = nEffCols-1; i >= 0 && mw > 0; i-- ) {
Length &width = layoutStruct[i].effWidth;
if (width.isFixed()) {
int minMaxDiff = layoutStruct[i].calcWidth-layoutStruct[i].effMinWidth;
int reduce = available * minMaxDiff / mw;
layoutStruct[i].calcWidth += reduce;
available -= reduce;
mw -= minMaxDiff;
if ( available >= 0 )
break;
}
}
}
if (available < 0) {
int mw = 0;
for ( int i = nEffCols-1; i >= 0; i-- ) {
Length &width = layoutStruct[i].effWidth;
if (width.isPercent())
mw += layoutStruct[i].calcWidth - layoutStruct[i].effMinWidth;
}
for ( int i = nEffCols-1; i >= 0 && mw > 0; i-- ) {
Length &width = layoutStruct[i].effWidth;
if (width.isPercent()) {
int minMaxDiff = layoutStruct[i].calcWidth-layoutStruct[i].effMinWidth;
int reduce = available * minMaxDiff / mw;
layoutStruct[i].calcWidth += reduce;
available -= reduce;
mw -= minMaxDiff;
if ( available >= 0 )
break;
}
}
}
}
//qDebug( " final available=%d", available );
int pos = 0;
for ( int i = 0; i < nEffCols; i++ ) {
#ifdef DEBUG_LAYOUT
qDebug("col %d: %d (width %d)", i, pos, layoutStruct[i].calcWidth );
#endif
table->columnPos[i] = pos;
pos += layoutStruct[i].calcWidth + table->borderHSpacing();
}
table->columnPos[table->columnPos.size()-1] = pos;
}
void AutoTableLayout::calcPercentages() const
{
total_percent = 0;
for ( unsigned int i = 0; i < layoutStruct.size(); i++ ) {
if ( layoutStruct[i].width.isPercent() )
total_percent += layoutStruct[i].width.value();
}
percentagesDirty = false;
}
#undef DEBUG_LAYOUT