Switch baseline values to LayoutUnits in RenderTableSection.
[WebKit-https.git] / 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 enum CollapsedBorderSide {
34     CBSBefore,
35     CBSAfter,
36     CBSStart,
37     CBSEnd
38 };
39
40 // Helper class for paintObject.
41 class CellSpan {
42 public:
43     CellSpan(unsigned start, unsigned end)
44         : m_start(start)
45         , m_end(end)
46     {
47     }
48
49     unsigned start() const { return m_start; }
50     unsigned end() const { return m_end; }
51
52 private:
53     unsigned m_start;
54     unsigned m_end;
55 };
56
57 class RenderTableCell;
58 class RenderTableRow;
59
60 class RenderTableSection : public RenderBox {
61 public:
62     RenderTableSection(Node*);
63     virtual ~RenderTableSection();
64
65     const RenderObjectChildList* children() const { return &m_children; }
66     RenderObjectChildList* children() { return &m_children; }
67
68     virtual void addChild(RenderObject* child, RenderObject* beforeChild = 0);
69
70     virtual LayoutUnit firstLineBoxBaseline() const;
71
72     void addCell(RenderTableCell*, RenderTableRow* row);
73
74     void setCellLogicalWidths();
75     int calcRowLogicalHeight();
76     void layoutRows();
77
78     RenderTable* table() const { return toRenderTable(parent()); }
79
80     struct CellStruct {
81         Vector<RenderTableCell*, 1> cells; 
82         bool inColSpan; // true for columns after the first in a colspan
83
84         CellStruct()
85             : inColSpan(false)
86         {
87         }
88
89         RenderTableCell* primaryCell()
90         {
91             return hasCells() ? cells[cells.size() - 1] : 0;
92         }
93
94         const RenderTableCell* primaryCell() const
95         {
96             return hasCells() ? cells[cells.size() - 1] : 0;
97         }
98
99         bool hasCells() const { return cells.size() > 0; }
100     };
101
102     typedef Vector<CellStruct> Row;
103
104     struct RowStruct {
105         RowStruct()
106             : rowRenderer(0)
107             , baseline()
108         {
109         }
110
111         Row row;
112         RenderTableRow* rowRenderer;
113         LayoutUnit baseline;
114         Length logicalHeight;
115     };
116
117     CellStruct& cellAt(unsigned row,  unsigned col) { return m_grid[row].row[col]; }
118     const CellStruct& cellAt(unsigned row, unsigned col) const { return m_grid[row].row[col]; }
119     RenderTableCell* primaryCellAt(unsigned row, unsigned col)
120     {
121         CellStruct& c = m_grid[row].row[col];
122         return c.primaryCell();
123     }
124
125     void appendColumn(unsigned pos);
126     void splitColumn(unsigned pos, unsigned first);
127
128     int calcOuterBorderBefore() const;
129     int calcOuterBorderAfter() const;
130     int calcOuterBorderStart() const;
131     int calcOuterBorderEnd() const;
132     void recalcOuterBorder();
133
134     int outerBorderBefore() const { return m_outerBorderBefore; }
135     int outerBorderAfter() const { return m_outerBorderAfter; }
136     int outerBorderStart() const { return m_outerBorderStart; }
137     int outerBorderEnd() const { return m_outerBorderEnd; }
138
139     unsigned numRows() const { return m_grid.size(); }
140     unsigned numColumns() const;
141     void recalcCells();
142     void recalcCellsIfNeeded()
143     {
144         if (m_needsCellRecalc)
145             recalcCells();
146     }
147
148     bool needsCellRecalc() const { return m_needsCellRecalc; }
149     void setNeedsCellRecalc();
150
151     LayoutUnit getBaseline(unsigned row) { return m_grid[row].baseline; }
152
153     void rowLogicalHeightChanged(unsigned rowIndex);
154
155     unsigned rowIndexForRenderer(const RenderTableRow*) const;
156
157     void removeCachedCollapsedBorders(const RenderTableCell*);
158     void setCachedCollapsedBorder(const RenderTableCell*, CollapsedBorderSide, CollapsedBorderValue);
159     CollapsedBorderValue& cachedCollapsedBorder(const RenderTableCell*, CollapsedBorderSide);
160
161     // distributeExtraLogicalHeightToRows methods return the *consumed* extra logical height.
162     // FIXME: We may want to introduce a structure holding the in-flux layout information.
163     int distributeExtraLogicalHeightToRows(int extraLogicalHeight);
164
165 protected:
166     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
167
168 private:
169     virtual RenderObjectChildList* virtualChildren() { return children(); }
170     virtual const RenderObjectChildList* virtualChildren() const { return children(); }
171
172     virtual const char* renderName() const { return isAnonymous() ? "RenderTableSection (anonymous)" : "RenderTableSection"; }
173
174     virtual bool isTableSection() const { return true; }
175
176     virtual void willBeDestroyed();
177
178     virtual void layout();
179
180     virtual void removeChild(RenderObject* oldChild);
181
182     virtual void paint(PaintInfo&, const LayoutPoint&);
183     virtual void paintCell(RenderTableCell*, PaintInfo&, const LayoutPoint&);
184     virtual void paintObject(PaintInfo&, const LayoutPoint&);
185
186     virtual void imageChanged(WrappedImagePtr, const IntRect* = 0);
187
188     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
189
190     void ensureRows(unsigned);
191
192     void distributeExtraLogicalHeightToPercentRows(int& extraLogicalHeight, int totalPercent);
193     void distributeExtraLogicalHeightToAutoRows(int& extraLogicalHeight, unsigned autoRowsCount);
194     void distributeRemainingExtraLogicalHeight(int& extraLogicalHeight);
195
196     bool hasOverflowingCell() const { return m_overflowingCells.size() || m_forceSlowPaintPathWithOverflowingCell; }
197
198     CellSpan fullTableRowSpan() const { return CellSpan(0, m_grid.size()); }
199     CellSpan fullTableColumnSpan() const { return CellSpan(0, table()->columns().size()); }
200
201     CellSpan dirtiedRows(const LayoutRect& repaintRect) const;
202     CellSpan dirtiedColumns(const LayoutRect& repaintRect) const;
203
204     RenderObjectChildList m_children;
205
206     Vector<RowStruct> m_grid;
207     Vector<int> m_rowPos;
208
209     // the current insertion position
210     unsigned m_cCol;
211     unsigned m_cRow;
212
213     int m_outerBorderStart;
214     int m_outerBorderEnd;
215     int m_outerBorderBefore;
216     int m_outerBorderAfter;
217
218     bool m_needsCellRecalc;
219
220     // This HashSet holds the overflowing cells for faster painting.
221     // If we have more than gMaxAllowedOverflowingCellRatio * total cells, it will be empty
222     // and m_forceSlowPaintPathWithOverflowingCell will be set to save memory.
223     HashSet<RenderTableCell*> m_overflowingCells;
224     bool m_forceSlowPaintPathWithOverflowingCell;
225
226     bool m_hasMultipleCellLevels;
227
228     // This map holds the collapsed border values for cells with collapsed borders.
229     // It is held at RenderTableSection level to spare memory consumption by table cells.
230     HashMap<pair<const RenderTableCell*, int>, CollapsedBorderValue > m_cellsCollapsedBorders;
231 };
232
233 inline RenderTableSection* toRenderTableSection(RenderObject* object)
234 {
235     ASSERT(!object || object->isTableSection());
236     return static_cast<RenderTableSection*>(object);
237 }
238
239 inline const RenderTableSection* toRenderTableSection(const RenderObject* object)
240 {
241     ASSERT(!object || object->isTableSection());
242     return static_cast<const RenderTableSection*>(object);
243 }
244
245 // This will catch anyone doing an unnecessary cast.
246 void toRenderTableSection(const RenderTableSection*);
247
248 } // namespace WebCore
249
250 #endif // RenderTableSection_h