Source/WebCore/rendering/RenderTableSection.h

   1 /*
   2  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
   3  *           (C) 1997 Torben Weis (weis@kde.org)
   4  *           (C) 1998 Waldo Bastian (bastian@kde.org)
   5  *           (C) 1999 Lars Knoll (knoll@kde.org)
   6  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   7  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public License
  20  * along with this library; see the file COPYING.LIB.  If not, write to
  21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  * Boston, MA 02110-1301, USA.
  23  */
  24
  25 #ifndef RenderTableSection_h
  26 #define RenderTableSection_h
  27
  28 #include "RenderTable.h"
  29 #include <wtf/Vector.h>
  30
  31 namespace WebCore {
  32
  33 class RenderTableCell;
  34 class RenderTableRow;
  35
  36 enum CollapsedBorderSide {
  37     CBSBefore,
  38     CBSAfter,
  39     CBSStart,
  40     CBSEnd
  41 };
  42
  43 // Helper class for paintObject.
  44 struct CellSpan {
  45 public:
  46     CellSpan(unsigned start, unsigned end)
  47         : start(start)
  48         , end(end)
  49     {
  50     }
  51
  52     unsigned start;
  53     unsigned end;
  54 };
  55
  56 class RenderTableSection final : public RenderBox {
  57 public:
  58     RenderTableSection(Element&, RenderStyle&&);
  59     RenderTableSection(Document&, RenderStyle&&);
  60     virtual ~RenderTableSection();
  61
  62     RenderTableRow* firstRow() const;
  63     RenderTableRow* lastRow() const;
  64
  65     void addChild(RenderObject* child, RenderObject* beforeChild = 0) override;
  66
  67     Optional<int> firstLineBaseline() const override;
  68
  69     void addCell(RenderTableCell*, RenderTableRow* row);
  70
  71     LayoutUnit calcRowLogicalHeight();
  72     void layoutRows();
  73     void computeOverflowFromCells();
  74
  75     RenderTable* table() const { return downcast<RenderTable>(parent()); }
  76
  77     struct CellStruct {
  78         Vector<RenderTableCell*, 1> cells;
  79         bool inColSpan { false }; // true for columns after the first in a colspan
  80
  81         RenderTableCell* primaryCell() { return hasCells() ? cells[cells.size() - 1] : 0; }
  82         const RenderTableCell* primaryCell() const { return hasCells() ? cells[cells.size() - 1] : 0; }
  83         bool hasCells() const { return cells.size() > 0; }
  84     };
  85
  86     typedef Vector<CellStruct> Row;
  87     struct RowStruct {
  88         Row row;
  89         RenderTableRow* rowRenderer { nullptr };
  90         LayoutUnit baseline;
  91         Length logicalHeight;
  92     };
  93
  94     const BorderValue& borderAdjoiningTableStart() const;
  95     const BorderValue& borderAdjoiningTableEnd() const;
  96     const BorderValue& borderAdjoiningStartCell(const RenderTableCell&) const;
  97     const BorderValue& borderAdjoiningEndCell(const RenderTableCell&) const;
  98
  99     const RenderTableCell* firstRowCellAdjoiningTableStart() const;
 100     const RenderTableCell* firstRowCellAdjoiningTableEnd() const;
 101
 102     CellStruct& cellAt(unsigned row,  unsigned col);
 103     const CellStruct& cellAt(unsigned row, unsigned col) const;
 104     RenderTableCell* primaryCellAt(unsigned row, unsigned col);
 105     RenderTableRow* rowRendererAt(unsigned row) const;
 106
 107     void appendColumn(unsigned pos);
 108     void splitColumn(unsigned pos, unsigned first);
 109
 110     LayoutUnit calcOuterBorderBefore() const;
 111     LayoutUnit calcOuterBorderAfter() const;
 112     LayoutUnit calcOuterBorderStart() const;
 113     LayoutUnit calcOuterBorderEnd() const;
 114     void recalcOuterBorder();
 115
 116     LayoutUnit outerBorderBefore() const { return m_outerBorderBefore; }
 117     LayoutUnit outerBorderAfter() const { return m_outerBorderAfter; }
 118     LayoutUnit outerBorderStart() const { return m_outerBorderStart; }
 119     LayoutUnit outerBorderEnd() const { return m_outerBorderEnd; }
 120
 121     LayoutUnit outerBorderLeft(const RenderStyle* styleForCellFlow) const;
 122     LayoutUnit outerBorderRight(const RenderStyle* styleForCellFlow) const;
 123     LayoutUnit outerBorderTop(const RenderStyle* styleForCellFlow) const;
 124     LayoutUnit outerBorderBottom(const RenderStyle* styleForCellFlow) const;
 125
 126     unsigned numRows() const;
 127     unsigned numColumns() const;
 128     void recalcCells();
 129     void recalcCellsIfNeeded();
 130
 131     bool needsCellRecalc() const { return m_needsCellRecalc; }
 132     void setNeedsCellRecalc();
 133
 134     LayoutUnit rowBaseline(unsigned row);
 135     void rowLogicalHeightChanged(unsigned rowIndex);
 136
 137     void clearCachedCollapsedBorders();
 138     void removeCachedCollapsedBorders(const RenderTableCell&);
 139     void setCachedCollapsedBorder(const RenderTableCell&, CollapsedBorderSide, CollapsedBorderValue);
 140     CollapsedBorderValue cachedCollapsedBorder(const RenderTableCell&, CollapsedBorderSide);
 141
 142     // distributeExtraLogicalHeightToRows methods return the *consumed* extra logical height.
 143     // FIXME: We may want to introduce a structure holding the in-flux layout information.
 144     LayoutUnit distributeExtraLogicalHeightToRows(LayoutUnit extraLogicalHeight);
 145
 146     static RenderTableSection* createAnonymousWithParentRenderer(const RenderObject*);
 147     RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const override { return createAnonymousWithParentRenderer(parent); }
 148
 149     void paint(PaintInfo&, const LayoutPoint&) override;
 150
 151 protected:
 152     void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
 153
 154 private:
 155     enum ShouldIncludeAllIntersectingCells {
 156         IncludeAllIntersectingCells,
 157         DoNotIncludeAllIntersectingCells
 158     };
 159
 160     const char* renderName() const override { return (isAnonymous() || isPseudoElement()) ? "RenderTableSection (anonymous)" : "RenderTableSection"; }
 161
 162     bool canHaveChildren() const override { return true; }
 163
 164     bool isTableSection() const override { return true; }
 165
 166     void willBeRemovedFromTree() override;
 167
 168     void layout() override;
 169
 170     void paintCell(RenderTableCell*, PaintInfo&, const LayoutPoint&);
 171     void paintObject(PaintInfo&, const LayoutPoint&) override;
 172     void paintRowGroupBorder(const PaintInfo&, bool antialias, LayoutRect, BoxSide, CSSPropertyID borderColor, EBorderStyle, EBorderStyle tableBorderStyle);
 173     void paintRowGroupBorderIfRequired(const PaintInfo&, const LayoutPoint& paintOffset, unsigned row, unsigned col, BoxSide, RenderTableCell* = 0);
 174     LayoutUnit offsetLeftForRowGroupBorder(RenderTableCell*, const LayoutRect& rowGroupRect, unsigned row);
 175
 176     LayoutUnit offsetTopForRowGroupBorder(RenderTableCell*, BoxSide borderSide, unsigned row);
 177     LayoutUnit verticalRowGroupBorderHeight(RenderTableCell*, const LayoutRect& rowGroupRect, unsigned row);
 178     LayoutUnit horizontalRowGroupBorderWidth(RenderTableCell*, const LayoutRect& rowGroupRect, unsigned row, unsigned column);
 179
 180     void imageChanged(WrappedImagePtr, const IntRect* = 0) override;
 181
 182     bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
 183
 184     void ensureRows(unsigned);
 185
 186     void distributeExtraLogicalHeightToPercentRows(LayoutUnit& extraLogicalHeight, int totalPercent);
 187     void distributeExtraLogicalHeightToAutoRows(LayoutUnit& extraLogicalHeight, unsigned autoRowsCount);
 188     void distributeRemainingExtraLogicalHeight(LayoutUnit& extraLogicalHeight);
 189
 190     bool hasOverflowingCell() const { return m_overflowingCells.size() || m_forceSlowPaintPathWithOverflowingCell; }
 191     void computeOverflowFromCells(unsigned totalRows, unsigned nEffCols);
 192
 193     CellSpan fullTableRowSpan() const;
 194     CellSpan fullTableColumnSpan() const { return CellSpan(0, table()->columns().size()); }
 195
 196     // Flip the rect so it aligns with the coordinates used by the rowPos and columnPos vectors.
 197     LayoutRect logicalRectForWritingModeAndDirection(const LayoutRect&) const;
 198
 199     CellSpan dirtiedRows(const LayoutRect& repaintRect) const;
 200     CellSpan dirtiedColumns(const LayoutRect& repaintRect) const;
 201
 202     // These two functions take a rectangle as input that has been flipped by logicalRectForWritingModeAndDirection.
 203     // The returned span of rows or columns is end-exclusive, and empty if start==end.
 204     // The IncludeAllIntersectingCells argument is used to determine which cells to include when
 205     // an edge of the flippedRect lies exactly on a cell boundary. Using IncludeAllIntersectingCells
 206     // will return both cells, and using DoNotIncludeAllIntersectingCells will return only the cell
 207     // that hittesting should return.
 208     CellSpan spannedRows(const LayoutRect& flippedRect, ShouldIncludeAllIntersectingCells) const;
 209     CellSpan spannedColumns(const LayoutRect& flippedRect, ShouldIncludeAllIntersectingCells) const;
 210
 211     void setLogicalPositionForCell(RenderTableCell*, unsigned effectiveColumn) const;
 212
 213     void firstChild() const = delete;
 214     void lastChild() const = delete;
 215
 216     Vector<RowStruct> m_grid;
 217     Vector<LayoutUnit> m_rowPos;
 218
 219     // the current insertion position
 220     unsigned m_cCol { 0 };
 221     unsigned m_cRow  { 0 };
 222
 223     LayoutUnit m_outerBorderStart;
 224     LayoutUnit m_outerBorderEnd;
 225     LayoutUnit m_outerBorderBefore;
 226     LayoutUnit m_outerBorderAfter;
 227
 228     bool m_needsCellRecalc  { false };
 229
 230     // This HashSet holds the overflowing cells for faster painting.
 231     // If we have more than gMaxAllowedOverflowingCellRatio * total cells, it will be empty
 232     // and m_forceSlowPaintPathWithOverflowingCell will be set to save memory.
 233     HashSet<RenderTableCell*> m_overflowingCells;
 234     bool m_forceSlowPaintPathWithOverflowingCell { false };
 235
 236     bool m_hasMultipleCellLevels { false };
 237
 238     // This map holds the collapsed border values for cells with collapsed borders.
 239     // It is held at RenderTableSection level to spare memory consumption by table cells.
 240     HashMap<std::pair<const RenderTableCell*, int>, CollapsedBorderValue > m_cellsCollapsedBorders;
 241 };
 242
 243 inline const BorderValue& RenderTableSection::borderAdjoiningTableStart() const
 244 {
 245     if (isDirectionSame(this, table()))
 246         return style().borderStart();
 247     return style().borderEnd();
 248 }
 249
 250 inline const BorderValue& RenderTableSection::borderAdjoiningTableEnd() const
 251 {
 252     if (isDirectionSame(this, table()))
 253         return style().borderEnd();
 254     return style().borderStart();
 255 }
 256
 257 inline RenderTableSection::CellStruct& RenderTableSection::cellAt(unsigned row,  unsigned col)
 258 {
 259     recalcCellsIfNeeded();
 260     return m_grid[row].row[col];
 261 }
 262
 263 inline const RenderTableSection::CellStruct& RenderTableSection::cellAt(unsigned row, unsigned col) const
 264 {
 265     ASSERT(!m_needsCellRecalc);
 266     return m_grid[row].row[col];
 267 }
 268
 269 inline RenderTableCell* RenderTableSection::primaryCellAt(unsigned row, unsigned col)
 270 {
 271     recalcCellsIfNeeded();
 272     CellStruct& c = m_grid[row].row[col];
 273     return c.primaryCell();
 274 }
 275
 276 inline RenderTableRow* RenderTableSection::rowRendererAt(unsigned row) const
 277 {
 278     ASSERT(!m_needsCellRecalc);
 279     return m_grid[row].rowRenderer;
 280 }
 281
 282 inline LayoutUnit RenderTableSection::outerBorderLeft(const RenderStyle* styleForCellFlow) const
 283 {
 284     if (styleForCellFlow->isHorizontalWritingMode())
 285         return styleForCellFlow->isLeftToRightDirection() ? outerBorderStart() : outerBorderEnd();
 286     return styleForCellFlow->isFlippedBlocksWritingMode() ? outerBorderAfter() : outerBorderBefore();
 287 }
 288
 289 inline LayoutUnit RenderTableSection::outerBorderRight(const RenderStyle* styleForCellFlow) const
 290 {
 291     if (styleForCellFlow->isHorizontalWritingMode())
 292         return styleForCellFlow->isLeftToRightDirection() ? outerBorderEnd() : outerBorderStart();
 293     return styleForCellFlow->isFlippedBlocksWritingMode() ? outerBorderBefore() : outerBorderAfter();
 294 }
 295
 296 inline LayoutUnit RenderTableSection::outerBorderTop(const RenderStyle* styleForCellFlow) const
 297 {
 298     if (styleForCellFlow->isHorizontalWritingMode())
 299         return styleForCellFlow->isFlippedBlocksWritingMode() ? outerBorderAfter() : outerBorderBefore();
 300     return styleForCellFlow->isLeftToRightDirection() ? outerBorderStart() : outerBorderEnd();
 301 }
 302
 303 inline LayoutUnit RenderTableSection::outerBorderBottom(const RenderStyle* styleForCellFlow) const
 304 {
 305     if (styleForCellFlow->isHorizontalWritingMode())
 306         return styleForCellFlow->isFlippedBlocksWritingMode() ? outerBorderBefore() : outerBorderAfter();
 307     return styleForCellFlow->isLeftToRightDirection() ? outerBorderEnd() : outerBorderStart();
 308 }
 309
 310 inline unsigned RenderTableSection::numRows() const
 311 {
 312     ASSERT(!m_needsCellRecalc);
 313     return m_grid.size();
 314 }
 315
 316 inline void RenderTableSection::recalcCellsIfNeeded()
 317 {
 318     if (m_needsCellRecalc)
 319         recalcCells();
 320 }
 321
 322 inline LayoutUnit RenderTableSection::rowBaseline(unsigned row)
 323 {
 324     recalcCellsIfNeeded();
 325     return m_grid[row].baseline;
 326 }
 327
 328 inline CellSpan RenderTableSection::fullTableRowSpan() const
 329 {
 330     ASSERT(!m_needsCellRecalc);
 331     return CellSpan(0, m_grid.size());
 332 }
 333
 334 } // namespace WebCore
 335
 336 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderTableSection, isTableSection())
 337
 338 #endif // RenderTableSection_h