#ifndef RenderTable_h
#define RenderTable_h
#include "CSSPropertyNames.h"
#include "core/rendering/RenderBlock.h"
#include "core/rendering/style/CollapsedBorderValue.h"
#include "wtf/Vector.h"
namespace WebCore {
class RenderTableCol;
class RenderTableCaption;
class RenderTableCell;
class RenderTableSection;
class TableLayout;
enum SkipEmptySectionsValue { DoNotSkipEmptySections, SkipEmptySections };
class RenderTable FINAL : public RenderBlock {
public:
explicit RenderTable(Element*);
virtual ~RenderTable();
int hBorderSpacing() const { return m_hSpacing; }
int vBorderSpacing() const { return m_vSpacing; }
bool collapseBorders() const { return style()->borderCollapse(); }
virtual int borderStart() const OVERRIDE { return m_borderStart; }
virtual int borderEnd() const OVERRIDE { return m_borderEnd; }
virtual int borderBefore() const OVERRIDE;
virtual int borderAfter() const OVERRIDE;
virtual int borderLeft() const OVERRIDE
{
if (style()->isHorizontalWritingMode())
return style()->isLeftToRightDirection() ? borderStart() : borderEnd();
return style()->isFlippedBlocksWritingMode() ? borderAfter() : borderBefore();
}
virtual int borderRight() const OVERRIDE
{
if (style()->isHorizontalWritingMode())
return style()->isLeftToRightDirection() ? borderEnd() : borderStart();
return style()->isFlippedBlocksWritingMode() ? borderBefore() : borderAfter();
}
virtual int borderTop() const OVERRIDE
{
if (style()->isHorizontalWritingMode())
return style()->isFlippedBlocksWritingMode() ? borderAfter() : borderBefore();
return style()->isLeftToRightDirection() ? borderStart() : borderEnd();
}
virtual int borderBottom() const OVERRIDE
{
if (style()->isHorizontalWritingMode())
return style()->isFlippedBlocksWritingMode() ? borderBefore() : borderAfter();
return style()->isLeftToRightDirection() ? borderEnd() : borderStart();
}
Color bgColor() const { return resolveColor(CSSPropertyBackgroundColor); }
int outerBorderBefore() const;
int outerBorderAfter() const;
int outerBorderStart() const;
int outerBorderEnd() const;
int outerBorderLeft() const
{
if (style()->isHorizontalWritingMode())
return style()->isLeftToRightDirection() ? outerBorderStart() : outerBorderEnd();
return style()->isFlippedBlocksWritingMode() ? outerBorderAfter() : outerBorderBefore();
}
int outerBorderRight() const
{
if (style()->isHorizontalWritingMode())
return style()->isLeftToRightDirection() ? outerBorderEnd() : outerBorderStart();
return style()->isFlippedBlocksWritingMode() ? outerBorderBefore() : outerBorderAfter();
}
int outerBorderTop() const
{
if (style()->isHorizontalWritingMode())
return style()->isFlippedBlocksWritingMode() ? outerBorderAfter() : outerBorderBefore();
return style()->isLeftToRightDirection() ? outerBorderStart() : outerBorderEnd();
}
int outerBorderBottom() const
{
if (style()->isHorizontalWritingMode())
return style()->isFlippedBlocksWritingMode() ? outerBorderBefore() : outerBorderAfter();
return style()->isLeftToRightDirection() ? outerBorderEnd() : outerBorderStart();
}
int calcBorderStart() const;
int calcBorderEnd() const;
void recalcBordersInRowDirection();
virtual void addChild(RenderObject* child, RenderObject* beforeChild = 0) OVERRIDE;
struct ColumnStruct {
explicit ColumnStruct(unsigned initialSpan = 1)
: span(initialSpan)
{
}
unsigned span;
};
void forceSectionsRecalc()
{
setNeedsSectionRecalc();
recalcSections();
}
const Vector<ColumnStruct>& columns() const { return m_columns; }
const Vector<int>& columnPositions() const { return m_columnPos; }
void setColumnPosition(unsigned index, int position)
{
m_columnLogicalWidthChanged |= m_columnPos[index] != position;
m_columnPos[index] = position;
}
RenderTableSection* header() const { return m_head; }
RenderTableSection* footer() const { return m_foot; }
RenderTableSection* firstBody() const { return m_firstBody; }
RenderTableSection* topSection() const;
RenderTableSection* bottomSection() const;
RenderTableSection* topNonEmptySection() const;
unsigned lastColumnIndex() const { return numEffCols() - 1; }
void splitColumn(unsigned position, unsigned firstSpan);
void appendColumn(unsigned span);
unsigned numEffCols() const { return m_columns.size(); }
unsigned spanOfEffCol(unsigned effCol) const { return m_columns[effCol].span; }
unsigned colToEffCol(unsigned column) const
{
if (!m_hasCellColspanThatDeterminesTableWidth)
return column;
unsigned effColumn = 0;
unsigned numColumns = numEffCols();
for (unsigned c = 0; effColumn < numColumns && c + m_columns[effColumn].span - 1 < column; ++effColumn)
c += m_columns[effColumn].span;
return effColumn;
}
unsigned effColToCol(unsigned effCol) const
{
if (!m_hasCellColspanThatDeterminesTableWidth)
return effCol;
unsigned c = 0;
for (unsigned i = 0; i < effCol; i++)
c += m_columns[i].span;
return c;
}
LayoutUnit borderSpacingInRowDirection() const
{
if (unsigned effectiveColumnCount = numEffCols())
return static_cast<LayoutUnit>(effectiveColumnCount + 1) * hBorderSpacing();
return 0;
}
virtual LayoutUnit paddingEnd() const OVERRIDE { return static_cast<int>(RenderBlock::paddingEnd()); }
virtual LayoutUnit paddingStart() const OVERRIDE { return static_cast<int>(RenderBlock::paddingStart()); }
LayoutUnit bordersPaddingAndSpacingInRowDirection() const
{
return borderStart() + borderEnd() + (collapseBorders() ? LayoutUnit() : (paddingStart() + paddingEnd() + borderSpacingInRowDirection()));
}
RenderTableCol* firstColumn() const;
RenderTableCol* colElement(unsigned col, bool* startEdge = 0, bool* endEdge = 0) const
{
if (!m_hasColElements)
return 0;
return slowColElement(col, startEdge, endEdge);
}
bool needsSectionRecalc() const { return m_needsSectionRecalc; }
void setNeedsSectionRecalc()
{
if (documentBeingDestroyed())
return;
m_needsSectionRecalc = true;
setNeedsLayout();
}
RenderTableSection* sectionAbove(const RenderTableSection*, SkipEmptySectionsValue = DoNotSkipEmptySections) const;
RenderTableSection* sectionBelow(const RenderTableSection*, SkipEmptySectionsValue = DoNotSkipEmptySections) const;
RenderTableCell* cellAbove(const RenderTableCell*) const;
RenderTableCell* cellBelow(const RenderTableCell*) const;
RenderTableCell* cellBefore(const RenderTableCell*) const;
RenderTableCell* cellAfter(const RenderTableCell*) const;
typedef Vector<CollapsedBorderValue> CollapsedBorderValues;
void invalidateCollapsedBorders()
{
m_collapsedBordersValid = false;
m_collapsedBorders.clear();
}
const CollapsedBorderValue* currentBorderValue() const { return m_currentBorder; }
bool hasSections() const { return m_head || m_foot || m_firstBody; }
void recalcSectionsIfNeeded() const
{
if (m_needsSectionRecalc)
recalcSections();
}
static RenderTable* createAnonymousWithParentRenderer(const RenderObject*);
virtual RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const OVERRIDE
{
return createAnonymousWithParentRenderer(parent);
}
const BorderValue& tableStartBorderAdjoiningCell(const RenderTableCell*) const;
const BorderValue& tableEndBorderAdjoiningCell(const RenderTableCell*) const;
void addCaption(const RenderTableCaption*);
void removeCaption(const RenderTableCaption*);
void addColumn(const RenderTableCol*);
void removeColumn(const RenderTableCol*);
protected:
virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) OVERRIDE;
virtual void simplifiedNormalFlowLayout() OVERRIDE;
private:
virtual const char* renderName() const OVERRIDE { return "RenderTable"; }
virtual bool isTable() const OVERRIDE { return true; }
virtual bool avoidsFloats() const OVERRIDE { return true; }
virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE;
virtual void paintObject(PaintInfo&, const LayoutPoint&) OVERRIDE;
virtual void paintBoxDecorations(PaintInfo&, const LayoutPoint&) OVERRIDE;
virtual void paintMask(PaintInfo&, const LayoutPoint&) OVERRIDE;
virtual void layout() OVERRIDE;
virtual void computeIntrinsicLogicalWidths(LayoutUnit& minWidth, LayoutUnit& maxWidth) const OVERRIDE;
virtual void computePreferredLogicalWidths() OVERRIDE;
virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE;
virtual int firstLineBoxBaseline() const OVERRIDE;
virtual int inlineBlockBaseline(LineDirectionMode) const OVERRIDE;
RenderTableCol* slowColElement(unsigned col, bool* startEdge, bool* endEdge) const;
void updateColumnCache() const;
void invalidateCachedColumns();
virtual RenderBlock* firstLineBlock() const OVERRIDE;
virtual void updateFirstLetter() OVERRIDE;
virtual void updateLogicalWidth() OVERRIDE;
LayoutUnit convertStyleLogicalWidthToComputedWidth(const Length& styleLogicalWidth, LayoutUnit availableWidth);
LayoutUnit convertStyleLogicalHeightToComputedHeight(const Length& styleLogicalHeight);
virtual LayoutRect overflowClipRect(const LayoutPoint& location, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) OVERRIDE;
virtual void addOverflowFromChildren() OVERRIDE;
void subtractCaptionRect(LayoutRect&) const;
void recalcCollapsedBorders();
void recalcSections() const;
void layoutCaption(RenderTableCaption*);
void distributeExtraLogicalHeight(int extraLogicalHeight);
mutable Vector<int> m_columnPos;
mutable Vector<ColumnStruct> m_columns;
mutable Vector<RenderTableCaption*> m_captions;
mutable Vector<RenderTableCol*> m_columnRenderers;
mutable RenderTableSection* m_head;
mutable RenderTableSection* m_foot;
mutable RenderTableSection* m_firstBody;
OwnPtr<TableLayout> m_tableLayout;
CollapsedBorderValues m_collapsedBorders;
const CollapsedBorderValue* m_currentBorder;
bool m_collapsedBordersValid : 1;
mutable bool m_hasColElements : 1;
mutable bool m_needsSectionRecalc : 1;
bool m_columnLogicalWidthChanged : 1;
mutable bool m_columnRenderersValid: 1;
mutable bool m_hasCellColspanThatDeterminesTableWidth : 1;
bool hasCellColspanThatDeterminesTableWidth() const
{
for (unsigned c = 0; c < numEffCols(); c++) {
if (m_columns[c].span > 1)
return true;
}
return false;
}
short m_hSpacing;
short m_vSpacing;
int m_borderStart;
int m_borderEnd;
};
inline RenderTableSection* RenderTable::topSection() const
{
ASSERT(!needsSectionRecalc());
if (m_head)
return m_head;
if (m_firstBody)
return m_firstBody;
return m_foot;
}
DEFINE_RENDER_OBJECT_TYPE_CASTS(RenderTable, isTable());
}
#endif