REGRESSION(r140907): Incorrect baseline on cells after updating vertical-align
[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 RenderBlock {
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     : RenderBlock(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(node());
82     if (node()->hasTagName(tdTag) || node()->hasTagName(thTag))
83         return min<unsigned>(toHTMLTableCellElement(node())->colSpan(), maxColumnIndex);
84 #if ENABLE(MATHML)
85     if (node()->hasTagName(MathMLNames::mtdTag))
86         return min<unsigned>(toMathMLElement(node())->colSpan(), maxColumnIndex);
87 #endif
88     return 1;
89 }
90
91 unsigned RenderTableCell::parseRowSpanFromDOM() const
92 {
93     ASSERT(node());
94     if (node()->hasTagName(tdTag) || node()->hasTagName(thTag))
95         return min<unsigned>(toHTMLTableCellElement(node())->rowSpan(), maxRowIndex);
96 #if ENABLE(MATHML)
97     if (node()->hasTagName(MathMLNames::mtdTag))
98         return min<unsigned>(toMathMLElement(node())->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 = node() && parseColSpanFromDOM() != 1;
108     m_hasRowSpan = node() && parseRowSpanFromDOM() != 1;
109 }
110
111 void RenderTableCell::colSpanOrRowSpanChanged()
112 {
113     ASSERT(node());
114 #if ENABLE(MATHML)
115     ASSERT(node()->hasTagName(tdTag) || node()->hasTagName(thTag) || node()->hasTagName(MathMLNames::mtdTag));
116 #else
117     ASSERT(node()->hasTagName(tdTag) || node()->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 (node() && style()->autoWrap()) {
170         // See if nowrap was set.
171         Length w = styleOrColLogicalWidth();
172         String nowrap = toElement(node())->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 > borderBefore() + paddingBefore())
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     if (RenderView* v = view()) {
367         // FIXME: layoutDelta needs to be applied in parts before/after transforms and
368         // repaint containers. https://bugs.webkit.org/show_bug.cgi?id=23308
369         r.move(v->layoutDelta());
370     }
371     computeRectForRepaint(repaintContainer, r);
372     return r;
373 }
374
375 void RenderTableCell::computeRectForRepaint(const RenderLayerModelObject* repaintContainer, LayoutRect& r, bool fixed) const
376 {
377     if (repaintContainer == this)
378         return;
379     r.setY(r.y());
380     RenderView* v = view();
381     if ((!v || !v->layoutStateEnabled() || repaintContainer) && parent())
382         r.moveBy(-parentBox()->location()); // Rows are in the same coordinate space, so don't add their offset in.
383     RenderBlock::computeRectForRepaint(repaintContainer, r, fixed);
384 }
385
386 LayoutUnit RenderTableCell::cellBaselinePosition() const
387 {
388     // <http://www.w3.org/TR/2007/CR-CSS21-20070719/tables.html#height-layout>: The baseline of a cell is the baseline of
389     // the first in-flow line box in the cell, or the first in-flow table-row in the cell, whichever comes first. If there
390     // is no such line box or table-row, the baseline is the bottom of content edge of the cell box.
391     LayoutUnit firstLineBaseline = firstLineBoxBaseline();
392     if (firstLineBaseline != -1)
393         return firstLineBaseline;
394     return paddingBefore() + borderBefore() + contentLogicalHeight();
395 }
396
397 void RenderTableCell::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
398 {
399     ASSERT(style()->display() == TABLE_CELL);
400     ASSERT(!row() || row()->rowIndexWasSet());
401
402     RenderBlock::styleDidChange(diff, oldStyle);
403     setHasBoxDecorations(true);
404
405     if (parent() && section() && oldStyle && style()->height() != oldStyle->height())
406         section()->rowLogicalHeightChanged(rowIndex());
407
408     // Our intrinsic padding pushes us down to align with the baseline of other cells on the row. If our vertical-align
409     // has changed then so will the padding needed to align with other cells - clear it so we can recalculate it from scratch.
410     if (oldStyle && style()->verticalAlign() != oldStyle->verticalAlign())
411         clearIntrinsicPadding();
412
413     // If border was changed, notify table.
414     if (parent()) {
415         RenderTable* table = this->table();
416         if (table && !table->selfNeedsLayout() && !table->normalChildNeedsLayout()&& oldStyle && oldStyle->border() != style()->border())
417             table->invalidateCollapsedBorders();
418     }
419 }
420
421 // The following rules apply for resolving conflicts and figuring out which border
422 // to use.
423 // (1) Borders with the 'border-style' of 'hidden' take precedence over all other conflicting 
424 // borders. Any border with this value suppresses all borders at this location.
425 // (2) Borders with a style of 'none' have the lowest priority. Only if the border properties of all 
426 // the elements meeting at this edge are 'none' will the border be omitted (but note that 'none' is 
427 // the default value for the border style.)
428 // (3) If none of the styles are 'hidden' and at least one of them is not 'none', then narrow borders 
429 // are discarded in favor of wider ones. If several have the same 'border-width' then styles are preferred 
430 // in this order: 'double', 'solid', 'dashed', 'dotted', 'ridge', 'outset', 'groove', and the lowest: 'inset'.
431 // (4) If border styles differ only in color, then a style set on a cell wins over one on a row, 
432 // which wins over a row group, column, column group and, lastly, table. It is undefined which color 
433 // is used when two elements of the same type disagree.
434 static int compareBorders(const CollapsedBorderValue& border1, const CollapsedBorderValue& border2)
435 {
436     // Sanity check the values passed in. The null border have lowest priority.
437     if (!border2.exists()) {
438         if (!border1.exists())
439             return 0;
440         return 1;
441     }
442     if (!border1.exists())
443         return -1;
444
445     // Rule #1 above.
446     if (border2.style() == BHIDDEN) {
447         if (border1.style() == BHIDDEN)
448             return 0;
449         return -1;
450     }
451     if (border1.style() == BHIDDEN)
452         return 1;
453     
454     // Rule #2 above.  A style of 'none' has lowest priority and always loses to any other border.
455     if (border2.style() == BNONE) {
456         if (border1.style() == BNONE)
457             return 0;
458         return 1;
459     }
460     if (border1.style() == BNONE)
461         return -1;
462
463     // The first part of rule #3 above. Wider borders win.
464     if (border1.width() != border2.width())
465         return border1.width() < border2.width() ? -1 : 1;
466     
467     // The borders have equal width.  Sort by border style.
468     if (border1.style() != border2.style())
469         return border1.style() < border2.style() ? -1 : 1;
470     
471     // The border have the same width and style.  Rely on precedence (cell over row over row group, etc.)
472     if (border1.precedence() == border2.precedence())
473         return 0;
474     return border1.precedence() < border2.precedence() ? -1 : 1;
475 }
476
477 static CollapsedBorderValue chooseBorder(const CollapsedBorderValue& border1, const CollapsedBorderValue& border2)
478 {
479     const CollapsedBorderValue& border = compareBorders(border1, border2) < 0 ? border2 : border1;
480     return border.style() == BHIDDEN ? CollapsedBorderValue() : border;
481 }
482
483 bool RenderTableCell::hasStartBorderAdjoiningTable() const
484 {
485     bool isStartColumn = !col();
486     bool isEndColumn = table()->colToEffCol(col() + colSpan() - 1) == table()->numEffCols() - 1;
487     bool hasSameDirectionAsTable = hasSameDirectionAs(table());
488
489     // The table direction determines the row direction. In mixed directionality, we cannot guarantee that
490     // we have a common border with the table (think a ltr table with rtl start cell).
491     return (isStartColumn && hasSameDirectionAsTable) || (isEndColumn && !hasSameDirectionAsTable);
492 }
493
494 bool RenderTableCell::hasEndBorderAdjoiningTable() const
495 {
496     bool isStartColumn = !col();
497     bool isEndColumn = table()->colToEffCol(col() + colSpan() - 1) == table()->numEffCols() - 1;
498     bool hasSameDirectionAsTable = hasSameDirectionAs(table());
499
500     // The table direction determines the row direction. In mixed directionality, we cannot guarantee that
501     // we have a common border with the table (think a ltr table with ltr end cell).
502     return (isStartColumn && !hasSameDirectionAsTable) || (isEndColumn && hasSameDirectionAsTable);
503 }
504
505 CollapsedBorderValue RenderTableCell::collapsedStartBorder(IncludeBorderColorOrNot includeColor) const
506 {
507     CollapsedBorderValue result = computeCollapsedStartBorder(includeColor);
508     if (includeColor)
509         section()->setCachedCollapsedBorder(this, CBSStart, result);
510     return result;
511 }
512
513 CollapsedBorderValue RenderTableCell::computeCollapsedStartBorder(IncludeBorderColorOrNot includeColor) const
514 {
515     RenderTable* table = this->table();
516
517     // For the start border, we need to check, in order of precedence:
518     // (1) Our start border.
519     int startColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderStartColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
520     int endColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderEndColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
521     CollapsedBorderValue result(style()->borderStart(), includeColor ? style()->visitedDependentColor(startColorProperty) : Color(), BCELL);
522
523     // (2) The end border of the preceding cell.
524     RenderTableCell* cellBefore = table->cellBefore(this);
525     if (cellBefore) {
526         CollapsedBorderValue cellBeforeAdjoiningBorder = CollapsedBorderValue(cellBefore->borderAdjoiningCellAfter(this), includeColor ? cellBefore->style()->visitedDependentColor(endColorProperty) : Color(), BCELL);
527         // |result| should be the 2nd argument as |cellBefore| should win in case of equality per CSS 2.1 (Border conflict resolution, point 4).
528         result = chooseBorder(cellBeforeAdjoiningBorder, result);
529         if (!result.exists())
530             return result;
531     }
532
533     bool startBorderAdjoinsTable = hasStartBorderAdjoiningTable();
534     if (startBorderAdjoinsTable) {
535         // (3) Our row's start border.
536         result = chooseBorder(result, CollapsedBorderValue(row()->borderAdjoiningStartCell(this), includeColor ? parent()->style()->visitedDependentColor(startColorProperty) : Color(), BROW));
537         if (!result.exists())
538             return result;
539
540         // (4) Our row group's start border.
541         result = chooseBorder(result, CollapsedBorderValue(section()->borderAdjoiningStartCell(this), includeColor ? section()->style()->visitedDependentColor(startColorProperty) : Color(), BROWGROUP));
542         if (!result.exists())
543             return result;
544     }
545     
546     // (5) Our column and column group's start borders.
547     bool startColEdge;
548     bool endColEdge;
549     if (RenderTableCol* colElt = table->colElement(col(), &startColEdge, &endColEdge)) {
550         if (colElt->isTableColumnGroup() && startColEdge) {
551             // The |colElt| is a column group and is also the first colgroup (in case of spanned colgroups).
552             result = chooseBorder(result, CollapsedBorderValue(colElt->borderAdjoiningCellStartBorder(this), includeColor ? colElt->style()->visitedDependentColor(startColorProperty) : Color(), BCOLGROUP));
553             if (!result.exists())
554                 return result;
555         } else if (!colElt->isTableColumnGroup()) {
556             // We first consider the |colElt| and irrespective of whether it is a spanned col or not, we apply
557             // its start border. This is as per HTML5 which states that: "For the purposes of the CSS table model,
558             // the col element is expected to be treated as if it was present as many times as its span attribute specifies".
559             result = chooseBorder(result, CollapsedBorderValue(colElt->borderAdjoiningCellStartBorder(this), includeColor ? colElt->style()->visitedDependentColor(startColorProperty) : Color(), BCOL));
560             if (!result.exists())
561                 return result;
562             // Next, apply the start border of the enclosing colgroup but only if it is adjacent to the cell's edge.
563             if (RenderTableCol* enclosingColumnGroup = colElt->enclosingColumnGroupIfAdjacentBefore()) {
564                 result = chooseBorder(result, CollapsedBorderValue(enclosingColumnGroup->borderAdjoiningCellStartBorder(this), includeColor ? enclosingColumnGroup->style()->visitedDependentColor(startColorProperty) : Color(), BCOLGROUP));
565                 if (!result.exists())
566                     return result;
567             }
568         }
569     }
570     
571     // (6) The end border of the preceding column.
572     if (cellBefore) {
573         if (RenderTableCol* colElt = table->colElement(col() - 1, &startColEdge, &endColEdge)) {
574             if (colElt->isTableColumnGroup() && endColEdge) {
575                 // The element is a colgroup and is also the last colgroup (in case of spanned colgroups).
576                 result = chooseBorder(CollapsedBorderValue(colElt->borderAdjoiningCellAfter(this), includeColor ? colElt->style()->visitedDependentColor(endColorProperty) : Color(), BCOLGROUP), result);
577                 if (!result.exists())
578                     return result;
579             } else if (colElt->isTableColumn()) {
580                 // Resolve the collapsing border against the col's border ignoring any 'span' as per HTML5.
581                 result = chooseBorder(CollapsedBorderValue(colElt->borderAdjoiningCellAfter(this), includeColor ? colElt->style()->visitedDependentColor(endColorProperty) : Color(), BCOL), result);
582                 if (!result.exists())
583                     return result;
584                 // Next, if the previous col has a parent colgroup then its end border should be applied
585                 // but only if it is adjacent to the cell's edge.
586                 if (RenderTableCol* enclosingColumnGroup = colElt->enclosingColumnGroupIfAdjacentAfter()) {
587                     result = chooseBorder(CollapsedBorderValue(enclosingColumnGroup->borderAdjoiningCellEndBorder(this), includeColor ? enclosingColumnGroup->style()->visitedDependentColor(endColorProperty) : Color(), BCOLGROUP), result);
588                     if (!result.exists())
589                         return result;
590                 }
591             }
592         }
593     }
594
595     if (startBorderAdjoinsTable) {
596         // (7) The table's start border.
597         result = chooseBorder(result, CollapsedBorderValue(table->tableStartBorderAdjoiningCell(this), includeColor ? table->style()->visitedDependentColor(startColorProperty) : Color(), BTABLE));
598         if (!result.exists())
599             return result;
600     }
601     
602     return result;
603 }
604
605 CollapsedBorderValue RenderTableCell::collapsedEndBorder(IncludeBorderColorOrNot includeColor) const
606 {
607     CollapsedBorderValue result = computeCollapsedEndBorder(includeColor);
608     if (includeColor)
609         section()->setCachedCollapsedBorder(this, CBSEnd, result);
610     return result;
611 }
612
613 CollapsedBorderValue RenderTableCell::computeCollapsedEndBorder(IncludeBorderColorOrNot includeColor) const
614 {
615     RenderTable* table = this->table();
616     // Note: We have to use the effective column information instead of whether we have a cell after as a table doesn't
617     // have to be regular (any row can have less cells than the total cell count).
618     bool isEndColumn = table->colToEffCol(col() + colSpan() - 1) == table->numEffCols() - 1;
619
620     // For end border, we need to check, in order of precedence:
621     // (1) Our end border.
622     int startColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderStartColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
623     int endColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderEndColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
624     CollapsedBorderValue result = CollapsedBorderValue(style()->borderEnd(), includeColor ? style()->visitedDependentColor(endColorProperty) : Color(), BCELL);
625     
626     // (2) The start border of the following cell.
627     if (!isEndColumn) {
628         if (RenderTableCell* cellAfter = table->cellAfter(this)) {
629             CollapsedBorderValue cellAfterAdjoiningBorder = CollapsedBorderValue(cellAfter->borderAdjoiningCellBefore(this), includeColor ? cellAfter->style()->visitedDependentColor(startColorProperty) : Color(), BCELL);
630             result = chooseBorder(result, cellAfterAdjoiningBorder);
631             if (!result.exists())
632                 return result;
633         }
634     }
635
636     bool endBorderAdjoinsTable = hasEndBorderAdjoiningTable();
637     if (endBorderAdjoinsTable) {
638         // (3) Our row's end border.
639         result = chooseBorder(result, CollapsedBorderValue(row()->borderAdjoiningEndCell(this), includeColor ? parent()->style()->visitedDependentColor(endColorProperty) : Color(), BROW));
640         if (!result.exists())
641             return result;
642         
643         // (4) Our row group's end border.
644         result = chooseBorder(result, CollapsedBorderValue(section()->borderAdjoiningEndCell(this), includeColor ? section()->style()->visitedDependentColor(endColorProperty) : Color(), BROWGROUP));
645         if (!result.exists())
646             return result;
647     }
648     
649     // (5) Our column and column group's end borders.
650     bool startColEdge;
651     bool endColEdge;
652     if (RenderTableCol* colElt = table->colElement(col() + colSpan() - 1, &startColEdge, &endColEdge)) {
653         if (colElt->isTableColumnGroup() && endColEdge) {
654             // The element is a colgroup and is also the last colgroup (in case of spanned colgroups).
655             result = chooseBorder(result, CollapsedBorderValue(colElt->borderAdjoiningCellEndBorder(this), includeColor ? colElt->style()->visitedDependentColor(endColorProperty) : Color(), BCOLGROUP));
656             if (!result.exists())
657                 return result;
658         } else if (!colElt->isTableColumnGroup()) {
659             // First apply the end border of the column irrespective of whether it is spanned or not. This is as per
660             // HTML5 which states that: "For the purposes of the CSS table model, the col element is expected to be
661             // treated as if it was present as many times as its span attribute specifies".
662             result = chooseBorder(result, CollapsedBorderValue(colElt->borderAdjoiningCellEndBorder(this), includeColor ? colElt->style()->visitedDependentColor(endColorProperty) : Color(), BCOL));
663             if (!result.exists())
664                 return result;
665             // Next, if it has a parent colgroup then we apply its end border but only if it is adjacent to the cell.
666             if (RenderTableCol* enclosingColumnGroup = colElt->enclosingColumnGroupIfAdjacentAfter()) {
667                 result = chooseBorder(result, CollapsedBorderValue(enclosingColumnGroup->borderAdjoiningCellEndBorder(this), includeColor ? enclosingColumnGroup->style()->visitedDependentColor(endColorProperty) : Color(), BCOLGROUP));
668                 if (!result.exists())
669                     return result;
670             }
671         }
672     }
673     
674     // (6) The start border of the next column.
675     if (!isEndColumn) {
676         if (RenderTableCol* colElt = table->colElement(col() + colSpan(), &startColEdge, &endColEdge)) {
677             if (colElt->isTableColumnGroup() && startColEdge) {
678                 // This case is a colgroup without any col, we only compute it if it is adjacent to the cell's edge.
679                 result = chooseBorder(result, CollapsedBorderValue(colElt->borderAdjoiningCellBefore(this), includeColor ? colElt->style()->visitedDependentColor(startColorProperty) : Color(), BCOLGROUP));
680                 if (!result.exists())
681                     return result;
682             } else if (colElt->isTableColumn()) {
683                 // Resolve the collapsing border against the col's border ignoring any 'span' as per HTML5.
684                 result = chooseBorder(result, CollapsedBorderValue(colElt->borderAdjoiningCellBefore(this), includeColor ? colElt->style()->visitedDependentColor(startColorProperty) : Color(), BCOL));
685                 if (!result.exists())
686                     return result;
687                 // If we have a parent colgroup, resolve the border only if it is adjacent to the cell.
688                 if (RenderTableCol* enclosingColumnGroup = colElt->enclosingColumnGroupIfAdjacentBefore()) {
689                     result = chooseBorder(result, CollapsedBorderValue(enclosingColumnGroup->borderAdjoiningCellStartBorder(this), includeColor ? enclosingColumnGroup->style()->visitedDependentColor(startColorProperty) : Color(), BCOLGROUP));
690                     if (!result.exists())
691                         return result;
692                 }
693             }
694         }
695     }
696
697     if (endBorderAdjoinsTable) {
698         // (7) The table's end border.
699         result = chooseBorder(result, CollapsedBorderValue(table->tableEndBorderAdjoiningCell(this), includeColor ? table->style()->visitedDependentColor(endColorProperty) : Color(), BTABLE));
700         if (!result.exists())
701             return result;
702     }
703     
704     return result;
705 }
706
707 CollapsedBorderValue RenderTableCell::collapsedBeforeBorder(IncludeBorderColorOrNot includeColor) const
708 {
709     CollapsedBorderValue result = computeCollapsedBeforeBorder(includeColor);
710     if (includeColor)
711         section()->setCachedCollapsedBorder(this, CBSBefore, result);
712     return result;
713 }
714
715 CollapsedBorderValue RenderTableCell::computeCollapsedBeforeBorder(IncludeBorderColorOrNot includeColor) const
716 {
717     RenderTable* table = this->table();
718
719     // For before border, we need to check, in order of precedence:
720     // (1) Our before border.
721     int beforeColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderBeforeColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
722     int afterColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderAfterColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
723     CollapsedBorderValue result = CollapsedBorderValue(style()->borderBefore(), includeColor ? style()->visitedDependentColor(beforeColorProperty) : Color(), BCELL);
724     
725     RenderTableCell* prevCell = table->cellAbove(this);
726     if (prevCell) {
727         // (2) A before cell's after border.
728         result = chooseBorder(CollapsedBorderValue(prevCell->style()->borderAfter(), includeColor ? prevCell->style()->visitedDependentColor(afterColorProperty) : Color(), BCELL), result);
729         if (!result.exists())
730             return result;
731     }
732     
733     // (3) Our row's before border.
734     result = chooseBorder(result, CollapsedBorderValue(parent()->style()->borderBefore(), includeColor ? parent()->style()->visitedDependentColor(beforeColorProperty) : Color(), BROW));
735     if (!result.exists())
736         return result;
737     
738     // (4) The previous row's after border.
739     if (prevCell) {
740         RenderObject* prevRow = 0;
741         if (prevCell->section() == section())
742             prevRow = parent()->previousSibling();
743         else
744             prevRow = prevCell->section()->lastChild();
745     
746         if (prevRow) {
747             result = chooseBorder(CollapsedBorderValue(prevRow->style()->borderAfter(), includeColor ? prevRow->style()->visitedDependentColor(afterColorProperty) : Color(), BROW), result);
748             if (!result.exists())
749                 return result;
750         }
751     }
752     
753     // Now check row groups.
754     RenderTableSection* currSection = section();
755     if (!rowIndex()) {
756         // (5) Our row group's before border.
757         result = chooseBorder(result, CollapsedBorderValue(currSection->style()->borderBefore(), includeColor ? currSection->style()->visitedDependentColor(beforeColorProperty) : Color(), BROWGROUP));
758         if (!result.exists())
759             return result;
760         
761         // (6) Previous row group's after border.
762         currSection = table->sectionAbove(currSection, SkipEmptySections);
763         if (currSection) {
764             result = chooseBorder(CollapsedBorderValue(currSection->style()->borderAfter(), includeColor ? currSection->style()->visitedDependentColor(afterColorProperty) : Color(), BROWGROUP), result);
765             if (!result.exists())
766                 return result;
767         }
768     }
769     
770     if (!currSection) {
771         // (8) Our column and column group's before borders.
772         RenderTableCol* colElt = table->colElement(col());
773         if (colElt) {
774             result = chooseBorder(result, CollapsedBorderValue(colElt->style()->borderBefore(), includeColor ? colElt->style()->visitedDependentColor(beforeColorProperty) : Color(), BCOL));
775             if (!result.exists())
776                 return result;
777             if (RenderTableCol* enclosingColumnGroup = colElt->enclosingColumnGroup()) {
778                 result = chooseBorder(result, CollapsedBorderValue(enclosingColumnGroup->style()->borderBefore(), includeColor ? enclosingColumnGroup->style()->visitedDependentColor(beforeColorProperty) : Color(), BCOLGROUP));
779                 if (!result.exists())
780                     return result;
781             }
782         }
783         
784         // (9) The table's before border.
785         result = chooseBorder(result, CollapsedBorderValue(table->style()->borderBefore(), includeColor ? table->style()->visitedDependentColor(beforeColorProperty) : Color(), BTABLE));
786         if (!result.exists())
787             return result;
788     }
789     
790     return result;
791 }
792
793 CollapsedBorderValue RenderTableCell::collapsedAfterBorder(IncludeBorderColorOrNot includeColor) const
794 {
795     CollapsedBorderValue result = computeCollapsedAfterBorder(includeColor);
796     if (includeColor)
797         section()->setCachedCollapsedBorder(this, CBSAfter, result);
798     return result;
799 }
800
801 CollapsedBorderValue RenderTableCell::computeCollapsedAfterBorder(IncludeBorderColorOrNot includeColor) const
802 {
803     RenderTable* table = this->table();
804
805     // For after border, we need to check, in order of precedence:
806     // (1) Our after border.
807     int beforeColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderBeforeColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
808     int afterColorProperty = includeColor ? CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderAfterColor, styleForCellFlow()->direction(), styleForCellFlow()->writingMode()) : 0;
809     CollapsedBorderValue result = CollapsedBorderValue(style()->borderAfter(), includeColor ? style()->visitedDependentColor(afterColorProperty) : Color(), BCELL);
810     
811     RenderTableCell* nextCell = table->cellBelow(this);
812     if (nextCell) {
813         // (2) An after cell's before border.
814         result = chooseBorder(result, CollapsedBorderValue(nextCell->style()->borderBefore(), includeColor ? nextCell->style()->visitedDependentColor(beforeColorProperty) : Color(), BCELL));
815         if (!result.exists())
816             return result;
817     }
818     
819     // (3) Our row's after border. (FIXME: Deal with rowspan!)
820     result = chooseBorder(result, CollapsedBorderValue(parent()->style()->borderAfter(), includeColor ? parent()->style()->visitedDependentColor(afterColorProperty) : Color(), BROW));
821     if (!result.exists())
822         return result;
823     
824     // (4) The next row's before border.
825     if (nextCell) {
826         result = chooseBorder(result, CollapsedBorderValue(nextCell->parent()->style()->borderBefore(), includeColor ? nextCell->parent()->style()->visitedDependentColor(beforeColorProperty) : Color(), BROW));
827         if (!result.exists())
828             return result;
829     }
830     
831     // Now check row groups.
832     RenderTableSection* currSection = section();
833     if (rowIndex() + rowSpan() >= currSection->numRows()) {
834         // (5) Our row group's after border.
835         result = chooseBorder(result, CollapsedBorderValue(currSection->style()->borderAfter(), includeColor ? currSection->style()->visitedDependentColor(afterColorProperty) : Color(), BROWGROUP));
836         if (!result.exists())
837             return result;
838         
839         // (6) Following row group's before border.
840         currSection = table->sectionBelow(currSection, SkipEmptySections);
841         if (currSection) {
842             result = chooseBorder(result, CollapsedBorderValue(currSection->style()->borderBefore(), includeColor ? currSection->style()->visitedDependentColor(beforeColorProperty) : Color(), BROWGROUP));
843             if (!result.exists())
844                 return result;
845         }
846     }
847     
848     if (!currSection) {
849         // (8) Our column and column group's after borders.
850         RenderTableCol* colElt = table->colElement(col());
851         if (colElt) {
852             result = chooseBorder(result, CollapsedBorderValue(colElt->style()->borderAfter(), includeColor ? colElt->style()->visitedDependentColor(afterColorProperty) : Color(), BCOL));
853             if (!result.exists()) return result;
854             if (RenderTableCol* enclosingColumnGroup = colElt->enclosingColumnGroup()) {
855                 result = chooseBorder(result, CollapsedBorderValue(enclosingColumnGroup->style()->borderAfter(), includeColor ? enclosingColumnGroup->style()->visitedDependentColor(afterColorProperty) : Color(), BCOLGROUP));
856                 if (!result.exists())
857                     return result;
858             }
859         }
860         
861         // (9) The table's after border.
862         result = chooseBorder(result, CollapsedBorderValue(table->style()->borderAfter(), includeColor ? table->style()->visitedDependentColor(afterColorProperty) : Color(), BTABLE));
863         if (!result.exists())
864             return result;
865     }
866     
867     return result;    
868 }
869
870 inline CollapsedBorderValue RenderTableCell::cachedCollapsedLeftBorder(const RenderStyle* styleForCellFlow) const
871 {
872     if (styleForCellFlow->isHorizontalWritingMode())
873         return styleForCellFlow->isLeftToRightDirection() ? section()->cachedCollapsedBorder(this, CBSStart) : section()->cachedCollapsedBorder(this, CBSEnd);
874     return styleForCellFlow->isFlippedBlocksWritingMode() ? section()->cachedCollapsedBorder(this, CBSAfter) : section()->cachedCollapsedBorder(this, CBSBefore);
875 }
876
877 inline CollapsedBorderValue RenderTableCell::cachedCollapsedRightBorder(const RenderStyle* styleForCellFlow) const
878 {
879     if (styleForCellFlow->isHorizontalWritingMode())
880         return styleForCellFlow->isLeftToRightDirection() ? section()->cachedCollapsedBorder(this, CBSEnd) : section()->cachedCollapsedBorder(this, CBSStart);
881     return styleForCellFlow->isFlippedBlocksWritingMode() ? section()->cachedCollapsedBorder(this, CBSBefore) : section()->cachedCollapsedBorder(this, CBSAfter);
882 }
883
884 inline CollapsedBorderValue RenderTableCell::cachedCollapsedTopBorder(const RenderStyle* styleForCellFlow) const
885 {
886     if (styleForCellFlow->isHorizontalWritingMode())
887         return styleForCellFlow->isFlippedBlocksWritingMode() ? section()->cachedCollapsedBorder(this, CBSAfter) : section()->cachedCollapsedBorder(this, CBSBefore);
888     return styleForCellFlow->isLeftToRightDirection() ? section()->cachedCollapsedBorder(this, CBSStart) : section()->cachedCollapsedBorder(this, CBSEnd);
889 }
890
891 inline CollapsedBorderValue RenderTableCell::cachedCollapsedBottomBorder(const RenderStyle* styleForCellFlow) const
892 {
893     if (styleForCellFlow->isHorizontalWritingMode())
894         return styleForCellFlow->isFlippedBlocksWritingMode() ? section()->cachedCollapsedBorder(this, CBSBefore) : section()->cachedCollapsedBorder(this, CBSAfter);
895     return styleForCellFlow->isLeftToRightDirection() ? section()->cachedCollapsedBorder(this, CBSEnd) : section()->cachedCollapsedBorder(this, CBSStart);
896 }
897
898 int RenderTableCell::borderLeft() const
899 {
900     return table()->collapseBorders() ? borderHalfLeft(false) : RenderBlock::borderLeft();
901 }
902
903 int RenderTableCell::borderRight() const
904 {
905     return table()->collapseBorders() ? borderHalfRight(false) : RenderBlock::borderRight();
906 }
907
908 int RenderTableCell::borderTop() const
909 {
910     return table()->collapseBorders() ? borderHalfTop(false) : RenderBlock::borderTop();
911 }
912
913 int RenderTableCell::borderBottom() const
914 {
915     return table()->collapseBorders() ? borderHalfBottom(false) : RenderBlock::borderBottom();
916 }
917
918 // FIXME: https://bugs.webkit.org/show_bug.cgi?id=46191, make the collapsed border drawing
919 // work with different block flow values instead of being hard-coded to top-to-bottom.
920 int RenderTableCell::borderStart() const
921 {
922     return table()->collapseBorders() ? borderHalfStart(false) : RenderBlock::borderStart();
923 }
924
925 int RenderTableCell::borderEnd() const
926 {
927     return table()->collapseBorders() ? borderHalfEnd(false) : RenderBlock::borderEnd();
928 }
929
930 int RenderTableCell::borderBefore() const
931 {
932     return table()->collapseBorders() ? borderHalfBefore(false) : RenderBlock::borderBefore();
933 }
934
935 int RenderTableCell::borderAfter() const
936 {
937     return table()->collapseBorders() ? borderHalfAfter(false) : RenderBlock::borderAfter();
938 }
939
940 int RenderTableCell::borderHalfLeft(bool outer) const
941 {
942     const RenderStyle* styleForCellFlow = this->styleForCellFlow();
943     if (styleForCellFlow->isHorizontalWritingMode())
944         return styleForCellFlow->isLeftToRightDirection() ? borderHalfStart(outer) : borderHalfEnd(outer);
945     return styleForCellFlow->isFlippedBlocksWritingMode() ? borderHalfAfter(outer) : borderHalfBefore(outer);
946 }
947
948 int RenderTableCell::borderHalfRight(bool outer) const
949 {
950     const RenderStyle* styleForCellFlow = this->styleForCellFlow();
951     if (styleForCellFlow->isHorizontalWritingMode())
952         return styleForCellFlow->isLeftToRightDirection() ? borderHalfEnd(outer) : borderHalfStart(outer);
953     return styleForCellFlow->isFlippedBlocksWritingMode() ? borderHalfBefore(outer) : borderHalfAfter(outer);
954 }
955
956 int RenderTableCell::borderHalfTop(bool outer) const
957 {
958     const RenderStyle* styleForCellFlow = this->styleForCellFlow();
959     if (styleForCellFlow->isHorizontalWritingMode())
960         return styleForCellFlow->isFlippedBlocksWritingMode() ? borderHalfAfter(outer) : borderHalfBefore(outer);
961     return styleForCellFlow->isLeftToRightDirection() ? borderHalfStart(outer) : borderHalfEnd(outer);
962 }
963
964 int RenderTableCell::borderHalfBottom(bool outer) const
965 {
966     const RenderStyle* styleForCellFlow = this->styleForCellFlow();
967     if (styleForCellFlow->isHorizontalWritingMode())
968         return styleForCellFlow->isFlippedBlocksWritingMode() ? borderHalfBefore(outer) : borderHalfAfter(outer);
969     return styleForCellFlow->isLeftToRightDirection() ? borderHalfEnd(outer) : borderHalfStart(outer);
970 }
971
972 int RenderTableCell::borderHalfStart(bool outer) const
973 {
974     CollapsedBorderValue border = collapsedStartBorder(DoNotIncludeBorderColor);
975     if (border.exists())
976         return (border.width() + ((styleForCellFlow()->isLeftToRightDirection() ^ outer) ? 1 : 0)) / 2; // Give the extra pixel to top and left.
977     return 0;
978 }
979     
980 int RenderTableCell::borderHalfEnd(bool outer) const
981 {
982     CollapsedBorderValue border = collapsedEndBorder(DoNotIncludeBorderColor);
983     if (border.exists())
984         return (border.width() + ((styleForCellFlow()->isLeftToRightDirection() ^ outer) ? 0 : 1)) / 2;
985     return 0;
986 }
987
988 int RenderTableCell::borderHalfBefore(bool outer) const
989 {
990     CollapsedBorderValue border = collapsedBeforeBorder(DoNotIncludeBorderColor);
991     if (border.exists())
992         return (border.width() + ((styleForCellFlow()->isFlippedBlocksWritingMode() ^ outer) ? 0 : 1)) / 2; // Give the extra pixel to top and left.
993     return 0;
994 }
995
996 int RenderTableCell::borderHalfAfter(bool outer) const
997 {
998     CollapsedBorderValue border = collapsedAfterBorder(DoNotIncludeBorderColor);
999     if (border.exists())
1000         return (border.width() + ((styleForCellFlow()->isFlippedBlocksWritingMode() ^ outer) ? 1 : 0)) / 2;
1001     return 0;
1002 }
1003
1004 void RenderTableCell::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
1005 {
1006     ASSERT(paintInfo.phase != PaintPhaseCollapsedTableBorders);
1007     RenderBlock::paint(paintInfo, paintOffset);
1008 }
1009
1010 static EBorderStyle collapsedBorderStyle(EBorderStyle style)
1011 {
1012     if (style == OUTSET)
1013         return GROOVE;
1014     if (style == INSET)
1015         return RIDGE;
1016     return style;
1017 }
1018
1019 struct CollapsedBorder {
1020     CollapsedBorderValue borderValue;
1021     BoxSide side;
1022     bool shouldPaint;
1023     int x1;
1024     int y1;
1025     int x2;
1026     int y2;
1027     EBorderStyle style;
1028 };
1029
1030 class CollapsedBorders {
1031 public:
1032     CollapsedBorders()
1033         : m_count(0)
1034     {
1035     }
1036     
1037     void addBorder(const CollapsedBorderValue& borderValue, BoxSide borderSide, bool shouldPaint,
1038                    int x1, int y1, int x2, int y2, EBorderStyle borderStyle)
1039     {
1040         if (borderValue.exists() && shouldPaint) {
1041             m_borders[m_count].borderValue = borderValue;
1042             m_borders[m_count].side = borderSide;
1043             m_borders[m_count].shouldPaint = shouldPaint;
1044             m_borders[m_count].x1 = x1;
1045             m_borders[m_count].x2 = x2;
1046             m_borders[m_count].y1 = y1;
1047             m_borders[m_count].y2 = y2;
1048             m_borders[m_count].style = borderStyle;
1049             m_count++;
1050         }
1051     }
1052
1053     CollapsedBorder* nextBorder()
1054     {
1055         for (unsigned i = 0; i < m_count; i++) {
1056             if (m_borders[i].borderValue.exists() && m_borders[i].shouldPaint) {
1057                 m_borders[i].shouldPaint = false;
1058                 return &m_borders[i];
1059             }
1060         }
1061         
1062         return 0;
1063     }
1064     
1065     CollapsedBorder m_borders[4];
1066     unsigned m_count;
1067 };
1068
1069 static void addBorderStyle(RenderTable::CollapsedBorderValues& borderValues,
1070                            CollapsedBorderValue borderValue)
1071 {
1072     if (!borderValue.exists())
1073         return;
1074     size_t count = borderValues.size();
1075     for (size_t i = 0; i < count; ++i)
1076         if (borderValues[i].isSameIgnoringColor(borderValue))
1077             return;
1078     borderValues.append(borderValue);
1079 }
1080
1081 void RenderTableCell::collectBorderValues(RenderTable::CollapsedBorderValues& borderValues) const
1082 {
1083     addBorderStyle(borderValues, collapsedStartBorder());
1084     addBorderStyle(borderValues, collapsedEndBorder());
1085     addBorderStyle(borderValues, collapsedBeforeBorder());
1086     addBorderStyle(borderValues, collapsedAfterBorder());
1087 }
1088
1089 static int compareBorderValuesForQSort(const void* pa, const void* pb)
1090 {
1091     const CollapsedBorderValue* a = static_cast<const CollapsedBorderValue*>(pa);
1092     const CollapsedBorderValue* b = static_cast<const CollapsedBorderValue*>(pb);
1093     if (a->isSameIgnoringColor(*b))
1094         return 0;
1095     return compareBorders(*a, *b);
1096 }
1097
1098 void RenderTableCell::sortBorderValues(RenderTable::CollapsedBorderValues& borderValues)
1099 {
1100     qsort(borderValues.data(), borderValues.size(), sizeof(CollapsedBorderValue),
1101         compareBorderValuesForQSort);
1102 }
1103
1104 void RenderTableCell::paintCollapsedBorders(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
1105 {
1106     ASSERT(paintInfo.phase == PaintPhaseCollapsedTableBorders);
1107
1108     if (!paintInfo.shouldPaintWithinRoot(this) || style()->visibility() != VISIBLE)
1109         return;
1110
1111     LayoutRect localRepaintRect = paintInfo.rect;
1112     localRepaintRect.inflate(maximalOutlineSize(paintInfo.phase));
1113
1114     LayoutRect paintRect = LayoutRect(paintOffset + location(), pixelSnappedSize());
1115     if (paintRect.y() - table()->outerBorderTop() >= localRepaintRect.maxY())
1116         return;
1117
1118     if (paintRect.maxY() + table()->outerBorderBottom() <= localRepaintRect.y())
1119         return;
1120
1121     GraphicsContext* graphicsContext = paintInfo.context;
1122     if (!table()->currentBorderValue() || graphicsContext->paintingDisabled())
1123         return;
1124
1125     const RenderStyle* styleForCellFlow = this->styleForCellFlow();
1126     CollapsedBorderValue leftVal = cachedCollapsedLeftBorder(styleForCellFlow);
1127     CollapsedBorderValue rightVal = cachedCollapsedRightBorder(styleForCellFlow);
1128     CollapsedBorderValue topVal = cachedCollapsedTopBorder(styleForCellFlow);
1129     CollapsedBorderValue bottomVal = cachedCollapsedBottomBorder(styleForCellFlow);
1130      
1131     // Adjust our x/y/width/height so that we paint the collapsed borders at the correct location.
1132     int topWidth = topVal.width();
1133     int bottomWidth = bottomVal.width();
1134     int leftWidth = leftVal.width();
1135     int rightWidth = rightVal.width();
1136
1137     IntRect borderRect = pixelSnappedIntRect(paintRect.x() - leftWidth / 2,
1138             paintRect.y() - topWidth / 2,
1139             paintRect.width() + leftWidth / 2 + (rightWidth + 1) / 2,
1140             paintRect.height() + topWidth / 2 + (bottomWidth + 1) / 2);
1141
1142     EBorderStyle topStyle = collapsedBorderStyle(topVal.style());
1143     EBorderStyle bottomStyle = collapsedBorderStyle(bottomVal.style());
1144     EBorderStyle leftStyle = collapsedBorderStyle(leftVal.style());
1145     EBorderStyle rightStyle = collapsedBorderStyle(rightVal.style());
1146     
1147     bool renderTop = topStyle > BHIDDEN && !topVal.isTransparent();
1148     bool renderBottom = bottomStyle > BHIDDEN && !bottomVal.isTransparent();
1149     bool renderLeft = leftStyle > BHIDDEN && !leftVal.isTransparent();
1150     bool renderRight = rightStyle > BHIDDEN && !rightVal.isTransparent();
1151
1152     // We never paint diagonals at the joins.  We simply let the border with the highest
1153     // precedence paint on top of borders with lower precedence.  
1154     CollapsedBorders borders;
1155     borders.addBorder(topVal, BSTop, renderTop, borderRect.x(), borderRect.y(), borderRect.maxX(), borderRect.y() + topWidth, topStyle);
1156     borders.addBorder(bottomVal, BSBottom, renderBottom, borderRect.x(), borderRect.maxY() - bottomWidth, borderRect.maxX(), borderRect.maxY(), bottomStyle);
1157     borders.addBorder(leftVal, BSLeft, renderLeft, borderRect.x(), borderRect.y(), borderRect.x() + leftWidth, borderRect.maxY(), leftStyle);
1158     borders.addBorder(rightVal, BSRight, renderRight, borderRect.maxX() - rightWidth, borderRect.y(), borderRect.maxX(), borderRect.maxY(), rightStyle);
1159
1160     bool antialias = shouldAntialiasLines(graphicsContext);
1161     
1162     for (CollapsedBorder* border = borders.nextBorder(); border; border = borders.nextBorder()) {
1163         if (border->borderValue.isSameIgnoringColor(*table()->currentBorderValue()))
1164             drawLineForBoxSide(graphicsContext, border->x1, border->y1, border->x2, border->y2, border->side, 
1165                                border->borderValue.color(), border->style, 0, 0, antialias);
1166     }
1167 }
1168
1169 void RenderTableCell::paintBackgroundsBehindCell(PaintInfo& paintInfo, const LayoutPoint& paintOffset, RenderObject* backgroundObject)
1170 {
1171     if (!paintInfo.shouldPaintWithinRoot(this))
1172         return;
1173
1174     if (!backgroundObject)
1175         return;
1176
1177     if (style()->visibility() != VISIBLE)
1178         return;
1179
1180     RenderTable* tableElt = table();
1181     if (!tableElt->collapseBorders() && style()->emptyCells() == HIDE && !firstChild())
1182         return;
1183
1184     LayoutPoint adjustedPaintOffset = paintOffset;
1185     if (backgroundObject != this)
1186         adjustedPaintOffset.moveBy(location());
1187
1188     Color c = backgroundObject->style()->visitedDependentColor(CSSPropertyBackgroundColor);
1189     const FillLayer* bgLayer = backgroundObject->style()->backgroundLayers();
1190
1191     if (bgLayer->hasImage() || c.isValid()) {
1192         // We have to clip here because the background would paint
1193         // on top of the borders otherwise.  This only matters for cells and rows.
1194         bool shouldClip = backgroundObject->hasLayer() && (backgroundObject == this || backgroundObject == parent()) && tableElt->collapseBorders();
1195         GraphicsContextStateSaver stateSaver(*paintInfo.context, shouldClip);
1196         if (shouldClip) {
1197             LayoutRect clipRect(adjustedPaintOffset.x() + borderLeft(), adjustedPaintOffset.y() + borderTop(),
1198                 width() - borderLeft() - borderRight(), height() - borderTop() - borderBottom());
1199             paintInfo.context->clip(clipRect);
1200         }
1201         paintFillLayers(paintInfo, c, bgLayer, LayoutRect(adjustedPaintOffset, pixelSnappedSize()), BackgroundBleedNone, CompositeSourceOver, backgroundObject);
1202     }
1203 }
1204
1205 void RenderTableCell::paintBoxDecorations(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
1206 {
1207     if (!paintInfo.shouldPaintWithinRoot(this))
1208         return;
1209
1210     RenderTable* tableElt = table();
1211     if (!tableElt->collapseBorders() && style()->emptyCells() == HIDE && !firstChild())
1212         return;
1213
1214     LayoutRect paintRect = LayoutRect(paintOffset, pixelSnappedSize());
1215     paintBoxShadow(paintInfo, paintRect, style(), Normal);
1216     
1217     // Paint our cell background.
1218     paintBackgroundsBehindCell(paintInfo, paintOffset, this);
1219
1220     paintBoxShadow(paintInfo, paintRect, style(), Inset);
1221
1222     if (!style()->hasBorder() || tableElt->collapseBorders())
1223         return;
1224
1225     paintBorder(paintInfo, paintRect, style());
1226 }
1227
1228 void RenderTableCell::paintMask(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
1229 {
1230     if (style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseMask)
1231         return;
1232
1233     RenderTable* tableElt = table();
1234     if (!tableElt->collapseBorders() && style()->emptyCells() == HIDE && !firstChild())
1235         return;
1236    
1237     paintMaskImages(paintInfo, LayoutRect(paintOffset, pixelSnappedSize()));
1238 }
1239
1240 bool RenderTableCell::boxShadowShouldBeAppliedToBackground(BackgroundBleedAvoidance, InlineFlowBox*) const
1241 {
1242     return false;
1243 }
1244
1245 void RenderTableCell::scrollbarsChanged(bool horizontalScrollbarChanged, bool verticalScrollbarChanged)
1246 {
1247     LayoutUnit scrollbarHeight = scrollbarLogicalHeight();
1248     if (!scrollbarHeight)
1249         return; // Not sure if we should be doing something when a scrollbar goes away or not.
1250     
1251     // We only care if the scrollbar that affects our intrinsic padding has been added.
1252     if ((isHorizontalWritingMode() && !horizontalScrollbarChanged) ||
1253         (!isHorizontalWritingMode() && !verticalScrollbarChanged))
1254         return;
1255
1256     // Shrink our intrinsic padding as much as possible to accommodate the scrollbar.
1257     if (style()->verticalAlign() == MIDDLE) {
1258         LayoutUnit totalHeight = logicalHeight();
1259         LayoutUnit heightWithoutIntrinsicPadding = totalHeight - intrinsicPaddingBefore() - intrinsicPaddingAfter();
1260         totalHeight -= scrollbarHeight;
1261         LayoutUnit newBeforePadding = (totalHeight - heightWithoutIntrinsicPadding) / 2;
1262         LayoutUnit newAfterPadding = totalHeight - heightWithoutIntrinsicPadding - newBeforePadding;
1263         setIntrinsicPaddingBefore(newBeforePadding);
1264         setIntrinsicPaddingAfter(newAfterPadding);
1265     } else
1266         setIntrinsicPaddingAfter(intrinsicPaddingAfter() - scrollbarHeight);
1267 }
1268
1269 RenderTableCell* RenderTableCell::createAnonymous(Document* document)
1270 {
1271     RenderTableCell* renderer = new (document->renderArena()) RenderTableCell(0);
1272     renderer->setDocumentForAnonymous(document);
1273     return renderer;
1274 }
1275
1276 RenderTableCell* RenderTableCell::createAnonymousWithParentRenderer(const RenderObject* parent)
1277 {
1278     RenderTableCell* newCell = RenderTableCell::createAnonymous(parent->document());
1279     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parent->style(), TABLE_CELL);
1280     newCell->setStyle(newStyle.release());
1281     return newCell;
1282 }
1283
1284 } // namespace WebCore