Tighten table rendering code
[WebKit-https.git] / Source / WebCore / rendering / RenderTableCell.cpp
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, 2007, 2008, 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 #include "config.h"
26 #include "RenderTableCell.h"
27
28 #include "CollapsedBorderValue.h"
29 #include "FloatQuad.h"
30 #include "GraphicsContext.h"
31 #include "HTMLNames.h"
32 #include "HTMLTableCellElement.h"
33 #include "PaintInfo.h"
34 #include "RenderTableCol.h"
35 #include "RenderView.h"
36 #include "StylePropertySet.h"
37 #include "TransformState.h"
38 #include <wtf/StackStats.h>
39
40 #if ENABLE(MATHML)
41 #include "MathMLElement.h"
42 #include "MathMLNames.h"
43 #endif
44
45 using namespace std;
46
47 namespace WebCore {
48
49 using namespace HTMLNames;
50
51 struct SameSizeAsRenderTableCell : public RenderBlockFlow {
52     unsigned bitfields;
53     int paddings[2];
54 };
55
56 COMPILE_ASSERT(sizeof(RenderTableCell) == sizeof(SameSizeAsRenderTableCell), RenderTableCell_should_stay_small);
57 COMPILE_ASSERT(sizeof(CollapsedBorderValue) == 8, CollapsedBorderValue_should_stay_small);
58
59 RenderTableCell::RenderTableCell(Element* element)
60     : RenderBlockFlow(element)
61     , m_column(unsetColumnIndex)
62     , m_cellWidthChanged(false)
63     , m_intrinsicPaddingBefore(0)
64     , m_intrinsicPaddingAfter(0)
65 {
66     // We only update the flags when notified of DOM changes in colSpanOrRowSpanChanged()
67     // so we need to set their initial values here in case something asks for colSpan()/rowSpan() before then.
68     updateColAndRowSpanFlags();
69 }
70
71 void RenderTableCell::willBeRemovedFromTree()
72 {
73     RenderBlock::willBeRemovedFromTree();
74
75     section()->setNeedsCellRecalc();
76     section()->removeCachedCollapsedBorders(this);
77 }
78
79 unsigned RenderTableCell::parseColSpanFromDOM() const
80 {
81     ASSERT(element());
82     if (element()->hasTagName(tdTag) || element()->hasTagName(thTag))
83         return min<unsigned>(toHTMLTableCellElement(element())->colSpan(), maxColumnIndex);
84 #if ENABLE(MATHML)
85     if (element()->hasTagName(MathMLNames::mtdTag))
86         return min<unsigned>(toMathMLElement(element())->colSpan(), maxColumnIndex);
87 #endif
88     return 1;
89 }
90
91 unsigned RenderTableCell::parseRowSpanFromDOM() const
92 {
93     ASSERT(element());
94     if (element()->hasTagName(tdTag) || element()->hasTagName(thTag))
95         return min<unsigned>(toHTMLTableCellElement(element())->rowSpan(), maxRowIndex);
96 #if ENABLE(MATHML)
97     if (element()->hasTagName(MathMLNames::mtdTag))
98         return min<unsigned>(toMathMLElement(element())->rowSpan(), maxRowIndex);
99 #endif
100     return 1;
101 }
102
103 void RenderTableCell::updateColAndRowSpanFlags()
104 {
105     // The vast majority of table cells do not have a colspan or rowspan,
106     // so we keep a bool to know if we need to bother reading from the DOM.
107     m_hasColSpan = element() && parseColSpanFromDOM() != 1;
108     m_hasRowSpan = element() && parseRowSpanFromDOM() != 1;
109 }
110
111 void RenderTableCell::colSpanOrRowSpanChanged()
112 {
113     ASSERT(element());
114 #if ENABLE(MATHML)
115     ASSERT(element()->hasTagName(tdTag) || element()->hasTagName(thTag) || element()->hasTagName(MathMLNames::mtdTag));
116 #else
117     ASSERT(element()->hasTagName(tdTag) || element()->hasTagName(thTag));
118 #endif
119
120     updateColAndRowSpanFlags();
121
122     // FIXME: I suspect that we could return early here if !m_hasColSpan && !m_hasRowSpan.
123
124     setNeedsLayoutAndPrefWidthsRecalc();
125     if (parent() && section())
126         section()->setNeedsCellRecalc();
127 }
128
129 Length RenderTableCell::logicalWidthFromColumns(RenderTableCol* firstColForThisCell, Length widthFromStyle) const
130 {
131     ASSERT(firstColForThisCell && firstColForThisCell == table()->colElement(col()));
132     RenderTableCol* tableCol = firstColForThisCell;
133
134     unsigned colSpanCount = colSpan();
135     int colWidthSum = 0;
136     for (unsigned i = 1; i <= colSpanCount; i++) {
137         Length colWidth = tableCol->style()->logicalWidth();
138
139         // Percentage value should be returned only for colSpan == 1.
140         // Otherwise we return original width for the cell.
141         if (!colWidth.isFixed()) {
142             if (colSpanCount > 1)
143                 return widthFromStyle;
144             return colWidth;
145         }
146
147         colWidthSum += colWidth.value();
148         tableCol = tableCol->nextColumn();
149         // If no next <col> tag found for the span we just return what we have for now.
150         if (!tableCol)
151             break;
152     }
153
154     // Column widths specified on <col> apply to the border box of the cell, see bug 8126.
155     // FIXME: Why is border/padding ignored in the negative width case?
156     if (colWidthSum > 0)
157         return Length(max(0, colWidthSum - borderAndPaddingLogicalWidth().ceil()), Fixed);
158     return Length(colWidthSum, Fixed);
159 }
160
161 void RenderTableCell::computePreferredLogicalWidths()
162 {
163     // The child cells rely on the grids up in the sections to do their computePreferredLogicalWidths work.  Normally the sections are set up early, as table
164     // cells are added, but relayout can cause the cells to be freed, leaving stale pointers in the sections'
165     // grids.  We must refresh those grids before the child cells try to use them.
166     table()->recalcSectionsIfNeeded();
167
168     RenderBlock::computePreferredLogicalWidths();
169     if (element() && style()->autoWrap()) {
170         // See if nowrap was set.
171         Length w = styleOrColLogicalWidth();
172         String nowrap = element()->getAttribute(nowrapAttr);
173         if (!nowrap.isNull() && w.isFixed())
174             // Nowrap is set, but we didn't actually use it because of the
175             // fixed width set on the cell.  Even so, it is a WinIE/Moz trait
176             // to make the minwidth of the cell into the fixed width.  They do this
177             // even in strict mode, so do not make this a quirk.  Affected the top
178             // of hiptop.com.
179             m_minPreferredLogicalWidth = max<LayoutUnit>(w.value(), m_minPreferredLogicalWidth);
180     }
181 }
182
183 void RenderTableCell::computeIntrinsicPadding(int rowHeight)
184 {
185     int oldIntrinsicPaddingBefore = intrinsicPaddingBefore();
186     int oldIntrinsicPaddingAfter = intrinsicPaddingAfter();
187     int logicalHeightWithoutIntrinsicPadding = pixelSnappedLogicalHeight() - oldIntrinsicPaddingBefore - oldIntrinsicPaddingAfter;
188
189     int intrinsicPaddingBefore = 0;
190     switch (style()->verticalAlign()) {
191     case SUB:
192     case SUPER:
193     case TEXT_TOP:
194     case TEXT_BOTTOM:
195     case LENGTH:
196     case BASELINE: {
197         LayoutUnit baseline = cellBaselinePosition();
198         if (baseline > borderAndPaddingBefore())
199             intrinsicPaddingBefore = section()->rowBaseline(rowIndex()) - (baseline - oldIntrinsicPaddingBefore);
200         break;
201     }
202     case TOP:
203         break;
204     case MIDDLE:
205         intrinsicPaddingBefore = (rowHeight - logicalHeightWithoutIntrinsicPadding) / 2;
206         break;
207     case BOTTOM:
208         intrinsicPaddingBefore = rowHeight - logicalHeightWithoutIntrinsicPadding;
209         break;
210     case BASELINE_MIDDLE:
211         break;
212     }
213
214     int intrinsicPaddingAfter = rowHeight - logicalHeightWithoutIntrinsicPadding - intrinsicPaddingBefore;
215     setIntrinsicPaddingBefore(intrinsicPaddingBefore);
216     setIntrinsicPaddingAfter(intrinsicPaddingAfter);
217
218     // FIXME: Changing an intrinsic padding shouldn't trigger a relayout as it only shifts the cell inside the row but
219     // doesn't change the logical height.
220     if (intrinsicPaddingBefore != oldIntrinsicPaddingBefore || intrinsicPaddingAfter != oldIntrinsicPaddingAfter)
221         setNeedsLayout(true, MarkOnlyThis);
222 }
223
224 void RenderTableCell::updateLogicalWidth()
225 {
226 }
227
228 void RenderTableCell::setCellLogicalWidth(int tableLayoutLogicalWidth)
229 {
230     if (tableLayoutLogicalWidth == logicalWidth())
231         return;
232
233     setNeedsLayout(true, MarkOnlyThis);
234     row()->setChildNeedsLayout(true, MarkOnlyThis);
235
236     if (!table()->selfNeedsLayout() && checkForRepaintDuringLayout())
237         repaint();
238
239     setLogicalWidth(tableLayoutLogicalWidth);
240     setCellWidthChanged(true);
241 }
242
243 void RenderTableCell::layout()
244 {
245     StackStats::LayoutCheckPoint layoutCheckPoint;
246     updateFirstLetter();
247
248     int oldCellBaseline = cellBaselinePosition();
249     layoutBlock(cellWidthChanged());
250
251     // If we have replaced content, the intrinsic height of our content may have changed since the last time we laid out. If that's the case the intrinsic padding we used
252     // for layout (the padding required to push the contents of the cell down to the row's baseline) is included in our new height and baseline and makes both
253     // of them wrong. So if our content's intrinsic height has changed push the new content up into the intrinsic padding and relayout so that the rest of
254     // table and row layout can use the correct baseline and height for this cell.
255     if (isBaselineAligned() && section()->rowBaseline(rowIndex()) && cellBaselinePosition() > section()->rowBaseline(rowIndex())) {
256         int newIntrinsicPaddingBefore = max<LayoutUnit>(0, intrinsicPaddingBefore() - max<LayoutUnit>(0, cellBaselinePosition() - oldCellBaseline));
257         setIntrinsicPaddingBefore(newIntrinsicPaddingBefore);
258         setNeedsLayout(true, MarkOnlyThis);
259         layoutBlock(cellWidthChanged());
260     }
261
262     setCellWidthChanged(false);
263 }
264
265 LayoutUnit RenderTableCell::paddingTop() const
266 {
267     int result = computedCSSPaddingTop();
268     if (!isHorizontalWritingMode())
269         return result;
270     return result + (style()->writingMode() == TopToBottomWritingMode ? intrinsicPaddingBefore() : intrinsicPaddingAfter());
271 }
272
273 LayoutUnit RenderTableCell::paddingBottom() const
274 {
275     int result = computedCSSPaddingBottom();
276     if (!isHorizontalWritingMode())
277         return result;
278     return result + (style()->writingMode() == TopToBottomWritingMode ? intrinsicPaddingAfter() : intrinsicPaddingBefore());
279 }
280
281 LayoutUnit RenderTableCell::paddingLeft() const
282 {
283     int result = computedCSSPaddingLeft();
284     if (isHorizontalWritingMode())
285         return result;
286     return result + (style()->writingMode() == LeftToRightWritingMode ? intrinsicPaddingBefore() : intrinsicPaddingAfter());
287 }
288
289 LayoutUnit RenderTableCell::paddingRight() const
290 {   
291     int result = computedCSSPaddingRight();
292     if (isHorizontalWritingMode())
293         return result;
294     return result + (style()->writingMode() == LeftToRightWritingMode ? intrinsicPaddingAfter() : intrinsicPaddingBefore());
295 }
296
297 LayoutUnit RenderTableCell::paddingBefore() const
298 {
299     return static_cast<int>(computedCSSPaddingBefore()) + intrinsicPaddingBefore();
300 }
301
302 LayoutUnit RenderTableCell::paddingAfter() const
303 {
304     return static_cast<int>(computedCSSPaddingAfter()) + intrinsicPaddingAfter();
305 }
306
307 void RenderTableCell::setOverrideLogicalContentHeightFromRowHeight(LayoutUnit rowHeight)
308 {
309     clearIntrinsicPadding();
310     setOverrideLogicalContentHeight(max<LayoutUnit>(0, rowHeight - borderAndPaddingLogicalHeight()));
311 }
312
313 LayoutSize RenderTableCell::offsetFromContainer(RenderObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const
314 {
315     ASSERT(o == container());
316
317     LayoutSize offset = RenderBlock::offsetFromContainer(o, point, offsetDependsOnPoint);
318     if (parent())
319         offset -= parentBox()->locationOffset();
320
321     return offset;
322 }
323
324 LayoutRect RenderTableCell::clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const
325 {
326     // If the table grid is dirty, we cannot get reliable information about adjoining cells,
327     // so we ignore outside borders. This should not be a problem because it means that
328     // the table is going to recalculate the grid, relayout and repaint its current rect, which
329     // includes any outside borders of this cell.
330     if (!table()->collapseBorders() || table()->needsSectionRecalc())
331         return RenderBlock::clippedOverflowRectForRepaint(repaintContainer);
332
333     bool rtl = !styleForCellFlow()->isLeftToRightDirection();
334     int outlineSize = style()->outlineSize();
335     int left = max(borderHalfLeft(true), outlineSize);
336     int right = max(borderHalfRight(true), outlineSize);
337     int top = max(borderHalfTop(true), outlineSize);
338     int bottom = max(borderHalfBottom(true), outlineSize);
339     if ((left && !rtl) || (right && rtl)) {
340         if (RenderTableCell* before = table()->cellBefore(this)) {
341             top = max(top, before->borderHalfTop(true));
342             bottom = max(bottom, before->borderHalfBottom(true));
343         }
344     }
345     if ((left && rtl) || (right && !rtl)) {
346         if (RenderTableCell* after = table()->cellAfter(this)) {
347             top = max(top, after->borderHalfTop(true));
348             bottom = max(bottom, after->borderHalfBottom(true));
349         }
350     }
351     if (top) {
352         if (RenderTableCell* above = table()->cellAbove(this)) {
353             left = max(left, above->borderHalfLeft(true));
354             right = max(right, above->borderHalfRight(true));
355         }
356     }
357     if (bottom) {
358         if (RenderTableCell* below = table()->cellBelow(this)) {
359             left = max(left, below->borderHalfLeft(true));
360             right = max(right, below->borderHalfRight(true));
361         }
362     }
363     LayoutPoint location(max<LayoutUnit>(left, -visualOverflowRect().x()), max<LayoutUnit>(top, -visualOverflowRect().y()));
364     LayoutRect r(-location.x(), -location.y(), location.x() + max(width() + right, visualOverflowRect().maxX()), location.y() + max(height() + bottom, visualOverflowRect().maxY()));
365
366     // FIXME: layoutDelta needs to be applied in parts before/after transforms and
367     // repaint containers. https://bugs.webkit.org/show_bug.cgi?id=23308
368     r.move(view().layoutDelta());
369
370     computeRectForRepaint(repaintContainer, r);
371     return r;
372 }
373
374 void RenderTableCell::computeRectForRepaint(const RenderLayerModelObject* repaintContainer, LayoutRect& r, bool fixed) const
375 {
376     if (repaintContainer == this)
377         return;
378     r.setY(r.y());
379     if ((!view().layoutStateEnabled() || repaintContainer) && parent())
380         r.moveBy(-parentBox()->location()); // Rows are in the same coordinate space, so don't add their offset in.
381     RenderBlock::computeRectForRepaint(repaintContainer, r, fixed);
382 }
383
384 LayoutUnit RenderTableCell::cellBaselinePosition() const
385 {
386     // <http://www.w3.org/TR/2007/CR-CSS21-20070719/tables.html#height-layout>: The baseline of a cell is the baseline of
387     // the first in-flow line box in the cell, or the first in-flow table-row in the cell, whichever comes first. If there
388     // is no such line box or table-row, the baseline is the bottom of content edge of the cell box.
389     LayoutUnit firstLineBaseline = firstLineBoxBaseline();
390     if (firstLineBaseline != -1)
391         return firstLineBaseline;
392     return borderAndPaddingBefore() + contentLogicalHeight();
393 }
394
395 void RenderTableCell::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
396 {
397     ASSERT(style()->display() == TABLE_CELL);
398     ASSERT(!row() || row()->rowIndexWasSet());
399
400     RenderBlock::styleDidChange(diff, oldStyle);
401     setHasBoxDecorations(true);
402
403     if (parent() && section() && oldStyle && style()->height() != oldStyle->height())
404         section()->rowLogicalHeightChanged(rowIndex());
405
406     // Our intrinsic padding pushes us down to align with the baseline of other cells on the row. If our vertical-align
407     // has changed then so will the padding needed to align with other cells - clear it so we can recalculate it from scratch.
408     if (oldStyle && style()->verticalAlign() != oldStyle->verticalAlign())
409         clearIntrinsicPadding();
410
411     // If border was changed, notify table.
412     if (parent()) {
413         RenderTable* table = this->table();
414         if (table && !table->selfNeedsLayout() && !table->normalChildNeedsLayout()&& oldStyle && oldStyle->border() != style()->border())
415             table->invalidateCollapsedBorders();
416     }
417 }
418
419 // The following rules apply for resolving conflicts and figuring out which border
420 // to use.
421 // (1) Borders with the 'border-style' of 'hidden' take precedence over all other conflicting 
422 // borders. Any border with this value suppresses all borders at this location.
423 // (2) Borders with a style of 'none' have the lowest priority. Only if the border properties of all 
424 // the elements meeting at this edge are 'none' will the border be omitted (but note that 'none' is 
425 // the default value for the border style.)
426 // (3) If none of the styles are 'hidden' and at least one of them is not 'none', then narrow borders 
427 // are discarded in favor of wider ones. If several have the same 'border-width' then styles are preferred 
428 // in this order: 'double', 'solid', 'dashed', 'dotted', 'ridge', 'outset', 'groove', and the lowest: 'inset'.
429 // (4) If border styles differ only in color, then a style set on a cell wins over one on a row, 
430 // which wins over a row group, column, column group and, lastly, table. It is undefined which color 
431 // is used when two elements of the same type disagree.
432 static int compareBorders(const CollapsedBorderValue& border1, const CollapsedBorderValue& border2)
433 {
434     // Sanity check the values passed in. The null border have lowest priority.
435     if (!border2.exists()) {
436         if (!border1.exists())
437             return 0;
438         return 1;
439     }
440     if (!border1.exists())
441         return -1;
442
443     // Rule #1 above.
444     if (border2.style() == BHIDDEN) {
445         if (border1.style() == BHIDDEN)
446             return 0;
447         return -1;
448     }
449     if (border1.style() == BHIDDEN)
450         return 1;
451     
452     // Rule #2 above.  A style of 'none' has lowest priority and always loses to any other border.
453     if (border2.style() == BNONE) {
454         if (border1.style() == BNONE)
455             return 0;
456         return 1;
457     }
458     if (border1.style() == BNONE)
459         return -1;
460
461     // The first part of rule #3 above. Wider borders win.
462     if (border1.width() != border2.width())
463         return border1.width() < border2.width() ? -1 : 1;
464     
465     // The borders have equal width.  Sort by border style.
466     if (border1.style() != border2.style())
467         return border1.style() < border2.style() ? -1 : 1;
468     
469     // The border have the same width and style.  Rely on precedence (cell over row over row group, etc.)
470     if (border1.precedence() == border2.precedence())
471         return 0;
472     return border1.precedence() < border2.precedence() ? -1 : 1;
473 }
474
475 static CollapsedBorderValue chooseBorder(const CollapsedBorderValue& border1, const CollapsedBorderValue& border2)
476 {
477     const CollapsedBorderValue& border = compareBorders(border1, border2) < 0 ? border2 : border1;
478     return border.style() == BHIDDEN ? CollapsedBorderValue() : border;
479 }
480
481 bool RenderTableCell::hasStartBorderAdjoiningTable() const
482 {
483     bool isStartColumn = !col();
484     bool isEndColumn = table()->colToEffCol(col() + colSpan() - 1) == table()->numEffCols() - 1;
485     bool hasSameDirectionAsTable = hasSameDirectionAs(section());
486
487     // The table direction determines the row direction. In mixed directionality, we cannot guarantee that
488     // we have a common border with the table (think a ltr table with rtl start cell).
489     return (isStartColumn && hasSameDirectionAsTable) || (isEndColumn && !hasSameDirectionAsTable);
490 }
491
492 bool RenderTableCell::hasEndBorderAdjoiningTable() const
493 {
494     bool isStartColumn = !col();
495     bool isEndColumn = table()->colToEffCol(col() + colSpan() - 1) == table()->numEffCols() - 1;
496     bool hasSameDirectionAsTable = hasSameDirectionAs(section());
497
498     // The table direction determines the row direction. In mixed directionality, we cannot guarantee that
499     // we have a common border with the table (think a ltr table with ltr end cell).
500     return (isStartColumn && !hasSameDirectionAsTable) || (isEndColumn && hasSameDirectionAsTable);
501 }
502
503 CollapsedBorderValue RenderTableCell::collapsedStartBorder(IncludeBorderColorOrNot includeColor) const
504 {
505     CollapsedBorderValue result = computeCollapsedStartBorder(includeColor);
506     if (includeColor)
507         section()->setCachedCollapsedBorder(this, CBSStart, result);
508     return result;
509 }
510
511 CollapsedBorderValue RenderTableCell::computeCollapsedStartBorder(IncludeBorderColorOrNot includeColor) const
512 {
513     RenderTable* table = this->table();
514
515     // For the start border, we need to check, in order of precedence:
516     // (1) Our start border.
517     int startColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderStartColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
518     int endColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderEndColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
519     CollapsedBorderValue result(style()->borderStart(), includeColor ? style()->visitedDependentColor(startColorProperty) : Color(), BCELL);
520
521     // (2) The end border of the preceding cell.
522     RenderTableCell* cellBefore = table->cellBefore(this);
523     if (cellBefore) {
524         CollapsedBorderValue cellBeforeAdjoiningBorder = CollapsedBorderValue(cellBefore->borderAdjoiningCellAfter(this), includeColor ? cellBefore->style()->visitedDependentColor(endColorProperty) : Color(), BCELL);
525         // |result| should be the 2nd argument as |cellBefore| should win in case of equality per CSS 2.1 (Border conflict resolution, point 4).
526         result = chooseBorder(cellBeforeAdjoiningBorder, result);
527         if (!result.exists())
528             return result;
529     }
530
531     bool startBorderAdjoinsTable = hasStartBorderAdjoiningTable();
532     if (startBorderAdjoinsTable) {
533         // (3) Our row's start border.
534         result = chooseBorder(result, CollapsedBorderValue(row()->borderAdjoiningStartCell(this), includeColor ? parent()->style()->visitedDependentColor(startColorProperty) : Color(), BROW));
535         if (!result.exists())
536             return result;
537
538         // (4) Our row group's start border.
539         result = chooseBorder(result, CollapsedBorderValue(section()->borderAdjoiningStartCell(this), includeColor ? section()->style()->visitedDependentColor(startColorProperty) : Color(), BROWGROUP));
540         if (!result.exists())
541             return result;
542     }
543     
544     // (5) Our column and column group's start borders.
545     bool startColEdge;
546     bool endColEdge;
547     if (RenderTableCol* colElt = table->colElement(col(), &startColEdge, &endColEdge)) {
548         if (colElt->isTableColumnGroup() && startColEdge) {
549             // The |colElt| is a column group and is also the first colgroup (in case of spanned colgroups).
550             result = chooseBorder(result, CollapsedBorderValue(colElt->borderAdjoiningCellStartBorder(this), includeColor ? colElt->style()->visitedDependentColor(startColorProperty) : Color(), BCOLGROUP));
551             if (!result.exists())
552                 return result;
553         } else if (!colElt->isTableColumnGroup()) {
554             // We first consider the |colElt| and irrespective of whether it is a spanned col or not, we apply
555             // its start border. This is as per HTML5 which states that: "For the purposes of the CSS table model,
556             // the col element is expected to be treated as if it was present as many times as its span attribute specifies".
557             result = chooseBorder(result, CollapsedBorderValue(colElt->borderAdjoiningCellStartBorder(this), includeColor ? colElt->style()->visitedDependentColor(startColorProperty) : Color(), BCOL));
558             if (!result.exists())
559                 return result;
560             // Next, apply the start border of the enclosing colgroup but only if it is adjacent to the cell's edge.
561             if (RenderTableCol* enclosingColumnGroup = colElt->enclosingColumnGroupIfAdjacentBefore()) {
562                 result = chooseBorder(result, CollapsedBorderValue(enclosingColumnGroup->borderAdjoiningCellStartBorder(this), includeColor ? enclosingColumnGroup->style()->visitedDependentColor(startColorProperty) : Color(), BCOLGROUP));
563                 if (!result.exists())
564                     return result;
565             }
566         }
567     }
568     
569     // (6) The end border of the preceding column.
570     if (cellBefore) {
571         if (RenderTableCol* colElt = table->colElement(col() - 1, &startColEdge, &endColEdge)) {
572             if (colElt->isTableColumnGroup() && endColEdge) {
573                 // The element is a colgroup and is also the last colgroup (in case of spanned colgroups).
574                 result = chooseBorder(CollapsedBorderValue(colElt->borderAdjoiningCellAfter(this), includeColor ? colElt->style()->visitedDependentColor(endColorProperty) : Color(), BCOLGROUP), result);
575                 if (!result.exists())
576                     return result;
577             } else if (colElt->isTableColumn()) {
578                 // Resolve the collapsing border against the col's border ignoring any 'span' as per HTML5.
579                 result = chooseBorder(CollapsedBorderValue(colElt->borderAdjoiningCellAfter(this), includeColor ? colElt->style()->visitedDependentColor(endColorProperty) : Color(), BCOL), result);
580                 if (!result.exists())
581                     return result;
582                 // Next, if the previous col has a parent colgroup then its end border should be applied
583                 // but only if it is adjacent to the cell's edge.
584                 if (RenderTableCol* enclosingColumnGroup = colElt->enclosingColumnGroupIfAdjacentAfter()) {
585                     result = chooseBorder(CollapsedBorderValue(enclosingColumnGroup->borderAdjoiningCellEndBorder(this), includeColor ? enclosingColumnGroup->style()->visitedDependentColor(endColorProperty) : Color(), BCOLGROUP), result);
586                     if (!result.exists())
587                         return result;
588                 }
589             }
590         }
591     }
592
593     if (startBorderAdjoinsTable) {
594         // (7) The table's start border.
595         result = chooseBorder(result, CollapsedBorderValue(table->tableStartBorderAdjoiningCell(this), includeColor ? table->style()->visitedDependentColor(startColorProperty) : Color(), BTABLE));
596         if (!result.exists())
597             return result;
598     }
599     
600     return result;
601 }
602
603 CollapsedBorderValue RenderTableCell::collapsedEndBorder(IncludeBorderColorOrNot includeColor) const
604 {
605     CollapsedBorderValue result = computeCollapsedEndBorder(includeColor);
606     if (includeColor)
607         section()->setCachedCollapsedBorder(this, CBSEnd, result);
608     return result;
609 }
610
611 CollapsedBorderValue RenderTableCell::computeCollapsedEndBorder(IncludeBorderColorOrNot includeColor) const
612 {
613     RenderTable* table = this->table();
614     // Note: We have to use the effective column information instead of whether we have a cell after as a table doesn't
615     // have to be regular (any row can have less cells than the total cell count).
616     bool isEndColumn = table->colToEffCol(col() + colSpan() - 1) == table->numEffCols() - 1;
617
618     // For end border, we need to check, in order of precedence:
619     // (1) Our end border.
620     int startColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderStartColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
621     int endColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderEndColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
622     CollapsedBorderValue result = CollapsedBorderValue(style()->borderEnd(), includeColor ? style()->visitedDependentColor(endColorProperty) : Color(), BCELL);
623     
624     // (2) The start border of the following cell.
625     if (!isEndColumn) {
626         if (RenderTableCell* cellAfter = table->cellAfter(this)) {
627             CollapsedBorderValue cellAfterAdjoiningBorder = CollapsedBorderValue(cellAfter->borderAdjoiningCellBefore(this), includeColor ? cellAfter->style()->visitedDependentColor(startColorProperty) : Color(), BCELL);
628             result = chooseBorder(result, cellAfterAdjoiningBorder);
629             if (!result.exists())
630                 return result;
631         }
632     }
633
634     bool endBorderAdjoinsTable = hasEndBorderAdjoiningTable();
635     if (endBorderAdjoinsTable) {
636         // (3) Our row's end border.
637         result = chooseBorder(result, CollapsedBorderValue(row()->borderAdjoiningEndCell(this), includeColor ? parent()->style()->visitedDependentColor(endColorProperty) : Color(), BROW));
638         if (!result.exists())
639             return result;
640         
641         // (4) Our row group's end border.
642         result = chooseBorder(result, CollapsedBorderValue(section()->borderAdjoiningEndCell(this), includeColor ? section()->style()->visitedDependentColor(endColorProperty) : Color(), BROWGROUP));
643         if (!result.exists())
644             return result;
645     }
646     
647     // (5) Our column and column group's end borders.
648     bool startColEdge;
649     bool endColEdge;
650     if (RenderTableCol* colElt = table->colElement(col() + colSpan() - 1, &startColEdge, &endColEdge)) {
651         if (colElt->isTableColumnGroup() && endColEdge) {
652             // The element is a colgroup and is also the last colgroup (in case of spanned colgroups).
653             result = chooseBorder(result, CollapsedBorderValue(colElt->borderAdjoiningCellEndBorder(this), includeColor ? colElt->style()->visitedDependentColor(endColorProperty) : Color(), BCOLGROUP));
654             if (!result.exists())
655                 return result;
656         } else if (!colElt->isTableColumnGroup()) {
657             // First apply the end border of the column irrespective of whether it is spanned or not. This is as per
658             // HTML5 which states that: "For the purposes of the CSS table model, the col element is expected to be
659             // treated as if it was present as many times as its span attribute specifies".
660             result = chooseBorder(result, CollapsedBorderValue(colElt->borderAdjoiningCellEndBorder(this), includeColor ? colElt->style()->visitedDependentColor(endColorProperty) : Color(), BCOL));
661             if (!result.exists())
662                 return result;
663             // Next, if it has a parent colgroup then we apply its end border but only if it is adjacent to the cell.
664             if (RenderTableCol* enclosingColumnGroup = colElt->enclosingColumnGroupIfAdjacentAfter()) {
665                 result = chooseBorder(result, CollapsedBorderValue(enclosingColumnGroup->borderAdjoiningCellEndBorder(this), includeColor ? enclosingColumnGroup->style()->visitedDependentColor(endColorProperty) : Color(), BCOLGROUP));
666                 if (!result.exists())
667                     return result;
668             }
669         }
670     }
671     
672     // (6) The start border of the next column.
673     if (!isEndColumn) {
674         if (RenderTableCol* colElt = table->colElement(col() + colSpan(), &startColEdge, &endColEdge)) {
675             if (colElt->isTableColumnGroup() && startColEdge) {
676                 // This case is a colgroup without any col, we only compute it if it is adjacent to the cell's edge.
677                 result = chooseBorder(result, CollapsedBorderValue(colElt->borderAdjoiningCellBefore(this), includeColor ? colElt->style()->visitedDependentColor(startColorProperty) : Color(), BCOLGROUP));
678                 if (!result.exists())
679                     return result;
680             } else if (colElt->isTableColumn()) {
681                 // Resolve the collapsing border against the col's border ignoring any 'span' as per HTML5.
682                 result = chooseBorder(result, CollapsedBorderValue(colElt->borderAdjoiningCellBefore(this), includeColor ? colElt->style()->visitedDependentColor(startColorProperty) : Color(), BCOL));
683                 if (!result.exists())
684                     return result;
685                 // If we have a parent colgroup, resolve the border only if it is adjacent to the cell.
686                 if (RenderTableCol* enclosingColumnGroup = colElt->enclosingColumnGroupIfAdjacentBefore()) {
687                     result = chooseBorder(result, CollapsedBorderValue(enclosingColumnGroup->borderAdjoiningCellStartBorder(this), includeColor ? enclosingColumnGroup->style()->visitedDependentColor(startColorProperty) : Color(), BCOLGROUP));
688                     if (!result.exists())
689                         return result;
690                 }
691             }
692         }
693     }
694
695     if (endBorderAdjoinsTable) {
696         // (7) The table's end border.
697         result = chooseBorder(result, CollapsedBorderValue(table->tableEndBorderAdjoiningCell(this), includeColor ? table->style()->visitedDependentColor(endColorProperty) : Color(), BTABLE));
698         if (!result.exists())
699             return result;
700     }
701     
702     return result;
703 }
704
705 CollapsedBorderValue RenderTableCell::collapsedBeforeBorder(IncludeBorderColorOrNot includeColor) const
706 {
707     CollapsedBorderValue result = computeCollapsedBeforeBorder(includeColor);
708     if (includeColor)
709         section()->setCachedCollapsedBorder(this, CBSBefore, result);
710     return result;
711 }
712
713 CollapsedBorderValue RenderTableCell::computeCollapsedBeforeBorder(IncludeBorderColorOrNot includeColor) const
714 {
715     RenderTable* table = this->table();
716
717     // For before border, we need to check, in order of precedence:
718     // (1) Our before border.
719     int beforeColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderBeforeColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
720     int afterColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderAfterColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
721     CollapsedBorderValue result = CollapsedBorderValue(style()->borderBefore(), includeColor ? style()->visitedDependentColor(beforeColorProperty) : Color(), BCELL);
722     
723     RenderTableCell* prevCell = table->cellAbove(this);
724     if (prevCell) {
725         // (2) A before cell's after border.
726         result = chooseBorder(CollapsedBorderValue(prevCell->style()->borderAfter(), includeColor ? prevCell->style()->visitedDependentColor(afterColorProperty) : Color(), BCELL), result);
727         if (!result.exists())
728             return result;
729     }
730     
731     // (3) Our row's before border.
732     result = chooseBorder(result, CollapsedBorderValue(parent()->style()->borderBefore(), includeColor ? parent()->style()->visitedDependentColor(beforeColorProperty) : Color(), BROW));
733     if (!result.exists())
734         return result;
735     
736     // (4) The previous row's after border.
737     if (prevCell) {
738         RenderObject* prevRow = 0;
739         if (prevCell->section() == section())
740             prevRow = parent()->previousSibling();
741         else
742             prevRow = prevCell->section()->lastRow();
743     
744         if (prevRow) {
745             result = chooseBorder(CollapsedBorderValue(prevRow->style()->borderAfter(), includeColor ? prevRow->style()->visitedDependentColor(afterColorProperty) : Color(), BROW), result);
746             if (!result.exists())
747                 return result;
748         }
749     }
750     
751     // Now check row groups.
752     RenderTableSection* currSection = section();
753     if (!rowIndex()) {
754         // (5) Our row group's before border.
755         result = chooseBorder(result, CollapsedBorderValue(currSection->style()->borderBefore(), includeColor ? currSection->style()->visitedDependentColor(beforeColorProperty) : Color(), BROWGROUP));
756         if (!result.exists())
757             return result;
758         
759         // (6) Previous row group's after border.
760         currSection = table->sectionAbove(currSection, SkipEmptySections);
761         if (currSection) {
762             result = chooseBorder(CollapsedBorderValue(currSection->style()->borderAfter(), includeColor ? currSection->style()->visitedDependentColor(afterColorProperty) : Color(), BROWGROUP), result);
763             if (!result.exists())
764                 return result;
765         }
766     }
767     
768     if (!currSection) {
769         // (8) Our column and column group's before borders.
770         RenderTableCol* colElt = table->colElement(col());
771         if (colElt) {
772             result = chooseBorder(result, CollapsedBorderValue(colElt->style()->borderBefore(), includeColor ? colElt->style()->visitedDependentColor(beforeColorProperty) : Color(), BCOL));
773             if (!result.exists())
774                 return result;
775             if (RenderTableCol* enclosingColumnGroup = colElt->enclosingColumnGroup()) {
776                 result = chooseBorder(result, CollapsedBorderValue(enclosingColumnGroup->style()->borderBefore(), includeColor ? enclosingColumnGroup->style()->visitedDependentColor(beforeColorProperty) : Color(), BCOLGROUP));
777                 if (!result.exists())
778                     return result;
779             }
780         }
781         
782         // (9) The table's before border.
783         result = chooseBorder(result, CollapsedBorderValue(table->style()->borderBefore(), includeColor ? table->style()->visitedDependentColor(beforeColorProperty) : Color(), BTABLE));
784         if (!result.exists())
785             return result;
786     }
787     
788     return result;
789 }
790
791 CollapsedBorderValue RenderTableCell::collapsedAfterBorder(IncludeBorderColorOrNot includeColor) const
792 {
793     CollapsedBorderValue result = computeCollapsedAfterBorder(includeColor);
794     if (includeColor)
795         section()->setCachedCollapsedBorder(this, CBSAfter, result);
796     return result;
797 }
798
799 CollapsedBorderValue RenderTableCell::computeCollapsedAfterBorder(IncludeBorderColorOrNot includeColor) const
800 {
801     RenderTable* table = this->table();
802
803     // For after border, we need to check, in order of precedence:
804     // (1) Our after border.
805     int beforeColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderBeforeColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
806     int afterColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderAfterColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
807     CollapsedBorderValue result = CollapsedBorderValue(style()->borderAfter(), includeColor ? style()->visitedDependentColor(afterColorProperty) : Color(), BCELL);
808     
809     RenderTableCell* nextCell = table->cellBelow(this);
810     if (nextCell) {
811         // (2) An after cell's before border.
812         result = chooseBorder(result, CollapsedBorderValue(nextCell->style()->borderBefore(), includeColor ? nextCell->style()->visitedDependentColor(beforeColorProperty) : Color(), BCELL));
813         if (!result.exists())
814             return result;
815     }
816     
817     // (3) Our row's after border. (FIXME: Deal with rowspan!)
818     result = chooseBorder(result, CollapsedBorderValue(parent()->style()->borderAfter(), includeColor ? parent()->style()->visitedDependentColor(afterColorProperty) : Color(), BROW));
819     if (!result.exists())
820         return result;
821     
822     // (4) The next row's before border.
823     if (nextCell) {
824         result = chooseBorder(result, CollapsedBorderValue(nextCell->parent()->style()->borderBefore(), includeColor ? nextCell->parent()->style()->visitedDependentColor(beforeColorProperty) : Color(), BROW));
825         if (!result.exists())
826             return result;
827     }
828     
829     // Now check row groups.
830     RenderTableSection* currSection = section();
831     if (rowIndex() + rowSpan() >= currSection->numRows()) {
832         // (5) Our row group's after border.
833         result = chooseBorder(result, CollapsedBorderValue(currSection->style()->borderAfter(), includeColor ? currSection->style()->visitedDependentColor(afterColorProperty) : Color(), BROWGROUP));
834         if (!result.exists())
835             return result;
836         
837         // (6) Following row group's before border.
838         currSection = table->sectionBelow(currSection, SkipEmptySections);
839         if (currSection) {
840             result = chooseBorder(result, CollapsedBorderValue(currSection->style()->borderBefore(), includeColor ? currSection->style()->visitedDependentColor(beforeColorProperty) : Color(), BROWGROUP));
841             if (!result.exists())
842                 return result;
843         }
844     }
845     
846     if (!currSection) {
847         // (8) Our column and column group's after borders.
848         RenderTableCol* colElt = table->colElement(col());
849         if (colElt) {
850             result = chooseBorder(result, CollapsedBorderValue(colElt->style()->borderAfter(), includeColor ? colElt->style()->visitedDependentColor(afterColorProperty) : Color(), BCOL));
851             if (!result.exists()) return result;
852             if (RenderTableCol* enclosingColumnGroup = colElt->enclosingColumnGroup()) {
853                 result = chooseBorder(result, CollapsedBorderValue(enclosingColumnGroup->style()->borderAfter(), includeColor ? enclosingColumnGroup->style()->visitedDependentColor(afterColorProperty) : Color(), BCOLGROUP));
854                 if (!result.exists())
855                     return result;
856             }
857         }
858         
859         // (9) The table's after border.
860         result = chooseBorder(result, CollapsedBorderValue(table->style()->borderAfter(), includeColor ? table->style()->visitedDependentColor(afterColorProperty) : Color(), BTABLE));
861         if (!result.exists())
862             return result;
863     }
864     
865     return result;    
866 }
867
868 inline CollapsedBorderValue RenderTableCell::cachedCollapsedLeftBorder(const RenderStyle* styleForCellFlow) const
869 {
870     if (styleForCellFlow->isHorizontalWritingMode())
871         return styleForCellFlow->isLeftToRightDirection() ? section()->cachedCollapsedBorder(this, CBSStart) : section()->cachedCollapsedBorder(this, CBSEnd);
872     return styleForCellFlow->isFlippedBlocksWritingMode() ? section()->cachedCollapsedBorder(this, CBSAfter) : section()->cachedCollapsedBorder(this, CBSBefore);
873 }
874
875 inline CollapsedBorderValue RenderTableCell::cachedCollapsedRightBorder(const RenderStyle* styleForCellFlow) const
876 {
877     if (styleForCellFlow->isHorizontalWritingMode())
878         return styleForCellFlow->isLeftToRightDirection() ? section()->cachedCollapsedBorder(this, CBSEnd) : section()->cachedCollapsedBorder(this, CBSStart);
879     return styleForCellFlow->isFlippedBlocksWritingMode() ? section()->cachedCollapsedBorder(this, CBSBefore) : section()->cachedCollapsedBorder(this, CBSAfter);
880 }
881
882 inline CollapsedBorderValue RenderTableCell::cachedCollapsedTopBorder(const RenderStyle* styleForCellFlow) const
883 {
884     if (styleForCellFlow->isHorizontalWritingMode())
885         return styleForCellFlow->isFlippedBlocksWritingMode() ? section()->cachedCollapsedBorder(this, CBSAfter) : section()->cachedCollapsedBorder(this, CBSBefore);
886     return styleForCellFlow->isLeftToRightDirection() ? section()->cachedCollapsedBorder(this, CBSStart) : section()->cachedCollapsedBorder(this, CBSEnd);
887 }
888
889 inline CollapsedBorderValue RenderTableCell::cachedCollapsedBottomBorder(const RenderStyle* styleForCellFlow) const
890 {
891     if (styleForCellFlow->isHorizontalWritingMode())
892         return styleForCellFlow->isFlippedBlocksWritingMode() ? section()->cachedCollapsedBorder(this, CBSBefore) : section()->cachedCollapsedBorder(this, CBSAfter);
893     return styleForCellFlow->isLeftToRightDirection() ? section()->cachedCollapsedBorder(this, CBSEnd) : section()->cachedCollapsedBorder(this, CBSStart);
894 }
895
896 inline RenderTableCell* RenderTableCell::cellAtLeft(const RenderStyle* styleForCellFlow) const
897 {
898     if (styleForCellFlow->isHorizontalWritingMode())
899         return styleForCellFlow->isLeftToRightDirection() ? table()->cellBefore(this) : table()->cellAfter(this);
900     return styleForCellFlow->isFlippedBlocksWritingMode() ? table()->cellBelow(this) : table()->cellAbove(this);
901 }
902
903 inline RenderTableCell* RenderTableCell::cellAtRight(const RenderStyle* styleForCellFlow) const
904 {
905     if (styleForCellFlow->isHorizontalWritingMode())
906         return styleForCellFlow->isLeftToRightDirection() ? table()->cellAfter(this) : table()->cellBefore(this);
907     return styleForCellFlow->isFlippedBlocksWritingMode() ? table()->cellAbove(this) : table()->cellBelow(this);
908 }
909
910 inline RenderTableCell* RenderTableCell::cellAtTop(const RenderStyle* styleForCellFlow) const
911 {
912     if (styleForCellFlow->isHorizontalWritingMode())
913         return styleForCellFlow->isFlippedBlocksWritingMode() ? table()->cellBelow(this) : table()->cellAbove(this);
914     return styleForCellFlow->isLeftToRightDirection() ? table()->cellBefore(this) : table()->cellAfter(this);
915 }
916
917 inline RenderTableCell* RenderTableCell::cellAtBottom(const RenderStyle* styleForCellFlow) const
918 {
919     if (styleForCellFlow->isHorizontalWritingMode())
920         return styleForCellFlow->isFlippedBlocksWritingMode() ? table()->cellAbove(this) : table()->cellBelow(this);
921     return styleForCellFlow->isLeftToRightDirection() ? table()->cellAfter(this) : table()->cellBefore(this);
922 }
923
924 int RenderTableCell::borderLeft() const
925 {
926     return table()->collapseBorders() ? borderHalfLeft(false) : RenderBlock::borderLeft();
927 }
928
929 int RenderTableCell::borderRight() const
930 {
931     return table()->collapseBorders() ? borderHalfRight(false) : RenderBlock::borderRight();
932 }
933
934 int RenderTableCell::borderTop() const
935 {
936     return table()->collapseBorders() ? borderHalfTop(false) : RenderBlock::borderTop();
937 }
938
939 int RenderTableCell::borderBottom() const
940 {
941     return table()->collapseBorders() ? borderHalfBottom(false) : RenderBlock::borderBottom();
942 }
943
944 // FIXME: https://bugs.webkit.org/show_bug.cgi?id=46191, make the collapsed border drawing
945 // work with different block flow values instead of being hard-coded to top-to-bottom.
946 int RenderTableCell::borderStart() const
947 {
948     return table()->collapseBorders() ? borderHalfStart(false) : RenderBlock::borderStart();
949 }
950
951 int RenderTableCell::borderEnd() const
952 {
953     return table()->collapseBorders() ? borderHalfEnd(false) : RenderBlock::borderEnd();
954 }
955
956 int RenderTableCell::borderBefore() const
957 {
958     return table()->collapseBorders() ? borderHalfBefore(false) : RenderBlock::borderBefore();
959 }
960
961 int RenderTableCell::borderAfter() const
962 {
963     return table()->collapseBorders() ? borderHalfAfter(false) : RenderBlock::borderAfter();
964 }
965
966 int RenderTableCell::borderHalfLeft(bool outer) const
967 {
968     const RenderStyle* styleForCellFlow = this->styleForCellFlow();
969     if (styleForCellFlow->isHorizontalWritingMode())
970         return styleForCellFlow->isLeftToRightDirection() ? borderHalfStart(outer) : borderHalfEnd(outer);
971     return styleForCellFlow->isFlippedBlocksWritingMode() ? borderHalfAfter(outer) : borderHalfBefore(outer);
972 }
973
974 int RenderTableCell::borderHalfRight(bool outer) const
975 {
976     const RenderStyle* styleForCellFlow = this->styleForCellFlow();
977     if (styleForCellFlow->isHorizontalWritingMode())
978         return styleForCellFlow->isLeftToRightDirection() ? borderHalfEnd(outer) : borderHalfStart(outer);
979     return styleForCellFlow->isFlippedBlocksWritingMode() ? borderHalfBefore(outer) : borderHalfAfter(outer);
980 }
981
982 int RenderTableCell::borderHalfTop(bool outer) const
983 {
984     const RenderStyle* styleForCellFlow = this->styleForCellFlow();
985     if (styleForCellFlow->isHorizontalWritingMode())
986         return styleForCellFlow->isFlippedBlocksWritingMode() ? borderHalfAfter(outer) : borderHalfBefore(outer);
987     return styleForCellFlow->isLeftToRightDirection() ? borderHalfStart(outer) : borderHalfEnd(outer);
988 }
989
990 int RenderTableCell::borderHalfBottom(bool outer) const
991 {
992     const RenderStyle* styleForCellFlow = this->styleForCellFlow();
993     if (styleForCellFlow->isHorizontalWritingMode())
994         return styleForCellFlow->isFlippedBlocksWritingMode() ? borderHalfBefore(outer) : borderHalfAfter(outer);
995     return styleForCellFlow->isLeftToRightDirection() ? borderHalfEnd(outer) : borderHalfStart(outer);
996 }
997
998 int RenderTableCell::borderHalfStart(bool outer) const
999 {
1000     CollapsedBorderValue border = collapsedStartBorder(DoNotIncludeBorderColor);
1001     if (border.exists())
1002         return (border.width() + ((styleForCellFlow()->isLeftToRightDirection() ^ outer) ? 1 : 0)) / 2; // Give the extra pixel to top and left.
1003     return 0;
1004 }
1005     
1006 int RenderTableCell::borderHalfEnd(bool outer) const
1007 {
1008     CollapsedBorderValue border = collapsedEndBorder(DoNotIncludeBorderColor);
1009     if (border.exists())
1010         return (border.width() + ((styleForCellFlow()->isLeftToRightDirection() ^ outer) ? 0 : 1)) / 2;
1011     return 0;
1012 }
1013
1014 int RenderTableCell::borderHalfBefore(bool outer) const
1015 {
1016     CollapsedBorderValue border = collapsedBeforeBorder(DoNotIncludeBorderColor);
1017     if (border.exists())
1018         return (border.width() + ((styleForCellFlow()->isFlippedBlocksWritingMode() ^ outer) ? 0 : 1)) / 2; // Give the extra pixel to top and left.
1019     return 0;
1020 }
1021
1022 int RenderTableCell::borderHalfAfter(bool outer) const
1023 {
1024     CollapsedBorderValue border = collapsedAfterBorder(DoNotIncludeBorderColor);
1025     if (border.exists())
1026         return (border.width() + ((styleForCellFlow()->isFlippedBlocksWritingMode() ^ outer) ? 1 : 0)) / 2;
1027     return 0;
1028 }
1029
1030 void RenderTableCell::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
1031 {
1032     ASSERT(paintInfo.phase != PaintPhaseCollapsedTableBorders);
1033     RenderBlock::paint(paintInfo, paintOffset);
1034 }
1035
1036 static EBorderStyle collapsedBorderStyle(EBorderStyle style)
1037 {
1038     if (style == OUTSET)
1039         return GROOVE;
1040     if (style == INSET)
1041         return RIDGE;
1042     return style;
1043 }
1044
1045 struct CollapsedBorder {
1046     CollapsedBorderValue borderValue;
1047     BoxSide side;
1048     bool shouldPaint;
1049     int x1;
1050     int y1;
1051     int x2;
1052     int y2;
1053     EBorderStyle style;
1054 };
1055
1056 class CollapsedBorders {
1057 public:
1058     CollapsedBorders()
1059         : m_count(0)
1060     {
1061     }
1062     
1063     void addBorder(const CollapsedBorderValue& borderValue, BoxSide borderSide, bool shouldPaint,
1064                    int x1, int y1, int x2, int y2, EBorderStyle borderStyle)
1065     {
1066         if (borderValue.exists() && shouldPaint) {
1067             m_borders[m_count].borderValue = borderValue;
1068             m_borders[m_count].side = borderSide;
1069             m_borders[m_count].shouldPaint = shouldPaint;
1070             m_borders[m_count].x1 = x1;
1071             m_borders[m_count].x2 = x2;
1072             m_borders[m_count].y1 = y1;
1073             m_borders[m_count].y2 = y2;
1074             m_borders[m_count].style = borderStyle;
1075             m_count++;
1076         }
1077     }
1078
1079     CollapsedBorder* nextBorder()
1080     {
1081         for (unsigned i = 0; i < m_count; i++) {
1082             if (m_borders[i].borderValue.exists() && m_borders[i].shouldPaint) {
1083                 m_borders[i].shouldPaint = false;
1084                 return &m_borders[i];
1085             }
1086         }
1087         
1088         return 0;
1089     }
1090     
1091     CollapsedBorder m_borders[4];
1092     unsigned m_count;
1093 };
1094
1095 static void addBorderStyle(RenderTable::CollapsedBorderValues& borderValues,
1096                            CollapsedBorderValue borderValue)
1097 {
1098     if (!borderValue.exists())
1099         return;
1100     size_t count = borderValues.size();
1101     for (size_t i = 0; i < count; ++i)
1102         if (borderValues[i].isSameIgnoringColor(borderValue))
1103             return;
1104     borderValues.append(borderValue);
1105 }
1106
1107 void RenderTableCell::collectBorderValues(RenderTable::CollapsedBorderValues& borderValues) const
1108 {
1109     addBorderStyle(borderValues, collapsedStartBorder());
1110     addBorderStyle(borderValues, collapsedEndBorder());
1111     addBorderStyle(borderValues, collapsedBeforeBorder());
1112     addBorderStyle(borderValues, collapsedAfterBorder());
1113 }
1114
1115 static int compareBorderValuesForQSort(const void* pa, const void* pb)
1116 {
1117     const CollapsedBorderValue* a = static_cast<const CollapsedBorderValue*>(pa);
1118     const CollapsedBorderValue* b = static_cast<const CollapsedBorderValue*>(pb);
1119     if (a->isSameIgnoringColor(*b))
1120         return 0;
1121     return compareBorders(*a, *b);
1122 }
1123
1124 void RenderTableCell::sortBorderValues(RenderTable::CollapsedBorderValues& borderValues)
1125 {
1126     qsort(borderValues.data(), borderValues.size(), sizeof(CollapsedBorderValue),
1127         compareBorderValuesForQSort);
1128 }
1129
1130 bool RenderTableCell::alignLeftRightBorderPaintRect(int& leftXOffset, int& rightXOffset)
1131 {
1132     const RenderStyle* styleForTopCell = styleForCellFlow();
1133     int left = cachedCollapsedLeftBorder(styleForTopCell).width();
1134     int right = cachedCollapsedRightBorder(styleForTopCell).width();
1135     leftXOffset = max<int>(leftXOffset, left);
1136     rightXOffset = max<int>(rightXOffset, right);
1137     if (colSpan() > 1)
1138         return false;
1139     return true;
1140 }
1141
1142 bool RenderTableCell::alignTopBottomBorderPaintRect(int& topYOffset, int& bottomYOffset)
1143 {
1144     const RenderStyle* styleForBottomCell = styleForCellFlow();
1145     int top = cachedCollapsedTopBorder(styleForBottomCell).width();
1146     int bottom = cachedCollapsedBottomBorder(styleForBottomCell).width();
1147     topYOffset = max<int>(topYOffset, top);
1148     bottomYOffset = max<int>(bottomYOffset, bottom);
1149     if (rowSpan() > 1)
1150         return false;
1151     return true;
1152 }
1153
1154
1155 void RenderTableCell::paintCollapsedBorders(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
1156 {
1157     ASSERT(paintInfo.phase == PaintPhaseCollapsedTableBorders);
1158
1159     if (!paintInfo.shouldPaintWithinRoot(this) || style()->visibility() != VISIBLE)
1160         return;
1161
1162     LayoutRect localRepaintRect = paintInfo.rect;
1163     localRepaintRect.inflate(maximalOutlineSize(paintInfo.phase));
1164
1165     LayoutRect paintRect = LayoutRect(paintOffset + location(), pixelSnappedSize());
1166     if (paintRect.y() - table()->outerBorderTop() >= localRepaintRect.maxY())
1167         return;
1168
1169     if (paintRect.maxY() + table()->outerBorderBottom() <= localRepaintRect.y())
1170         return;
1171
1172     GraphicsContext* graphicsContext = paintInfo.context;
1173     if (!table()->currentBorderValue() || graphicsContext->paintingDisabled())
1174         return;
1175
1176     const RenderStyle* styleForCellFlow = this->styleForCellFlow();
1177     CollapsedBorderValue leftVal = cachedCollapsedLeftBorder(styleForCellFlow);
1178     CollapsedBorderValue rightVal = cachedCollapsedRightBorder(styleForCellFlow);
1179     CollapsedBorderValue topVal = cachedCollapsedTopBorder(styleForCellFlow);
1180     CollapsedBorderValue bottomVal = cachedCollapsedBottomBorder(styleForCellFlow);
1181      
1182     // Adjust our x/y/width/height so that we paint the collapsed borders at the correct location.
1183     int topWidth = topVal.width();
1184     int bottomWidth = bottomVal.width();
1185     int leftWidth = leftVal.width();
1186     int rightWidth = rightVal.width();
1187
1188     int leftXOffsetTop = leftWidth;
1189     int leftXOffsetBottom = leftWidth;
1190     int rightXOffsetTop = rightWidth;
1191     int rightXOffsetBottom = rightWidth;
1192     int topYOffsetLeft = topWidth;
1193     int topYOffsetRight = topWidth;
1194     int bottomYOffsetLeft = bottomWidth;
1195     int bottomYOffsetRight = bottomWidth;
1196
1197     // We use the direction/writing-mode given by the section here because we want to know if we're
1198     // at the section's edge.
1199     bool shouldDrawTopBorder = !cellAtTop(section()->style());
1200     bool shouldDrawLeftBorder = !cellAtLeft(section()->style());
1201     bool shouldDrawRightBorder = true;
1202
1203     if (RenderTableCell* top = cellAtTop(styleForCellFlow)) {
1204         shouldDrawTopBorder = shouldDrawTopBorder && top->alignLeftRightBorderPaintRect(leftXOffsetTop, rightXOffsetTop);
1205         if (this->colSpan() > 1)
1206             shouldDrawTopBorder = false;
1207     }
1208
1209     if (RenderTableCell* bottom = cellAtBottom(styleForCellFlow))
1210         bottom->alignLeftRightBorderPaintRect(leftXOffsetBottom, rightXOffsetBottom);
1211
1212     if (RenderTableCell* left = cellAtLeft(styleForCellFlow))
1213         shouldDrawLeftBorder = shouldDrawLeftBorder && left->alignTopBottomBorderPaintRect(topYOffsetLeft, bottomYOffsetLeft);
1214
1215     if (RenderTableCell* right = cellAtRight(styleForCellFlow))
1216         shouldDrawRightBorder = right->alignTopBottomBorderPaintRect(topYOffsetRight, bottomYOffsetRight);
1217
1218     IntRect cellRect = pixelSnappedIntRect(paintRect.x(), paintRect.y(), paintRect.width(), paintRect.height());
1219
1220     IntRect borderRect = pixelSnappedIntRect(paintRect.x() - leftWidth / 2,
1221         paintRect.y() - topWidth / 2,
1222         paintRect.width() + leftWidth / 2 + (rightWidth + 1) / 2,
1223         paintRect.height() + topWidth / 2 + (bottomWidth + 1) / 2);
1224
1225     EBorderStyle topStyle = collapsedBorderStyle(topVal.style());
1226     EBorderStyle bottomStyle = collapsedBorderStyle(bottomVal.style());
1227     EBorderStyle leftStyle = collapsedBorderStyle(leftVal.style());
1228     EBorderStyle rightStyle = collapsedBorderStyle(rightVal.style());
1229     
1230     bool renderTop = topStyle > BHIDDEN && !topVal.isTransparent() && shouldDrawTopBorder;
1231     bool renderBottom = bottomStyle > BHIDDEN && !bottomVal.isTransparent();
1232     bool renderLeft = leftStyle > BHIDDEN && !leftVal.isTransparent() && shouldDrawLeftBorder;
1233     bool renderRight = rightStyle > BHIDDEN && !rightVal.isTransparent() && shouldDrawRightBorder;
1234
1235     // We never paint diagonals at the joins.  We simply let the border with the highest
1236     // precedence paint on top of borders with lower precedence.  
1237     CollapsedBorders borders;
1238     if (topVal.style() == DOTTED)
1239         borders.addBorder(topVal, BSTop, renderTop, cellRect.x() - leftXOffsetTop / 2, cellRect.y() - topWidth / 2, cellRect.maxX() + rightXOffsetTop / 2, cellRect.y() + topWidth / 2 + topWidth % 2, topStyle);
1240     else
1241         borders.addBorder(topVal, BSTop, renderTop, borderRect.x(), borderRect.y(), borderRect.maxX(), borderRect.y() + topWidth, topStyle);
1242
1243     if (bottomVal.style() == DOTTED)
1244         borders.addBorder(bottomVal, BSBottom, renderBottom, cellRect.x() - leftXOffsetBottom / 2, cellRect.maxY() - bottomWidth / 2, cellRect.maxX() + rightXOffsetBottom / 2, cellRect.maxY() + bottomWidth / 2 + bottomWidth % 2, bottomStyle);
1245     else
1246         borders.addBorder(bottomVal, BSBottom, renderBottom, borderRect.x(), borderRect.maxY() - bottomWidth, borderRect.maxX(), borderRect.maxY(), bottomStyle);
1247
1248     if (leftVal.style() == DOTTED)
1249         borders.addBorder(leftVal, BSLeft, renderLeft, cellRect.x() - leftWidth / 2, cellRect.y() - topYOffsetLeft / 2, cellRect.x() + leftWidth / 2 + leftWidth % 2, cellRect.maxY() + bottomYOffsetLeft / 2 + bottomYOffsetLeft % 2, leftStyle);
1250     else
1251         borders.addBorder(leftVal, BSLeft, renderLeft, borderRect.x(), borderRect.y(), borderRect.x() + leftWidth, borderRect.maxY(), leftStyle);
1252
1253     if (rightVal.style() == DOTTED)
1254         borders.addBorder(rightVal, BSRight, renderRight, cellRect.maxX() - rightWidth / 2, cellRect.y()  - topYOffsetRight / 2, cellRect.maxX() + rightWidth / 2 + rightWidth % 2, cellRect.maxY()  + bottomYOffsetRight / 2 + bottomYOffsetRight % 2, rightStyle);
1255     else
1256         borders.addBorder(rightVal, BSRight, renderRight, borderRect.maxX() - rightWidth, borderRect.y(), borderRect.maxX(), borderRect.maxY(), rightStyle);
1257
1258     bool antialias = shouldAntialiasLines(graphicsContext);
1259     
1260     for (CollapsedBorder* border = borders.nextBorder(); border; border = borders.nextBorder()) {
1261         if (border->borderValue.isSameIgnoringColor(*table()->currentBorderValue()))
1262             drawLineForBoxSide(graphicsContext, border->x1, border->y1, border->x2, border->y2, border->side, 
1263                 border->borderValue.color(), border->style, 0, 0, antialias);
1264     }
1265 }
1266
1267 void RenderTableCell::paintBackgroundsBehindCell(PaintInfo& paintInfo, const LayoutPoint& paintOffset, RenderObject* backgroundObject)
1268 {
1269     if (!paintInfo.shouldPaintWithinRoot(this))
1270         return;
1271
1272     if (!backgroundObject)
1273         return;
1274
1275     if (style()->visibility() != VISIBLE)
1276         return;
1277
1278     RenderTable* tableElt = table();
1279     if (!tableElt->collapseBorders() && style()->emptyCells() == HIDE && !firstChild())
1280         return;
1281
1282     LayoutPoint adjustedPaintOffset = paintOffset;
1283     if (backgroundObject != this)
1284         adjustedPaintOffset.moveBy(location());
1285
1286     Color c = backgroundObject->style()->visitedDependentColor(CSSPropertyBackgroundColor);
1287     const FillLayer* bgLayer = backgroundObject->style()->backgroundLayers();
1288
1289     if (bgLayer->hasImage() || c.isValid()) {
1290         // We have to clip here because the background would paint
1291         // on top of the borders otherwise.  This only matters for cells and rows.
1292         bool shouldClip = backgroundObject->hasLayer() && (backgroundObject == this || backgroundObject == parent()) && tableElt->collapseBorders();
1293         GraphicsContextStateSaver stateSaver(*paintInfo.context, shouldClip);
1294         if (shouldClip) {
1295             LayoutRect clipRect(adjustedPaintOffset.x() + borderLeft(), adjustedPaintOffset.y() + borderTop(),
1296                 width() - borderLeft() - borderRight(), height() - borderTop() - borderBottom());
1297             paintInfo.context->clip(clipRect);
1298         }
1299         paintFillLayers(paintInfo, c, bgLayer, LayoutRect(adjustedPaintOffset, pixelSnappedSize()), BackgroundBleedNone, CompositeSourceOver, backgroundObject);
1300     }
1301 }
1302
1303 void RenderTableCell::paintBoxDecorations(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
1304 {
1305     if (!paintInfo.shouldPaintWithinRoot(this))
1306         return;
1307
1308     RenderTable* tableElt = table();
1309     if (!tableElt->collapseBorders() && style()->emptyCells() == HIDE && !firstChild())
1310         return;
1311
1312     LayoutRect paintRect = LayoutRect(paintOffset, pixelSnappedSize());
1313     paintBoxShadow(paintInfo, paintRect, style(), Normal);
1314     
1315     // Paint our cell background.
1316     paintBackgroundsBehindCell(paintInfo, paintOffset, this);
1317
1318     paintBoxShadow(paintInfo, paintRect, style(), Inset);
1319
1320     if (!style()->hasBorder() || tableElt->collapseBorders())
1321         return;
1322
1323     paintBorder(paintInfo, paintRect, style());
1324 }
1325
1326 void RenderTableCell::paintMask(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
1327 {
1328     if (style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseMask)
1329         return;
1330
1331     RenderTable* tableElt = table();
1332     if (!tableElt->collapseBorders() && style()->emptyCells() == HIDE && !firstChild())
1333         return;
1334    
1335     paintMaskImages(paintInfo, LayoutRect(paintOffset, pixelSnappedSize()));
1336 }
1337
1338 bool RenderTableCell::boxShadowShouldBeAppliedToBackground(BackgroundBleedAvoidance, InlineFlowBox*) const
1339 {
1340     return false;
1341 }
1342
1343 void RenderTableCell::scrollbarsChanged(bool horizontalScrollbarChanged, bool verticalScrollbarChanged)
1344 {
1345     LayoutUnit scrollbarHeight = scrollbarLogicalHeight();
1346     if (!scrollbarHeight)
1347         return; // Not sure if we should be doing something when a scrollbar goes away or not.
1348     
1349     // We only care if the scrollbar that affects our intrinsic padding has been added.
1350     if ((isHorizontalWritingMode() && !horizontalScrollbarChanged) ||
1351         (!isHorizontalWritingMode() && !verticalScrollbarChanged))
1352         return;
1353
1354     // Shrink our intrinsic padding as much as possible to accommodate the scrollbar.
1355     if (style()->verticalAlign() == MIDDLE) {
1356         LayoutUnit totalHeight = logicalHeight();
1357         LayoutUnit heightWithoutIntrinsicPadding = totalHeight - intrinsicPaddingBefore() - intrinsicPaddingAfter();
1358         totalHeight -= scrollbarHeight;
1359         LayoutUnit newBeforePadding = (totalHeight - heightWithoutIntrinsicPadding) / 2;
1360         LayoutUnit newAfterPadding = totalHeight - heightWithoutIntrinsicPadding - newBeforePadding;
1361         setIntrinsicPaddingBefore(newBeforePadding);
1362         setIntrinsicPaddingAfter(newAfterPadding);
1363     } else
1364         setIntrinsicPaddingAfter(intrinsicPaddingAfter() - scrollbarHeight);
1365 }
1366
1367 RenderTableCell* RenderTableCell::createAnonymous(Document& document)
1368 {
1369     RenderTableCell* renderer = new (*document.renderArena()) RenderTableCell(0);
1370     renderer->setDocumentForAnonymous(document);
1371     return renderer;
1372 }
1373
1374 RenderTableCell* RenderTableCell::createAnonymousWithParentRenderer(const RenderObject* parent)
1375 {
1376     RenderTableCell* newCell = RenderTableCell::createAnonymous(parent->document());
1377     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parent->style(), TABLE_CELL);
1378     newCell->setStyle(newStyle.release());
1379     return newCell;
1380 }
1381
1382 } // namespace WebCore