/*
* Copyright (C) 1997 Martin Jones (mjones@kde.org)
* (C) 1997 Torben Weis (weis@kde.org)
* (C) 1998 Waldo Bastian (bastian@kde.org)
* (C) 1999 Lars Knoll (knoll@kde.org)
* (C) 1999 Antti Koivisto (koivisto@kde.org)
* Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
* Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
*
* 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, or (at your option) any later version.
*
* 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 "config.h"
#include "RenderTable.h"
#include "AutoTableLayout.h"
#include "CollapsedBorderValue.h"
#include "DeleteButtonController.h"
#include "Document.h"
#include "FixedTableLayout.h"
#include "FrameView.h"
#include "HitTestResult.h"
#include "HTMLNames.h"
#include "RenderLayer.h"
#include "RenderTableCell.h"
#include "RenderTableCol.h"
#include "RenderTableSection.h"
#ifdef ANDROID_LAYOUT
#include "Settings.h"
#endif
#include "RenderView.h"
using namespace std;
namespace WebCore {
using namespace HTMLNames;
RenderTable::RenderTable(Node* node)
: RenderBlock(node)
, m_caption(0)
, m_head(0)
, m_foot(0)
, m_firstBody(0)
, m_currentBorder(0)
, m_hasColElements(false)
, m_needsSectionRecalc(0)
, m_hSpacing(0)
, m_vSpacing(0)
, m_borderStart(0)
, m_borderEnd(0)
{
setChildrenInline(false);
m_columnPos.fill(0, 2);
m_columns.fill(ColumnStruct(), 1);
#ifdef ANDROID_LAYOUT
m_singleColumn = false;
#endif
}
RenderTable::~RenderTable()
{
}
void RenderTable::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
RenderBlock::styleDidChange(diff, oldStyle);
propagateStyleToAnonymousChildren();
ETableLayout oldTableLayout = oldStyle ? oldStyle->tableLayout() : TAUTO;
// In the collapsed border model, there is no cell spacing.
m_hSpacing = collapseBorders() ? 0 : style()->horizontalBorderSpacing();
m_vSpacing = collapseBorders() ? 0 : style()->verticalBorderSpacing();
m_columnPos[0] = m_hSpacing;
if (!m_tableLayout || style()->tableLayout() != oldTableLayout) {
// According to the CSS2 spec, you only use fixed table layout if an
// explicit width is specified on the table. Auto width implies auto table layout.
if (style()->tableLayout() == TFIXED && !style()->logicalWidth().isAuto())
m_tableLayout.set(new FixedTableLayout(this));
else
m_tableLayout.set(new AutoTableLayout(this));
}
}
static inline void resetSectionPointerIfNotBefore(RenderTableSection*& ptr, RenderObject* before)
{
if (!before || !ptr)
return;
RenderObject* o = before->previousSibling();
while (o && o != ptr)
o = o->previousSibling();
if (!o)
ptr = 0;
}
void RenderTable::addChild(RenderObject* child, RenderObject* beforeChild)
{
// Make sure we don't append things after :after-generated content if we have it.
if (!beforeChild && isAfterContent(lastChild()))
beforeChild = lastChild();
bool wrapInAnonymousSection = !child->isPositioned();
if (child->isRenderBlock() && child->style()->display() == TABLE_CAPTION) {
// First caption wins.
if (beforeChild && m_caption) {
RenderObject* o = beforeChild->previousSibling();
while (o && o != m_caption)
o = o->previousSibling();
if (!o) {
m_caption = 0;
setNeedsSectionRecalc();
}
}
if (!m_caption)
m_caption = toRenderBlock(child);
else
setNeedsSectionRecalc();
wrapInAnonymousSection = false;
} else if (child->isTableCol()) {
m_hasColElements = true;
wrapInAnonymousSection = false;
} else if (child->isTableSection()) {
switch (child->style()->display()) {
case TABLE_HEADER_GROUP:
resetSectionPointerIfNotBefore(m_head, beforeChild);
if (!m_head) {
m_head = toRenderTableSection(child);
} else {
resetSectionPointerIfNotBefore(m_firstBody, beforeChild);
if (!m_firstBody)
m_firstBody = toRenderTableSection(child);
}
wrapInAnonymousSection = false;
break;
case TABLE_FOOTER_GROUP:
resetSectionPointerIfNotBefore(m_foot, beforeChild);
if (!m_foot) {
m_foot = toRenderTableSection(child);
wrapInAnonymousSection = false;
break;
}
// Fall through.
case TABLE_ROW_GROUP:
resetSectionPointerIfNotBefore(m_firstBody, beforeChild);
if (!m_firstBody)
m_firstBody = toRenderTableSection(child);
wrapInAnonymousSection = false;
break;
default:
ASSERT_NOT_REACHED();
}
} else if (child->isTableCell() || child->isTableRow())
wrapInAnonymousSection = true;
else
wrapInAnonymousSection = true;
if (!wrapInAnonymousSection) {
// If the next renderer is actually wrapped in an anonymous table section, we need to go up and find that.
while (beforeChild && beforeChild->parent() != this)
beforeChild = beforeChild->parent();
RenderBox::addChild(child, beforeChild);
return;
}
if (!beforeChild && lastChild() && lastChild()->isTableSection() && lastChild()->isAnonymous()) {
lastChild()->addChild(child);
return;
}
RenderObject* lastBox = beforeChild;
while (lastBox && lastBox->parent()->isAnonymous() && !lastBox->isTableSection() && lastBox->style()->display() != TABLE_CAPTION && lastBox->style()->display() != TABLE_COLUMN_GROUP)
lastBox = lastBox->parent();
if (lastBox && lastBox->isAnonymous() && !isAfterContent(lastBox)) {
if (beforeChild == lastBox)
beforeChild = lastBox->firstChild();
lastBox->addChild(child, beforeChild);
return;
}
if (beforeChild && !beforeChild->isTableSection() && beforeChild->style()->display() != TABLE_CAPTION && beforeChild->style()->display() != TABLE_COLUMN_GROUP)
beforeChild = 0;
RenderTableSection* section = new (renderArena()) RenderTableSection(document() /* anonymous */);
RefPtr<RenderStyle> newStyle = RenderStyle::create();
newStyle->inheritFrom(style());
newStyle->setDisplay(TABLE_ROW_GROUP);
section->setStyle(newStyle.release());
addChild(section, beforeChild);
section->addChild(child);
}
void RenderTable::removeChild(RenderObject* oldChild)
{
RenderBox::removeChild(oldChild);
if (m_caption && oldChild == m_caption && node())
node()->setNeedsStyleRecalc();
setNeedsSectionRecalc();
}
void RenderTable::computeLogicalWidth()
{
#ifdef ANDROID_LAYOUT
if (view()->frameView())
setVisibleWidth(view()->frameView()->textWrapWidth());
#endif
if (isPositioned())
computePositionedLogicalWidth();
RenderBlock* cb = containingBlock();
int availableLogicalWidth = containingBlockLogicalWidthForContent();
bool hasPerpendicularContainingBlock = cb->style()->isHorizontalWritingMode() != style()->isHorizontalWritingMode();
int containerWidthInInlineDirection = hasPerpendicularContainingBlock ? perpendicularContainingBlockLogicalHeight() : availableLogicalWidth;
LengthType logicalWidthType = style()->logicalWidth().type();
if (logicalWidthType > Relative && style()->logicalWidth().isPositive()) {
// Percent or fixed table
setLogicalWidth(style()->logicalWidth().calcMinValue(containerWidthInInlineDirection));
setLogicalWidth(max(minPreferredLogicalWidth(), logicalWidth()));
} else {
// Subtract out any fixed margins from our available width for auto width tables.
int marginTotal = 0;
if (!style()->marginStart().isAuto())
marginTotal += style()->marginStart().calcValue(availableLogicalWidth);
if (!style()->marginEnd().isAuto())
marginTotal += style()->marginEnd().calcValue(availableLogicalWidth);
// Subtract out our margins to get the available content width.
int availableContentLogicalWidth = max(0, containerWidthInInlineDirection - marginTotal);
// Ensure we aren't bigger than our max width or smaller than our min width.
setLogicalWidth(min(availableContentLogicalWidth, maxPreferredLogicalWidth()));
}
setLogicalWidth(max(logicalWidth(), minPreferredLogicalWidth()));
// Finally, with our true width determined, compute our margins for real.
setMarginStart(0);
setMarginEnd(0);
#ifdef ANDROID_LAYOUT
// in SSR mode, we ignore left/right margin for table
if (document()->settings()->layoutAlgorithm() == Settings::kLayoutSSR)
return;
#endif
if (!hasPerpendicularContainingBlock)
computeInlineDirectionMargins(cb, availableLogicalWidth, logicalWidth());
else {
setMarginStart(style()->marginStart().calcMinValue(availableLogicalWidth));
setMarginEnd(style()->marginEnd().calcMinValue(availableLogicalWidth));
}
}
void RenderTable::adjustLogicalHeightForCaption()
{
ASSERT(m_caption);
IntRect captionRect(m_caption->x(), m_caption->y(), m_caption->width(), m_caption->height());
m_caption->setLogicalLocation(m_caption->marginStart(), logicalHeight());
if (!selfNeedsLayout() && m_caption->checkForRepaintDuringLayout())
m_caption->repaintDuringLayoutIfMoved(captionRect);
setLogicalHeight(logicalHeight() + m_caption->logicalHeight() + m_caption->marginBefore() + m_caption->marginAfter());
}
void RenderTable::layout()
{
ASSERT(needsLayout());
if (simplifiedLayout())
return;
recalcSectionsIfNeeded();
LayoutRepainter repainter(*this, checkForRepaintDuringLayout());
LayoutStateMaintainer statePusher(view(), this, IntSize(x(), y()), style()->isFlippedBlocksWritingMode());
setLogicalHeight(0);
m_overflow.clear();
initMaxMarginValues();
#ifdef ANDROID_LAYOUT
bool relayoutChildren = false;
#endif
int oldLogicalWidth = logicalWidth();
computeLogicalWidth();
#ifdef ANDROID_LAYOUT
if (!checkAndSetRelayoutChildren(&relayoutChildren)
&& document()->settings()->layoutAlgorithm() == Settings::kLayoutSSR) {
// if the width of a table is wider than its container width, or it has a nested table,
// we will render it with single column.
int cw = containingBlockLogicalWidthForContent();
bool shouldRenderAsSingleColumn = (width() > cw);
if (!shouldRenderAsSingleColumn) {
RenderObject* child = firstChild();
while (child) {
if (child->isTable()) {
shouldRenderAsSingleColumn = true;
break;
}
child = child->nextInPreOrder();
}
}
if (shouldRenderAsSingleColumn) {
m_singleColumn = true;
if (width() > cw)
setWidth(cw);
if (m_minPreferredLogicalWidth > cw)
m_minPreferredLogicalWidth = cw;
if (m_maxPreferredLogicalWidth > cw)
m_maxPreferredLogicalWidth = cw;
}
}
#endif
if (m_caption && logicalWidth() != oldLogicalWidth)
m_caption->setNeedsLayout(true, false);
// FIXME: The optimisation below doesn't work since the internal table
// layout could have changed. we need to add a flag to the table
// layout that tells us if something has changed in the min max
// calculations to do it correctly.
// if ( oldWidth != width() || columns.size() + 1 != columnPos.size() )
m_tableLayout->layout();
setCellLogicalWidths();
int totalSectionLogicalHeight = 0;
int oldTableLogicalTop = m_caption ? m_caption->logicalHeight() + m_caption->marginBefore() + m_caption->marginAfter() : 0;
bool collapsing = collapseBorders();
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
#ifdef ANDROID_LAYOUT
if (relayoutChildren) {
child->setNeedsLayout(true, false);
if (!child->isTableSection()) {
child->layoutIfNeeded();
continue;
}
// fall through
}
#endif
if (child->isTableSection()) {
child->layoutIfNeeded();
RenderTableSection* section = toRenderTableSection(child);
totalSectionLogicalHeight += section->calcRowLogicalHeight();
if (collapsing)
section->recalcOuterBorder();
ASSERT(!section->needsLayout());
} else if (child->isTableCol()) {
child->layoutIfNeeded();
ASSERT(!child->needsLayout());
}
}
// Only lay out one caption, since it's the only one we're going to end up painting.
if (m_caption)
m_caption->layoutIfNeeded();
// If any table section moved vertically, we will just repaint everything from that
// section down (it is quite unlikely that any of the following sections
// did not shift).
bool sectionMoved = false;
int movedSectionLogicalTop = 0;
// FIXME: Collapse caption margin.
if (m_caption && m_caption->style()->captionSide() != CAPBOTTOM) {
adjustLogicalHeightForCaption();
if (logicalHeight() != oldTableLogicalTop) {
sectionMoved = true;
movedSectionLogicalTop = min(logicalHeight(), oldTableLogicalTop);
}
}
int borderAndPaddingBefore = borderBefore() + (collapsing ? 0 : paddingBefore());
int borderAndPaddingAfter = borderAfter() + (collapsing ? 0 : paddingAfter());
setLogicalHeight(logicalHeight() + borderAndPaddingBefore);
if (!isPositioned())
computeLogicalHeight();
Length logicalHeightLength = style()->logicalHeight();
int computedLogicalHeight = 0;
if (logicalHeightLength.isFixed()) {
// Tables size as though CSS height includes border/padding.
computedLogicalHeight = logicalHeightLength.value() - (borderAndPaddingBefore + borderAndPaddingAfter);
} else if (logicalHeightLength.isPercent())
computedLogicalHeight = computePercentageLogicalHeight(logicalHeightLength);
computedLogicalHeight = max(0, computedLogicalHeight);
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
if (child->isTableSection())
// FIXME: Distribute extra height between all table body sections instead of giving it all to the first one.
toRenderTableSection(child)->layoutRows(child == m_firstBody ? max(0, computedLogicalHeight - totalSectionLogicalHeight) : 0);
}
if (!m_firstBody && computedLogicalHeight > totalSectionLogicalHeight && !document()->inQuirksMode()) {
// Completely empty tables (with no sections or anything) should at least honor specified height
// in strict mode.
setLogicalHeight(logicalHeight() + computedLogicalHeight);
}
int sectionLogicalLeft = style()->isLeftToRightDirection() ? borderStart() : borderEnd();
if (!collapsing)
sectionLogicalLeft += style()->isLeftToRightDirection() ? paddingStart() : paddingEnd();
// position the table sections
RenderTableSection* section = m_head ? m_head : (m_firstBody ? m_firstBody : m_foot);
while (section) {
if (!sectionMoved && section->logicalTop() != logicalHeight()) {
sectionMoved = true;
movedSectionLogicalTop = min(logicalHeight(), section->logicalTop()) + (style()->isHorizontalWritingMode() ? section->minYVisualOverflow() : section->minXVisualOverflow());
}
section->setLogicalLocation(sectionLogicalLeft, logicalHeight());
setLogicalHeight(logicalHeight() + section->logicalHeight());
section = sectionBelow(section);
}
setLogicalHeight(logicalHeight() + borderAndPaddingAfter);
if (m_caption && m_caption->style()->captionSide() == CAPBOTTOM)
adjustLogicalHeightForCaption();
if (isPositioned())
computeLogicalHeight();
// table can be containing block of positioned elements.
// FIXME: Only pass true if width or height changed.
layoutPositionedObjects(true);
updateLayerTransform();
computeOverflow(clientLogicalBottom());
statePusher.pop();
if (view()->layoutState()->pageLogicalHeight())
setPageLogicalOffset(view()->layoutState()->pageLogicalOffset(logicalTop()));
bool didFullRepaint = repainter.repaintAfterLayout();
// Repaint with our new bounds if they are different from our old bounds.
if (!didFullRepaint && sectionMoved) {
if (style()->isHorizontalWritingMode())
repaintRectangle(IntRect(minXVisualOverflow(), movedSectionLogicalTop, maxXVisualOverflow() - minXVisualOverflow(), maxYVisualOverflow() - movedSectionLogicalTop));
else
repaintRectangle(IntRect(movedSectionLogicalTop, minYVisualOverflow(), maxXVisualOverflow() - movedSectionLogicalTop, maxYVisualOverflow() - minYVisualOverflow()));
}
setNeedsLayout(false);
}
void RenderTable::addOverflowFromChildren()
{
// Add overflow from borders.
// Technically it's odd that we are incorporating the borders into layout overflow, which is only supposed to be about overflow from our
// descendant objects, but since tables don't support overflow:auto, this works out fine.
if (collapseBorders()) {
int rightBorderOverflow = width() + outerBorderRight() - borderRight();
int leftBorderOverflow = borderLeft() - outerBorderLeft();
int bottomBorderOverflow = height() + outerBorderBottom() - borderBottom();
int topBorderOverflow = borderTop() - outerBorderTop();
IntRect borderOverflowRect(leftBorderOverflow, topBorderOverflow, rightBorderOverflow - leftBorderOverflow, bottomBorderOverflow - topBorderOverflow);
if (borderOverflowRect != borderBoxRect()) {
addLayoutOverflow(borderOverflowRect);
addVisualOverflow(borderOverflowRect);
}
}
// Add overflow from our caption.
if (m_caption)
addOverflowFromChild(m_caption);
// Add overflow from our sections.
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
if (child->isTableSection()) {
RenderTableSection* section = toRenderTableSection(child);
addOverflowFromChild(section);
}
}
}
void RenderTable::setCellLogicalWidths()
{
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
if (child->isTableSection())
toRenderTableSection(child)->setCellLogicalWidths();
}
}
void RenderTable::paint(PaintInfo& paintInfo, int tx, int ty)
{
tx += x();
ty += y();
PaintPhase paintPhase = paintInfo.phase;
if (!isRoot()) {
IntRect overflowBox = visualOverflowRect();
flipForWritingMode(overflowBox);
overflowBox.inflate(maximalOutlineSize(paintInfo.phase));
overflowBox.move(tx, ty);
if (!overflowBox.intersects(paintInfo.rect))
return;
}
bool pushedClip = pushContentsClip(paintInfo, tx, ty);
paintObject(paintInfo, tx, ty);
if (pushedClip)
popContentsClip(paintInfo, paintPhase, tx, ty);
}
void RenderTable::paintObject(PaintInfo& paintInfo, int tx, int ty)
{
PaintPhase paintPhase = paintInfo.phase;
if ((paintPhase == PaintPhaseBlockBackground || paintPhase == PaintPhaseChildBlockBackground) && hasBoxDecorations() && style()->visibility() == VISIBLE)
paintBoxDecorations(paintInfo, tx, ty);
if (paintPhase == PaintPhaseMask) {
paintMask(paintInfo, tx, ty);
return;
}
// We're done. We don't bother painting any children.
if (paintPhase == PaintPhaseBlockBackground)
return;
// We don't paint our own background, but we do let the kids paint their backgrounds.
if (paintPhase == PaintPhaseChildBlockBackgrounds)
paintPhase = PaintPhaseChildBlockBackground;
PaintInfo info(paintInfo);
info.phase = paintPhase;
info.updatePaintingRootForChildren(this);
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
if (child->isBox() && !toRenderBox(child)->hasSelfPaintingLayer() && (child->isTableSection() || child == m_caption)) {
IntPoint childPoint = flipForWritingMode(toRenderBox(child), IntPoint(tx, ty), ParentToChildFlippingAdjustment);
child->paint(info, childPoint.x(), childPoint.y());
}
}
if (collapseBorders() && paintPhase == PaintPhaseChildBlockBackground && style()->visibility() == VISIBLE) {
// Collect all the unique border styles that we want to paint in a sorted list. Once we
// have all the styles sorted, we then do individual passes, painting each style of border
// from lowest precedence to highest precedence.
info.phase = PaintPhaseCollapsedTableBorders;
RenderTableCell::CollapsedBorderStyles borderStyles;
RenderObject* stop = nextInPreOrderAfterChildren();
for (RenderObject* o = firstChild(); o && o != stop; o = o->nextInPreOrder()) {
if (o->isTableCell())
toRenderTableCell(o)->collectBorderStyles(borderStyles);
}
RenderTableCell::sortBorderStyles(borderStyles);
size_t count = borderStyles.size();
for (size_t i = 0; i < count; ++i) {
m_currentBorder = &borderStyles[i];
for (RenderObject* child = firstChild(); child; child = child->nextSibling())
if (child->isTableSection()) {
IntPoint childPoint = flipForWritingMode(toRenderTableSection(child), IntPoint(tx, ty), ParentToChildFlippingAdjustment);
child->paint(info, childPoint.x(), childPoint.y());
}
}
m_currentBorder = 0;
}
// Paint outline.
if ((paintPhase == PaintPhaseOutline || paintPhase == PaintPhaseSelfOutline) && hasOutline() && style()->visibility() == VISIBLE)
paintOutline(paintInfo.context, tx, ty, width(), height());
}
void RenderTable::subtractCaptionRect(IntRect& rect) const
{
if (!m_caption)
return;
int captionLogicalHeight = m_caption->logicalHeight() + m_caption->marginBefore() + m_caption->marginAfter();
bool captionIsBefore = (m_caption->style()->captionSide() != CAPBOTTOM) ^ style()->isFlippedBlocksWritingMode();
if (style()->isHorizontalWritingMode()) {
rect.setHeight(rect.height() - captionLogicalHeight);
if (captionIsBefore)
rect.move(0, captionLogicalHeight);
} else {
rect.setWidth(rect.width() - captionLogicalHeight);
if (captionIsBefore)
rect.move(captionLogicalHeight, 0);
}
}
void RenderTable::paintBoxDecorations(PaintInfo& paintInfo, int tx, int ty)
{
if (!paintInfo.shouldPaintWithinRoot(this))
return;
IntRect rect(tx, ty, width(), height());
subtractCaptionRect(rect);
paintBoxShadow(paintInfo.context, rect.x(), rect.y(), rect.width(), rect.height(), style(), Normal);
if (isRoot())
paintRootBoxFillLayers(paintInfo);
else if (!isBody() || document()->documentElement()->renderer()->hasBackground())
// The <body> only paints its background if the root element has defined a background
// independent of the body.
paintFillLayers(paintInfo, style()->visitedDependentColor(CSSPropertyBackgroundColor), style()->backgroundLayers(), rect.x(), rect.y(), rect.width(), rect.height());
paintBoxShadow(paintInfo.context, rect.x(), rect.y(), rect.width(), rect.height(), style(), Inset);
if (style()->hasBorder() && !collapseBorders())
paintBorder(paintInfo.context, rect.x(), rect.y(), rect.width(), rect.height(), style());
}
void RenderTable::paintMask(PaintInfo& paintInfo, int tx, int ty)
{
if (style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseMask)
return;
IntRect rect(tx, ty, width(), height());
subtractCaptionRect(rect);
paintMaskImages(paintInfo, rect.x(), rect.y(), rect.width(), rect.height());
}
void RenderTable::computePreferredLogicalWidths()
{
ASSERT(preferredLogicalWidthsDirty());
recalcSectionsIfNeeded();
recalcBordersInRowDirection();
m_tableLayout->computePreferredLogicalWidths(m_minPreferredLogicalWidth, m_maxPreferredLogicalWidth);
if (m_caption)
m_minPreferredLogicalWidth = max(m_minPreferredLogicalWidth, m_caption->minPreferredLogicalWidth());
setPreferredLogicalWidthsDirty(false);
}
void RenderTable::splitColumn(int pos, int firstSpan)
{
// we need to add a new columnStruct
int oldSize = m_columns.size();
m_columns.grow(oldSize + 1);
int oldSpan = m_columns[pos].span;
ASSERT(oldSpan > firstSpan);
m_columns[pos].span = firstSpan;
memmove(m_columns.data() + pos + 1, m_columns.data() + pos, (oldSize - pos) * sizeof(ColumnStruct));
m_columns[pos + 1].span = oldSpan - firstSpan;
// change width of all rows.
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
if (child->isTableSection())
toRenderTableSection(child)->splitColumn(pos, firstSpan);
}
m_columnPos.grow(numEffCols() + 1);
setNeedsLayoutAndPrefWidthsRecalc();
}
void RenderTable::appendColumn(int span)
{
// easy case.
int pos = m_columns.size();
int newSize = pos + 1;
m_columns.grow(newSize);
m_columns[pos].span = span;
// change width of all rows.
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
if (child->isTableSection())
toRenderTableSection(child)->appendColumn(pos);
}
m_columnPos.grow(numEffCols() + 1);
setNeedsLayoutAndPrefWidthsRecalc();
}
RenderTableCol* RenderTable::nextColElement(RenderTableCol* current) const
{
RenderObject* next = current->firstChild();
if (!next)
next = current->nextSibling();
if (!next && current->parent()->isTableCol())
next = current->parent()->nextSibling();
while (next) {
if (next->isTableCol())
return toRenderTableCol(next);
if (next != m_caption)
return 0;
next = next->nextSibling();
}
return 0;
}
RenderTableCol* RenderTable::colElement(int col, bool* startEdge, bool* endEdge) const
{
if (!m_hasColElements)
return 0;
RenderObject* child = firstChild();
int cCol = 0;
while (child) {
if (child->isTableCol())
break;
if (child != m_caption)
return 0;
child = child->nextSibling();
}
if (!child)
return 0;
RenderTableCol* colElem = toRenderTableCol(child);
while (colElem) {
int span = colElem->span();
if (!colElem->firstChild()) {
int startCol = cCol;
int endCol = cCol + span - 1;
cCol += span;
if (cCol > col) {
if (startEdge)
*startEdge = startCol == col;
if (endEdge)
*endEdge = endCol == col;
return colElem;
}
}
colElem = nextColElement(colElem);
}
return 0;
}
void RenderTable::recalcCaption(RenderBlock* caption) const
{
if (!m_caption) {
m_caption = caption;
m_caption->setNeedsLayout(true);
} else {
// Make sure to null out the child's renderer.
if (Node* node = caption->node())
node->setRenderer(0);
// Destroy the child now.
caption->destroy();
}
}
void RenderTable::recalcSections() const
{
m_caption = 0;
m_head = 0;
m_foot = 0;
m_firstBody = 0;
m_hasColElements = false;
// We need to get valid pointers to caption, head, foot and first body again
RenderObject* nextSibling;
for (RenderObject* child = firstChild(); child; child = nextSibling) {
nextSibling = child->nextSibling();
switch (child->style()->display()) {
case TABLE_CAPTION:
if (child->isRenderBlock())
recalcCaption(toRenderBlock(child));
break;
case TABLE_COLUMN:
case TABLE_COLUMN_GROUP:
m_hasColElements = true;
break;
case TABLE_HEADER_GROUP:
if (child->isTableSection()) {
RenderTableSection* section = toRenderTableSection(child);
if (!m_head)
m_head = section;
else if (!m_firstBody)
m_firstBody = section;
section->recalcCellsIfNeeded();
}
break;
case TABLE_FOOTER_GROUP:
if (child->isTableSection()) {
RenderTableSection* section = toRenderTableSection(child);
if (!m_foot)
m_foot = section;
else if (!m_firstBody)
m_firstBody = section;
section->recalcCellsIfNeeded();
}
break;
case TABLE_ROW_GROUP:
if (child->isTableSection()) {
RenderTableSection* section = toRenderTableSection(child);
if (!m_firstBody)
m_firstBody = section;
section->recalcCellsIfNeeded();
}
break;
default:
break;
}
}
// repair column count (addChild can grow it too much, because it always adds elements to the last row of a section)
int maxCols = 0;
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
if (child->isTableSection()) {
RenderTableSection* section = toRenderTableSection(child);
int sectionCols = section->numColumns();
if (sectionCols > maxCols)
maxCols = sectionCols;
}
}
m_columns.resize(maxCols);
m_columnPos.resize(maxCols + 1);
ASSERT(selfNeedsLayout());
m_needsSectionRecalc = false;
}
int RenderTable::calcBorderStart() const
{
if (collapseBorders()) {
// Determined by the first cell of the first row. See the CSS 2.1 spec, section 17.6.2.
if (!numEffCols())
return 0;
unsigned borderWidth = 0;
const BorderValue& tb = style()->borderStart();
if (tb.style() == BHIDDEN)
return 0;
if (tb.style() > BHIDDEN)
borderWidth = tb.width();
if (RenderTableCol* colGroup = colElement(0)) {
const BorderValue& gb = colGroup->style()->borderStart();
if (gb.style() == BHIDDEN)
return 0;
if (gb.style() > BHIDDEN)
borderWidth = max(borderWidth, static_cast<unsigned>(gb.width()));
}
RenderTableSection* firstNonEmptySection = m_head ? m_head : (m_firstBody ? m_firstBody : m_foot);
if (firstNonEmptySection && !firstNonEmptySection->numRows())
firstNonEmptySection = sectionBelow(firstNonEmptySection, true);
if (firstNonEmptySection) {
const BorderValue& sb = firstNonEmptySection->style()->borderStart();
if (sb.style() == BHIDDEN)
return 0;
if (sb.style() > BHIDDEN)
borderWidth = max(borderWidth, static_cast<unsigned>(sb.width()));
const RenderTableSection::CellStruct& cs = firstNonEmptySection->cellAt(0, 0);
if (cs.hasCells()) {
const BorderValue& cb = cs.primaryCell()->style()->borderStart(); // FIXME: Make this work with perpendicualr and flipped cells.
if (cb.style() == BHIDDEN)
return 0;
const BorderValue& rb = cs.primaryCell()->parent()->style()->borderStart();
if (rb.style() == BHIDDEN)
return 0;
if (cb.style() > BHIDDEN)
borderWidth = max(borderWidth, static_cast<unsigned>(cb.width()));
if (rb.style() > BHIDDEN)
borderWidth = max(borderWidth, static_cast<unsigned>(rb.width()));
}
}
return (borderWidth + (style()->isLeftToRightDirection() ? 0 : 1)) / 2;
}
return RenderBlock::borderStart();
}
int RenderTable::calcBorderEnd() const
{
if (collapseBorders()) {
// Determined by the last cell of the first row. See the CSS 2.1 spec, section 17.6.2.
if (!numEffCols())
return 0;
unsigned borderWidth = 0;
const BorderValue& tb = style()->borderEnd();
if (tb.style() == BHIDDEN)
return 0;
if (tb.style() > BHIDDEN)
borderWidth = tb.width();
int endColumn = numEffCols() - 1;
if (RenderTableCol* colGroup = colElement(endColumn)) {
const BorderValue& gb = colGroup->style()->borderEnd();
if (gb.style() == BHIDDEN)
return 0;
if (gb.style() > BHIDDEN)
borderWidth = max(borderWidth, static_cast<unsigned>(gb.width()));
}
RenderTableSection* firstNonEmptySection = m_head ? m_head : (m_firstBody ? m_firstBody : m_foot);
if (firstNonEmptySection && !firstNonEmptySection->numRows())
firstNonEmptySection = sectionBelow(firstNonEmptySection, true);
if (firstNonEmptySection) {
const BorderValue& sb = firstNonEmptySection->style()->borderEnd();
if (sb.style() == BHIDDEN)
return 0;
if (sb.style() > BHIDDEN)
borderWidth = max(borderWidth, static_cast<unsigned>(sb.width()));
const RenderTableSection::CellStruct& cs = firstNonEmptySection->cellAt(0, endColumn);
if (cs.hasCells()) {
const BorderValue& cb = cs.primaryCell()->style()->borderEnd(); // FIXME: Make this work with perpendicular and flipped cells.
if (cb.style() == BHIDDEN)
return 0;
const BorderValue& rb = cs.primaryCell()->parent()->style()->borderEnd();
if (rb.style() == BHIDDEN)
return 0;
if (cb.style() > BHIDDEN)
borderWidth = max(borderWidth, static_cast<unsigned>(cb.width()));
if (rb.style() > BHIDDEN)
borderWidth = max(borderWidth, static_cast<unsigned>(rb.width()));
}
}
return (borderWidth + (style()->isLeftToRightDirection() ? 1 : 0)) / 2;
}
return RenderBlock::borderEnd();
}
void RenderTable::recalcBordersInRowDirection()
{
m_borderStart = calcBorderStart();
m_borderEnd = calcBorderEnd();
}
int RenderTable::borderBefore() const
{
if (collapseBorders())
return outerBorderBefore();
return RenderBlock::borderBefore();
}
int RenderTable::borderAfter() const
{
if (collapseBorders())
return outerBorderAfter();
return RenderBlock::borderAfter();
}
int RenderTable::outerBorderBefore() const
{
if (!collapseBorders())
return 0;
int borderWidth = 0;
RenderTableSection* topSection;
if (m_head)
topSection = m_head;
else if (m_firstBody)
topSection = m_firstBody;
else if (m_foot)
topSection = m_foot;
else
topSection = 0;
if (topSection) {
borderWidth = topSection->outerBorderBefore();
if (borderWidth == -1)
return 0; // Overridden by hidden
}
const BorderValue& tb = style()->borderBefore();
if (tb.style() == BHIDDEN)
return 0;
if (tb.style() > BHIDDEN)
borderWidth = max(borderWidth, static_cast<int>(tb.width() / 2));
return borderWidth;
}
int RenderTable::outerBorderAfter() const
{
if (!collapseBorders())
return 0;
int borderWidth = 0;
RenderTableSection* bottomSection;
if (m_foot)
bottomSection = m_foot;
else {
RenderObject* child;
for (child = lastChild(); child && !child->isTableSection(); child = child->previousSibling()) { }
bottomSection = child ? toRenderTableSection(child) : 0;
}
if (bottomSection) {
borderWidth = bottomSection->outerBorderAfter();
if (borderWidth == -1)
return 0; // Overridden by hidden
}
const BorderValue& tb = style()->borderAfter();
if (tb.style() == BHIDDEN)
return 0;
if (tb.style() > BHIDDEN)
borderWidth = max(borderWidth, static_cast<int>((tb.width() + 1) / 2));
return borderWidth;
}
int RenderTable::outerBorderStart() const
{
if (!collapseBorders())
return 0;
int borderWidth = 0;
const BorderValue& tb = style()->borderStart();
if (tb.style() == BHIDDEN)
return 0;
if (tb.style() > BHIDDEN)
borderWidth = (tb.width() + (style()->isLeftToRightDirection() ? 0 : 1)) / 2;
bool allHidden = true;
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
if (!child->isTableSection())
continue;
int sw = toRenderTableSection(child)->outerBorderStart();
if (sw == -1)
continue;
else
allHidden = false;
borderWidth = max(borderWidth, sw);
}
if (allHidden)
return 0;
return borderWidth;
}
int RenderTable::outerBorderEnd() const
{
if (!collapseBorders())
return 0;
int borderWidth = 0;
const BorderValue& tb = style()->borderEnd();
if (tb.style() == BHIDDEN)
return 0;
if (tb.style() > BHIDDEN)
borderWidth = (tb.width() + (style()->isLeftToRightDirection() ? 1 : 0)) / 2;
bool allHidden = true;
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
if (!child->isTableSection())
continue;
int sw = toRenderTableSection(child)->outerBorderEnd();
if (sw == -1)
continue;
else
allHidden = false;
borderWidth = max(borderWidth, sw);
}
if (allHidden)
return 0;
return borderWidth;
}
RenderTableSection* RenderTable::sectionAbove(const RenderTableSection* section, bool skipEmptySections) const
{
recalcSectionsIfNeeded();
if (section == m_head)
return 0;
RenderObject* prevSection = section == m_foot ? lastChild() : section->previousSibling();
while (prevSection) {
if (prevSection->isTableSection() && prevSection != m_head && prevSection != m_foot && (!skipEmptySections || toRenderTableSection(prevSection)->numRows()))
break;
prevSection = prevSection->previousSibling();
}
if (!prevSection && m_head && (!skipEmptySections || m_head->numRows()))
prevSection = m_head;
return toRenderTableSection(prevSection);
}
RenderTableSection* RenderTable::sectionBelow(const RenderTableSection* section, bool skipEmptySections) const
{
recalcSectionsIfNeeded();
if (section == m_foot)
return 0;
RenderObject* nextSection = section == m_head ? firstChild() : section->nextSibling();
while (nextSection) {
if (nextSection->isTableSection() && nextSection != m_head && nextSection != m_foot && (!skipEmptySections || toRenderTableSection(nextSection)->numRows()))
break;
nextSection = nextSection->nextSibling();
}
if (!nextSection && m_foot && (!skipEmptySections || m_foot->numRows()))
nextSection = m_foot;
return toRenderTableSection(nextSection);
}
RenderTableCell* RenderTable::cellAbove(const RenderTableCell* cell) const
{
recalcSectionsIfNeeded();
// Find the section and row to look in
int r = cell->row();
RenderTableSection* section = 0;
int rAbove = 0;
if (r > 0) {
// cell is not in the first row, so use the above row in its own section
section = cell->section();
rAbove = r - 1;
} else {
section = sectionAbove(cell->section(), true);
if (section)
rAbove = section->numRows() - 1;
}
// Look up the cell in the section's grid, which requires effective col index
if (section) {
int effCol = colToEffCol(cell->col());
RenderTableSection::CellStruct& aboveCell = section->cellAt(rAbove, effCol);
return aboveCell.primaryCell();
} else
return 0;
}
RenderTableCell* RenderTable::cellBelow(const RenderTableCell* cell) const
{
recalcSectionsIfNeeded();
// Find the section and row to look in
int r = cell->row() + cell->rowSpan() - 1;
RenderTableSection* section = 0;
int rBelow = 0;
if (r < cell->section()->numRows() - 1) {
// The cell is not in the last row, so use the next row in the section.
section = cell->section();
rBelow = r + 1;
} else {
section = sectionBelow(cell->section(), true);
if (section)
rBelow = 0;
}
// Look up the cell in the section's grid, which requires effective col index
if (section) {
int effCol = colToEffCol(cell->col());
RenderTableSection::CellStruct& belowCell = section->cellAt(rBelow, effCol);
return belowCell.primaryCell();
} else
return 0;
}
RenderTableCell* RenderTable::cellBefore(const RenderTableCell* cell) const
{
recalcSectionsIfNeeded();
RenderTableSection* section = cell->section();
int effCol = colToEffCol(cell->col());
if (!effCol)
return 0;
// If we hit a colspan back up to a real cell.
RenderTableSection::CellStruct& prevCell = section->cellAt(cell->row(), effCol - 1);
return prevCell.primaryCell();
}
RenderTableCell* RenderTable::cellAfter(const RenderTableCell* cell) const
{
recalcSectionsIfNeeded();
int effCol = colToEffCol(cell->col() + cell->colSpan());
if (effCol >= numEffCols())
return 0;
return cell->section()->primaryCellAt(cell->row(), effCol);
}
RenderBlock* RenderTable::firstLineBlock() const
{
return 0;
}
void RenderTable::updateFirstLetter()
{
}
int RenderTable::firstLineBoxBaseline() const
{
if (isWritingModeRoot())
return -1;
recalcSectionsIfNeeded();
RenderTableSection* firstNonEmptySection = m_head ? m_head : (m_firstBody ? m_firstBody : m_foot);
if (firstNonEmptySection && !firstNonEmptySection->numRows())
firstNonEmptySection = sectionBelow(firstNonEmptySection, true);
if (!firstNonEmptySection)
return -1;
return firstNonEmptySection->logicalTop() + firstNonEmptySection->firstLineBoxBaseline();
}
IntRect RenderTable::overflowClipRect(int tx, int ty, OverlayScrollbarSizeRelevancy relevancy)
{
IntRect rect = RenderBlock::overflowClipRect(tx, ty, relevancy);
// If we have a caption, expand the clip to include the caption.
// FIXME: Technically this is wrong, but it's virtually impossible to fix this
// for real until captions have been re-written.
// FIXME: This code assumes (like all our other caption code) that only top/bottom are
// supported. When we actually support left/right and stop mapping them to top/bottom,
// we might have to hack this code first (depending on what order we do these bug fixes in).
if (m_caption) {
if (style()->isHorizontalWritingMode()) {
rect.setHeight(height());
rect.setY(ty);
} else {
rect.setWidth(width());
rect.setX(tx);
}
}
return rect;
}
bool RenderTable::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, int xPos, int yPos, int tx, int ty, HitTestAction action)
{
tx += x();
ty += y();
// Check kids first.
if (!hasOverflowClip() || overflowClipRect(tx, ty).intersects(result.rectForPoint(xPos, yPos))) {
for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
if (child->isBox() && !toRenderBox(child)->hasSelfPaintingLayer() && (child->isTableSection() || child == m_caption)) {
IntPoint childPoint = flipForWritingMode(toRenderBox(child), IntPoint(tx, ty), ParentToChildFlippingAdjustment);
if (child->nodeAtPoint(request, result, xPos, yPos, childPoint.x(), childPoint.y(), action)) {
updateHitTestResult(result, IntPoint(xPos - childPoint.x(), yPos - childPoint.y()));
return true;
}
}
}
}
// Check our bounds next.
IntRect boundsRect = IntRect(tx, ty, width(), height());
if (visibleToHitTesting() && (action == HitTestBlockBackground || action == HitTestChildBlockBackground) && boundsRect.intersects(result.rectForPoint(xPos, yPos))) {
updateHitTestResult(result, flipForWritingMode(IntPoint(xPos - tx, yPos - ty)));
if (!result.addNodeToRectBasedTestResult(node(), xPos, yPos, boundsRect))
return true;
}
return false;
}
}