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