a9e3af742e8bea3f50bc0dafd54c0db8035e0ccf
[WebKit-https.git] / Source / WebCore / rendering / RootInlineBox.cpp
1 /*
2  * Copyright (C) 2003, 2006, 2008 Apple Inc. All rights reserved.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB.  If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  */
19
20 #include "config.h"
21 #include "RootInlineBox.h"
22
23 #include "BidiResolver.h"
24 #include "Chrome.h"
25 #include "ChromeClient.h"
26 #include "Document.h"
27 #include "EllipsisBox.h"
28 #include "Frame.h"
29 #include "GraphicsContext.h"
30 #include "HitTestResult.h"
31 #include "InlineTextBox.h"
32 #include "LogicalSelectionOffsetCaches.h"
33 #include "Page.h"
34 #include "PaintInfo.h"
35 #include "RenderFlowThread.h"
36 #include "RenderView.h"
37 #include "VerticalPositionCache.h"
38 #include <wtf/unicode/Unicode.h>
39
40 namespace WebCore {
41     
42 struct SameSizeAsRootInlineBox : public InlineFlowBox {
43     unsigned variables[7];
44     void* pointers[4];
45 };
46
47 COMPILE_ASSERT(sizeof(RootInlineBox) == sizeof(SameSizeAsRootInlineBox), RootInlineBox_should_stay_small);
48
49 typedef WTF::HashMap<const RootInlineBox*, std::unique_ptr<EllipsisBox>> EllipsisBoxMap;
50 static EllipsisBoxMap* gEllipsisBoxMap = 0;
51
52 RootInlineBox::RootInlineBox(RenderBlockFlow& block)
53     : InlineFlowBox(block)
54     , m_lineBreakPos(0)
55     , m_lineBreakObj(nullptr)
56     , m_containingRegion(nullptr)
57 {
58     setIsHorizontal(block.isHorizontalWritingMode());
59 }
60
61 RootInlineBox::~RootInlineBox()
62 {
63     detachEllipsisBox();
64 }
65
66 void RootInlineBox::detachEllipsisBox()
67 {
68     if (hasEllipsisBox()) {
69         auto box = gEllipsisBoxMap->take(this);
70         box->setParent(nullptr);
71         setHasEllipsisBox(false);
72     }
73 }
74
75 RenderLineBoxList& RootInlineBox::rendererLineBoxes() const
76 {
77     return blockFlow().lineBoxes();
78 }
79
80 void RootInlineBox::clearTruncation()
81 {
82     if (hasEllipsisBox()) {
83         detachEllipsisBox();
84         InlineFlowBox::clearTruncation();
85     }
86 }
87
88 bool RootInlineBox::isHyphenated() const
89 {
90     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
91         if (box->isInlineTextBox()) {
92             if (toInlineTextBox(box)->hasHyphen())
93                 return true;
94         }
95     }
96
97     return false;
98 }
99
100 int RootInlineBox::baselinePosition(FontBaseline baselineType) const
101 {
102     return renderer().baselinePosition(baselineType, isFirstLine(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOfInteriorLineBoxes);
103 }
104
105 LayoutUnit RootInlineBox::lineHeight() const
106 {
107     return renderer().lineHeight(isFirstLine(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOfInteriorLineBoxes);
108 }
109
110 bool RootInlineBox::lineCanAccommodateEllipsis(bool ltr, int blockEdge, int lineBoxEdge, int ellipsisWidth)
111 {
112     // First sanity-check the unoverflowed width of the whole line to see if there is sufficient room.
113     int delta = ltr ? lineBoxEdge - blockEdge : blockEdge - lineBoxEdge;
114     if (logicalWidth() - delta < ellipsisWidth)
115         return false;
116
117     // Next iterate over all the line boxes on the line.  If we find a replaced element that intersects
118     // then we refuse to accommodate the ellipsis.  Otherwise we're ok.
119     return InlineFlowBox::canAccommodateEllipsis(ltr, blockEdge, ellipsisWidth);
120 }
121
122 float RootInlineBox::placeEllipsis(const AtomicString& ellipsisStr,  bool ltr, float blockLeftEdge, float blockRightEdge, float ellipsisWidth, InlineBox* markupBox)
123 {
124     if (!gEllipsisBoxMap)
125         gEllipsisBoxMap = new EllipsisBoxMap();
126
127     // Create an ellipsis box.
128     auto newEllipsisBox = std::make_unique<EllipsisBox>(blockFlow(), ellipsisStr, this, ellipsisWidth - (markupBox ? markupBox->logicalWidth() : 0), logicalHeight(), y(), !prevRootBox(), isHorizontal(), markupBox);
129     auto ellipsisBox = newEllipsisBox.get();
130
131     gEllipsisBoxMap->add(this, std::move(newEllipsisBox));
132     setHasEllipsisBox(true);
133
134     // FIXME: Do we need an RTL version of this?
135     if (ltr && (x() + logicalWidth() + ellipsisWidth) <= blockRightEdge) {
136         ellipsisBox->setX(x() + logicalWidth());
137         return logicalWidth() + ellipsisWidth;
138     }
139
140     // Now attempt to find the nearest glyph horizontally and place just to the right (or left in RTL)
141     // of that glyph.  Mark all of the objects that intersect the ellipsis box as not painting (as being
142     // truncated).
143     bool foundBox = false;
144     float truncatedWidth = 0;
145     float position = placeEllipsisBox(ltr, blockLeftEdge, blockRightEdge, ellipsisWidth, truncatedWidth, foundBox);
146     ellipsisBox->setX(position);
147     return truncatedWidth;
148 }
149
150 float RootInlineBox::placeEllipsisBox(bool ltr, float blockLeftEdge, float blockRightEdge, float ellipsisWidth, float &truncatedWidth, bool& foundBox)
151 {
152     float result = InlineFlowBox::placeEllipsisBox(ltr, blockLeftEdge, blockRightEdge, ellipsisWidth, truncatedWidth, foundBox);
153     if (result == -1) {
154         result = ltr ? blockRightEdge - ellipsisWidth : blockLeftEdge;
155         truncatedWidth = blockRightEdge - blockLeftEdge;
156     }
157     return result;
158 }
159
160 void RootInlineBox::paintEllipsisBox(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom) const
161 {
162     if (hasEllipsisBox() && paintInfo.shouldPaintWithinRoot(renderer()) && renderer().style().visibility() == VISIBLE
163             && paintInfo.phase == PaintPhaseForeground)
164         ellipsisBox()->paint(paintInfo, paintOffset, lineTop, lineBottom);
165 }
166
167 #if PLATFORM(MAC)
168
169 void RootInlineBox::addHighlightOverflow()
170 {
171     Page* page = renderer().frame().page();
172     if (!page)
173         return;
174
175     // Highlight acts as a selection inflation.
176     FloatRect rootRect(0, selectionTop(), logicalWidth(), selectionHeight());
177     IntRect inflatedRect = enclosingIntRect(page->chrome().client().customHighlightRect(renderer().element(), renderer().style().highlight(), rootRect));
178     setOverflowFromLogicalRects(inflatedRect, inflatedRect, lineTop(), lineBottom());
179 }
180
181 void RootInlineBox::paintCustomHighlight(PaintInfo& paintInfo, const LayoutPoint& paintOffset, const AtomicString& highlightType)
182 {
183     if (!paintInfo.shouldPaintWithinRoot(renderer()) || renderer().style().visibility() != VISIBLE || paintInfo.phase != PaintPhaseForeground)
184         return;
185
186     Page* page = renderer().frame().page();
187     if (!page)
188         return;
189
190     // Get the inflated rect so that we can properly hit test.
191     FloatRect rootRect(paintOffset.x() + x(), paintOffset.y() + selectionTop(), logicalWidth(), selectionHeight());
192     FloatRect inflatedRect = page->chrome().client().customHighlightRect(renderer().element(), highlightType, rootRect);
193     if (inflatedRect.intersects(paintInfo.rect))
194         page->chrome().client().paintCustomHighlight(renderer().element(), highlightType, rootRect, rootRect, false, true);
195 }
196
197 #endif
198
199 void RootInlineBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
200 {
201     InlineFlowBox::paint(paintInfo, paintOffset, lineTop, lineBottom);
202     paintEllipsisBox(paintInfo, paintOffset, lineTop, lineBottom);
203 #if PLATFORM(MAC)
204     const RenderStyle& lineStyle = this->lineStyle();
205     if (lineStyle.highlight() != nullAtom && !paintInfo.context->paintingDisabled())
206         paintCustomHighlight(paintInfo, paintOffset, lineStyle.highlight());
207 #endif
208 }
209
210 bool RootInlineBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
211 {
212     if (hasEllipsisBox() && visibleToHitTesting()) {
213         if (ellipsisBox()->nodeAtPoint(request, result, locationInContainer, accumulatedOffset, lineTop, lineBottom)) {
214             renderer().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));
215             return true;
216         }
217     }
218     return InlineFlowBox::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, lineTop, lineBottom);
219 }
220
221 void RootInlineBox::adjustPosition(float dx, float dy)
222 {
223     InlineFlowBox::adjustPosition(dx, dy);
224     LayoutUnit blockDirectionDelta = isHorizontal() ? dy : dx; // The block direction delta is a LayoutUnit.
225     m_lineTop += blockDirectionDelta;
226     m_lineBottom += blockDirectionDelta;
227     m_lineTopWithLeading += blockDirectionDelta;
228     m_lineBottomWithLeading += blockDirectionDelta;
229     if (hasEllipsisBox())
230         ellipsisBox()->adjustPosition(dx, dy);
231 }
232
233 void RootInlineBox::childRemoved(InlineBox* box)
234 {
235     if (&box->renderer() == m_lineBreakObj)
236         setLineBreakInfo(0, 0, BidiStatus());
237
238     for (RootInlineBox* prev = prevRootBox(); prev && prev->lineBreakObj() == &box->renderer(); prev = prev->prevRootBox()) {
239         prev->setLineBreakInfo(0, 0, BidiStatus());
240         prev->markDirty();
241     }
242 }
243
244 RenderRegion* RootInlineBox::containingRegion() const
245 {
246 #ifndef NDEBUG
247     if (m_containingRegion) {
248         RenderFlowThread* flowThread = blockFlow().flowThreadContainingBlock();
249         const RenderRegionList& regionList = flowThread->renderRegionList();
250         ASSERT(regionList.contains(m_containingRegion));
251     }
252 #endif
253
254     return m_containingRegion;
255 }
256
257 void RootInlineBox::setContainingRegion(RenderRegion* region)
258 {
259     ASSERT(!isDirty());
260     ASSERT(blockFlow().flowThreadContainingBlock());
261     m_containingRegion = region;
262 }
263
264 LayoutUnit RootInlineBox::alignBoxesInBlockDirection(LayoutUnit heightOfBlock, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache& verticalPositionCache)
265 {
266 #if ENABLE(SVG)
267     // SVG will handle vertical alignment on its own.
268     if (isSVGRootInlineBox())
269         return 0;
270 #endif
271
272     LayoutUnit maxPositionTop = 0;
273     LayoutUnit maxPositionBottom = 0;
274     int maxAscent = 0;
275     int maxDescent = 0;
276     bool setMaxAscent = false;
277     bool setMaxDescent = false;
278
279     // Figure out if we're in no-quirks mode.
280     bool noQuirksMode = renderer().document().inNoQuirksMode();
281
282     m_baselineType = requiresIdeographicBaseline(textBoxDataMap) ? IdeographicBaseline : AlphabeticBaseline;
283
284     computeLogicalBoxHeights(this, maxPositionTop, maxPositionBottom, maxAscent, maxDescent, setMaxAscent, setMaxDescent, noQuirksMode,
285                              textBoxDataMap, baselineType(), verticalPositionCache);
286
287     if (maxAscent + maxDescent < std::max(maxPositionTop, maxPositionBottom))
288         adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);
289
290     LayoutUnit maxHeight = maxAscent + maxDescent;
291     LayoutUnit lineTop = heightOfBlock;
292     LayoutUnit lineBottom = heightOfBlock;
293     LayoutUnit lineTopIncludingMargins = heightOfBlock;
294     LayoutUnit lineBottomIncludingMargins = heightOfBlock;
295     bool setLineTop = false;
296     bool hasAnnotationsBefore = false;
297     bool hasAnnotationsAfter = false;
298     placeBoxesInBlockDirection(heightOfBlock, maxHeight, maxAscent, noQuirksMode, lineTop, lineBottom, setLineTop,
299                                lineTopIncludingMargins, lineBottomIncludingMargins, hasAnnotationsBefore, hasAnnotationsAfter, baselineType());
300     m_hasAnnotationsBefore = hasAnnotationsBefore;
301     m_hasAnnotationsAfter = hasAnnotationsAfter;
302     
303     maxHeight = std::max<LayoutUnit>(0, maxHeight); // FIXME: Is this really necessary?
304
305     setLineTopBottomPositions(lineTop, lineBottom, heightOfBlock, heightOfBlock + maxHeight);
306     setPaginatedLineWidth(blockFlow().availableLogicalWidthForContent(heightOfBlock));
307
308     LayoutUnit annotationsAdjustment = beforeAnnotationsAdjustment();
309     if (annotationsAdjustment) {
310         // FIXME: Need to handle pagination here. We might have to move to the next page/column as a result of the
311         // ruby expansion.
312         adjustBlockDirectionPosition(annotationsAdjustment);
313         heightOfBlock += annotationsAdjustment;
314     }
315
316     LayoutUnit gridSnapAdjustment = lineSnapAdjustment();
317     if (gridSnapAdjustment) {
318         adjustBlockDirectionPosition(gridSnapAdjustment);
319         heightOfBlock += gridSnapAdjustment;
320     }
321
322     return heightOfBlock + maxHeight;
323 }
324
325 #if ENABLE(CSS3_TEXT_DECORATION)
326 float RootInlineBox::maxLogicalTop() const
327 {
328     float maxLogicalTop = 0;
329     computeMaxLogicalTop(maxLogicalTop);
330     return maxLogicalTop;
331 }
332 #endif // CSS3_TEXT_DECORATION
333
334 LayoutUnit RootInlineBox::beforeAnnotationsAdjustment() const
335 {
336     LayoutUnit result = 0;
337
338     if (!renderer().style().isFlippedLinesWritingMode()) {
339         // Annotations under the previous line may push us down.
340         if (prevRootBox() && prevRootBox()->hasAnnotationsAfter())
341             result = prevRootBox()->computeUnderAnnotationAdjustment(lineTop());
342
343         if (!hasAnnotationsBefore())
344             return result;
345
346         // Annotations over this line may push us further down.
347         LayoutUnit highestAllowedPosition = prevRootBox() ? std::min(prevRootBox()->lineBottom(), lineTop()) + result : static_cast<LayoutUnit>(blockFlow().borderBefore());
348         result = computeOverAnnotationAdjustment(highestAllowedPosition);
349     } else {
350         // Annotations under this line may push us up.
351         if (hasAnnotationsBefore())
352             result = computeUnderAnnotationAdjustment(prevRootBox() ? prevRootBox()->lineBottom() : static_cast<LayoutUnit>(blockFlow().borderBefore()));
353
354         if (!prevRootBox() || !prevRootBox()->hasAnnotationsAfter())
355             return result;
356
357         // We have to compute the expansion for annotations over the previous line to see how much we should move.
358         LayoutUnit lowestAllowedPosition = std::max(prevRootBox()->lineBottom(), lineTop()) - result;
359         result = prevRootBox()->computeOverAnnotationAdjustment(lowestAllowedPosition);
360     }
361
362     return result;
363 }
364
365 LayoutUnit RootInlineBox::lineSnapAdjustment(LayoutUnit delta) const
366 {
367     // If our block doesn't have snapping turned on, do nothing.
368     // FIXME: Implement bounds snapping.
369     if (blockFlow().style().lineSnap() == LineSnapNone)
370         return 0;
371
372     // Get the current line grid and offset.
373     LayoutState* layoutState = blockFlow().view().layoutState();
374     RenderBlockFlow* lineGrid = layoutState->lineGrid();
375     LayoutSize lineGridOffset = layoutState->lineGridOffset();
376     if (!lineGrid || lineGrid->style().writingMode() != blockFlow().style().writingMode())
377         return 0;
378
379     // Get the hypothetical line box used to establish the grid.
380     RootInlineBox* lineGridBox = lineGrid->lineGridBox();
381     if (!lineGridBox)
382         return 0;
383     
384     LayoutUnit lineGridBlockOffset = lineGrid->isHorizontalWritingMode() ? lineGridOffset.height() : lineGridOffset.width();
385     LayoutUnit blockOffset = blockFlow().isHorizontalWritingMode() ? layoutState->layoutOffset().height() : layoutState->layoutOffset().width();
386
387     // Now determine our position on the grid. Our baseline needs to be adjusted to the nearest baseline multiple
388     // as established by the line box.
389     // FIXME: Need to handle crazy line-box-contain values that cause the root line box to not be considered. I assume
390     // the grid should honor line-box-contain.
391     LayoutUnit gridLineHeight = lineGridBox->lineBottomWithLeading() - lineGridBox->lineTopWithLeading();
392     if (!gridLineHeight)
393         return 0;
394
395     LayoutUnit lineGridFontAscent = lineGrid->style().fontMetrics().ascent(baselineType());
396     LayoutUnit lineGridFontHeight = lineGridBox->logicalHeight();
397     LayoutUnit firstTextTop = lineGridBlockOffset + lineGridBox->logicalTop();
398     LayoutUnit firstLineTopWithLeading = lineGridBlockOffset + lineGridBox->lineTopWithLeading();
399     LayoutUnit firstBaselinePosition = firstTextTop + lineGridFontAscent;
400
401     LayoutUnit currentTextTop = blockOffset + logicalTop() + delta;
402     LayoutUnit currentFontAscent = blockFlow().style().fontMetrics().ascent(baselineType());
403     LayoutUnit currentBaselinePosition = currentTextTop + currentFontAscent;
404
405     LayoutUnit lineGridPaginationOrigin = isHorizontal() ? layoutState->lineGridPaginationOrigin().height() : layoutState->lineGridPaginationOrigin().width();
406
407     // If we're paginated, see if we're on a page after the first one. If so, the grid resets on subsequent pages.
408     // FIXME: If the grid is an ancestor of the pagination establisher, then this is incorrect.
409     LayoutUnit pageLogicalTop = 0;
410     if (layoutState->isPaginated() && layoutState->pageLogicalHeight()) {
411         pageLogicalTop = blockFlow().pageLogicalTopForOffset(lineTopWithLeading() + delta);
412         if (pageLogicalTop > firstLineTopWithLeading)
413             firstTextTop = pageLogicalTop + lineGridBox->logicalTop() - lineGrid->borderAndPaddingBefore() + lineGridPaginationOrigin;
414     }
415
416     if (blockFlow().style().lineSnap() == LineSnapContain) {
417         // Compute the desired offset from the text-top of a grid line.
418         // Look at our height (logicalHeight()).
419         // Look at the total available height. It's going to be (textBottom - textTop) + (n-1)*(multiple with leading)
420         // where n is number of grid lines required to enclose us.
421         if (logicalHeight() <= lineGridFontHeight)
422             firstTextTop += (lineGridFontHeight - logicalHeight()) / 2;
423         else {
424             LayoutUnit numberOfLinesWithLeading = ceilf(static_cast<float>(logicalHeight() - lineGridFontHeight) / gridLineHeight);
425             LayoutUnit totalHeight = lineGridFontHeight + numberOfLinesWithLeading * gridLineHeight;
426             firstTextTop += (totalHeight - logicalHeight()) / 2;
427         }
428         firstBaselinePosition = firstTextTop + currentFontAscent;
429     } else
430         firstBaselinePosition = firstTextTop + lineGridFontAscent;
431
432     // If we're above the first line, just push to the first line.
433     if (currentBaselinePosition < firstBaselinePosition)
434         return delta + firstBaselinePosition - currentBaselinePosition;
435
436     // Otherwise we're in the middle of the grid somewhere. Just push to the next line.
437     LayoutUnit baselineOffset = currentBaselinePosition - firstBaselinePosition;
438     LayoutUnit remainder = roundToInt(baselineOffset) % roundToInt(gridLineHeight);
439     LayoutUnit result = delta;
440     if (remainder)
441         result += gridLineHeight - remainder;
442
443     // If we aren't paginated we can return the result.
444     if (!layoutState->isPaginated() || !layoutState->pageLogicalHeight() || result == delta)
445         return result;
446     
447     // We may end up shifted to a new page. We need to do a re-snap when that happens.
448     LayoutUnit newPageLogicalTop = blockFlow().pageLogicalTopForOffset(lineBottomWithLeading() + result);
449     if (newPageLogicalTop == pageLogicalTop)
450         return result;
451     
452     // Put ourselves at the top of the next page to force a snap onto the new grid established by that page.
453     return lineSnapAdjustment(newPageLogicalTop - (blockOffset + lineTopWithLeading()));
454 }
455
456 GapRects RootInlineBox::lineSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
457     LayoutUnit selTop, LayoutUnit selHeight, const LogicalSelectionOffsetCaches& cache, const PaintInfo* paintInfo)
458 {
459     RenderObject::SelectionState lineState = selectionState();
460
461     bool leftGap, rightGap;
462     blockFlow().getSelectionGapInfo(lineState, leftGap, rightGap);
463
464     GapRects result;
465
466     InlineBox* firstBox = firstSelectedBox();
467     InlineBox* lastBox = lastSelectedBox();
468     if (leftGap) {
469         result.uniteLeft(blockFlow().logicalLeftSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, &firstBox->parent()->renderer(), firstBox->logicalLeft(),
470             selTop, selHeight, cache, paintInfo));
471     }
472     if (rightGap) {
473         result.uniteRight(blockFlow().logicalRightSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, &lastBox->parent()->renderer(), lastBox->logicalRight(),
474             selTop, selHeight, cache, paintInfo));
475     }
476
477     // When dealing with bidi text, a non-contiguous selection region is possible.
478     // e.g. The logical text aaaAAAbbb (capitals denote RTL text and non-capitals LTR) is layed out
479     // visually as 3 text runs |aaa|bbb|AAA| if we select 4 characters from the start of the text the
480     // selection will look like (underline denotes selection):
481     // |aaa|bbb|AAA|
482     //  ___       _
483     // We can see that the |bbb| run is not part of the selection while the runs around it are.
484     if (firstBox && firstBox != lastBox) {
485         // Now fill in any gaps on the line that occurred between two selected elements.
486         LayoutUnit lastLogicalLeft = firstBox->logicalRight();
487         bool isPreviousBoxSelected = firstBox->selectionState() != RenderObject::SelectionNone;
488         for (InlineBox* box = firstBox->nextLeafChild(); box; box = box->nextLeafChild()) {
489             if (box->selectionState() != RenderObject::SelectionNone) {
490                 LayoutRect logicalRect(lastLogicalLeft, selTop, box->logicalLeft() - lastLogicalLeft, selHeight);
491                 logicalRect.move(renderer().isHorizontalWritingMode() ? offsetFromRootBlock : LayoutSize(offsetFromRootBlock.height(), offsetFromRootBlock.width()));
492                 LayoutRect gapRect = rootBlock.logicalRectToPhysicalRect(rootBlockPhysicalPosition, logicalRect);
493                 if (isPreviousBoxSelected && gapRect.width() > 0 && gapRect.height() > 0) {
494                     if (paintInfo && box->parent()->renderer().style().visibility() == VISIBLE)
495                         paintInfo->context->fillRect(gapRect, box->parent()->renderer().selectionBackgroundColor(), box->parent()->renderer().style().colorSpace());
496                     // VisibleSelection may be non-contiguous, see comment above.
497                     result.uniteCenter(gapRect);
498                 }
499                 lastLogicalLeft = box->logicalRight();
500             }
501             if (box == lastBox)
502                 break;
503             isPreviousBoxSelected = box->selectionState() != RenderObject::SelectionNone;
504         }
505     }
506
507     return result;
508 }
509
510 IntRect RootInlineBox::computeCaretRect(float logicalLeftPosition, unsigned caretWidth, LayoutUnit* extraWidthToEndOfLine) const
511 {
512     int height = selectionHeight();
513     int top = selectionTop();
514
515     // Distribute the caret's width to either side of the offset.
516     float left = logicalLeftPosition;
517     int caretWidthLeftOfOffset = caretWidth / 2;
518     left -= caretWidthLeftOfOffset;
519     int caretWidthRightOfOffset = caretWidth - caretWidthLeftOfOffset;
520     left = roundf(left);
521
522     float rootLeft = logicalLeft();
523     float rootRight = logicalRight();
524
525     if (extraWidthToEndOfLine)
526         *extraWidthToEndOfLine = (logicalWidth() + rootLeft) - (left + caretWidth);
527
528     const RenderStyle& blockStyle = blockFlow().style();
529
530     bool rightAligned = false;
531     switch (blockStyle.textAlign()) {
532     case RIGHT:
533     case WEBKIT_RIGHT:
534         rightAligned = true;
535         break;
536     case LEFT:
537     case WEBKIT_LEFT:
538     case CENTER:
539     case WEBKIT_CENTER:
540         break;
541     case JUSTIFY:
542     case TASTART:
543         rightAligned = !blockStyle.isLeftToRightDirection();
544         break;
545     case TAEND:
546         rightAligned = blockStyle.isLeftToRightDirection();
547         break;
548     }
549
550     float leftEdge = std::min<float>(0, rootLeft);
551     float rightEdge = std::max<float>(blockFlow().logicalWidth(), rootRight);
552
553     if (rightAligned) {
554         left = std::max(left, leftEdge);
555         left = std::min(left, rootRight - caretWidth);
556     } else {
557         left = std::min(left, rightEdge - caretWidthRightOfOffset);
558         left = std::max(left, rootLeft);
559     }
560     return blockStyle.isHorizontalWritingMode() ? IntRect(left, top, caretWidth, height) : IntRect(top, left, height, caretWidth);
561 }
562
563 RenderObject::SelectionState RootInlineBox::selectionState()
564 {
565     // Walk over all of the selected boxes.
566     RenderObject::SelectionState state = RenderObject::SelectionNone;
567     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
568         RenderObject::SelectionState boxState = box->selectionState();
569         if ((boxState == RenderObject::SelectionStart && state == RenderObject::SelectionEnd) ||
570             (boxState == RenderObject::SelectionEnd && state == RenderObject::SelectionStart))
571             state = RenderObject::SelectionBoth;
572         else if (state == RenderObject::SelectionNone ||
573                  ((boxState == RenderObject::SelectionStart || boxState == RenderObject::SelectionEnd) &&
574                   (state == RenderObject::SelectionNone || state == RenderObject::SelectionInside)))
575             state = boxState;
576         else if (boxState == RenderObject::SelectionNone && state == RenderObject::SelectionStart) {
577             // We are past the end of the selection.
578             state = RenderObject::SelectionBoth;
579         }
580         if (state == RenderObject::SelectionBoth)
581             break;
582     }
583
584     return state;
585 }
586
587 InlineBox* RootInlineBox::firstSelectedBox()
588 {
589     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
590         if (box->selectionState() != RenderObject::SelectionNone)
591             return box;
592     }
593
594     return 0;
595 }
596
597 InlineBox* RootInlineBox::lastSelectedBox()
598 {
599     for (InlineBox* box = lastLeafChild(); box; box = box->prevLeafChild()) {
600         if (box->selectionState() != RenderObject::SelectionNone)
601             return box;
602     }
603
604     return 0;
605 }
606
607 LayoutUnit RootInlineBox::selectionTop() const
608 {
609     LayoutUnit selectionTop = m_lineTop;
610
611     if (m_hasAnnotationsBefore)
612         selectionTop -= !renderer().style().isFlippedLinesWritingMode() ? computeOverAnnotationAdjustment(m_lineTop) : computeUnderAnnotationAdjustment(m_lineTop);
613
614     if (renderer().style().isFlippedLinesWritingMode())
615         return selectionTop;
616
617     LayoutUnit prevBottom = prevRootBox() ? prevRootBox()->selectionBottom() : blockFlow().borderAndPaddingBefore();
618     if (prevBottom < selectionTop && blockFlow().containsFloats()) {
619         // This line has actually been moved further down, probably from a large line-height, but possibly because the
620         // line was forced to clear floats.  If so, let's check the offsets, and only be willing to use the previous
621         // line's bottom if the offsets are greater on both sides.
622         LayoutUnit prevLeft = blockFlow().logicalLeftOffsetForLine(prevBottom, false);
623         LayoutUnit prevRight = blockFlow().logicalRightOffsetForLine(prevBottom, false);
624         LayoutUnit newLeft = blockFlow().logicalLeftOffsetForLine(selectionTop, false);
625         LayoutUnit newRight = blockFlow().logicalRightOffsetForLine(selectionTop, false);
626         if (prevLeft > newLeft || prevRight < newRight)
627             return selectionTop;
628     }
629
630     return prevBottom;
631 }
632
633 LayoutUnit RootInlineBox::selectionTopAdjustedForPrecedingBlock() const
634 {
635     const RootInlineBox& rootBox = root();
636     LayoutUnit top = selectionTop();
637
638     RenderObject::SelectionState blockSelectionState = rootBox.blockFlow().selectionState();
639     if (blockSelectionState != RenderObject::SelectionInside && blockSelectionState != RenderObject::SelectionEnd)
640         return top;
641
642     LayoutSize offsetToBlockBefore;
643     if (RenderBlock* block = rootBox.blockFlow().blockBeforeWithinSelectionRoot(offsetToBlockBefore)) {
644         if (block->isRenderBlockFlow()) {
645             if (RootInlineBox* lastLine = toRenderBlockFlow(block)->lastRootBox()) {
646                 RenderObject::SelectionState lastLineSelectionState = lastLine->selectionState();
647                 if (lastLineSelectionState != RenderObject::SelectionInside && lastLineSelectionState != RenderObject::SelectionStart)
648                     return top;
649
650                 LayoutUnit lastLineSelectionBottom = lastLine->selectionBottom() + offsetToBlockBefore.height();
651                 top = std::max(top, lastLineSelectionBottom);
652             }
653         }
654     }
655
656     return top;
657 }
658
659 LayoutUnit RootInlineBox::selectionBottom() const
660 {
661     LayoutUnit selectionBottom = m_lineBottom;
662
663     if (m_hasAnnotationsAfter)
664         selectionBottom += !renderer().style().isFlippedLinesWritingMode() ? computeUnderAnnotationAdjustment(m_lineBottom) : computeOverAnnotationAdjustment(m_lineBottom);
665
666     if (!renderer().style().isFlippedLinesWritingMode() || !nextRootBox())
667         return selectionBottom;
668
669     LayoutUnit nextTop = nextRootBox()->selectionTop();
670     if (nextTop > selectionBottom && blockFlow().containsFloats()) {
671         // The next line has actually been moved further over, probably from a large line-height, but possibly because the
672         // line was forced to clear floats.  If so, let's check the offsets, and only be willing to use the next
673         // line's top if the offsets are greater on both sides.
674         LayoutUnit nextLeft = blockFlow().logicalLeftOffsetForLine(nextTop, false);
675         LayoutUnit nextRight = blockFlow().logicalRightOffsetForLine(nextTop, false);
676         LayoutUnit newLeft = blockFlow().logicalLeftOffsetForLine(selectionBottom, false);
677         LayoutUnit newRight = blockFlow().logicalRightOffsetForLine(selectionBottom, false);
678         if (nextLeft > newLeft || nextRight < newRight)
679             return selectionBottom;
680     }
681
682     return nextTop;
683 }
684
685 int RootInlineBox::blockDirectionPointInLine() const
686 {
687     return !blockFlow().style().isFlippedBlocksWritingMode() ? std::max(lineTop(), selectionTop()) : std::min(lineBottom(), selectionBottom());
688 }
689
690 RenderBlockFlow& RootInlineBox::blockFlow() const
691 {
692     return toRenderBlockFlow(renderer());
693 }
694
695 static bool isEditableLeaf(InlineBox* leaf)
696 {
697     return leaf && leaf->renderer().node() && leaf->renderer().node()->rendererIsEditable();
698 }
699
700 InlineBox* RootInlineBox::closestLeafChildForPoint(const IntPoint& pointInContents, bool onlyEditableLeaves)
701 {
702     return closestLeafChildForLogicalLeftPosition(blockFlow().isHorizontalWritingMode() ? pointInContents.x() : pointInContents.y(), onlyEditableLeaves);
703 }
704
705 InlineBox* RootInlineBox::closestLeafChildForLogicalLeftPosition(int leftPosition, bool onlyEditableLeaves)
706 {
707     InlineBox* firstLeaf = firstLeafChild();
708     InlineBox* lastLeaf = lastLeafChild();
709
710     if (firstLeaf != lastLeaf) {
711         if (firstLeaf->isLineBreak())
712             firstLeaf = firstLeaf->nextLeafChildIgnoringLineBreak();
713         else if (lastLeaf->isLineBreak())
714             lastLeaf = lastLeaf->prevLeafChildIgnoringLineBreak();
715     }
716
717     if (firstLeaf == lastLeaf && (!onlyEditableLeaves || isEditableLeaf(firstLeaf)))
718         return firstLeaf;
719
720     // Avoid returning a list marker when possible.
721     if (leftPosition <= firstLeaf->logicalLeft() && !firstLeaf->renderer().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(firstLeaf)))
722         // The leftPosition coordinate is less or equal to left edge of the firstLeaf.
723         // Return it.
724         return firstLeaf;
725
726     if (leftPosition >= lastLeaf->logicalRight() && !lastLeaf->renderer().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(lastLeaf)))
727         // The leftPosition coordinate is greater or equal to right edge of the lastLeaf.
728         // Return it.
729         return lastLeaf;
730
731     InlineBox* closestLeaf = 0;
732     for (InlineBox* leaf = firstLeaf; leaf; leaf = leaf->nextLeafChildIgnoringLineBreak()) {
733         if (!leaf->renderer().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(leaf))) {
734             closestLeaf = leaf;
735             if (leftPosition < leaf->logicalRight())
736                 // The x coordinate is less than the right edge of the box.
737                 // Return it.
738                 return leaf;
739         }
740     }
741
742     return closestLeaf ? closestLeaf : lastLeaf;
743 }
744
745 BidiStatus RootInlineBox::lineBreakBidiStatus() const
746
747     return BidiStatus(static_cast<UCharDirection>(m_lineBreakBidiStatusEor), static_cast<UCharDirection>(m_lineBreakBidiStatusLastStrong), static_cast<UCharDirection>(m_lineBreakBidiStatusLast), m_lineBreakContext);
748 }
749
750 void RootInlineBox::setLineBreakInfo(RenderObject* obj, unsigned breakPos, const BidiStatus& status)
751 {
752     m_lineBreakObj = obj;
753     m_lineBreakPos = breakPos;
754     m_lineBreakBidiStatusEor = status.eor;
755     m_lineBreakBidiStatusLastStrong = status.lastStrong;
756     m_lineBreakBidiStatusLast = status.last;
757     m_lineBreakContext = status.context;
758 }
759
760 EllipsisBox* RootInlineBox::ellipsisBox() const
761 {
762     if (!hasEllipsisBox())
763         return 0;
764     return gEllipsisBoxMap->get(this);
765 }
766
767 void RootInlineBox::removeLineBoxFromRenderObject()
768 {
769     blockFlow().lineBoxes().removeLineBox(this);
770 }
771
772 void RootInlineBox::extractLineBoxFromRenderObject()
773 {
774     blockFlow().lineBoxes().extractLineBox(this);
775 }
776
777 void RootInlineBox::attachLineBoxToRenderObject()
778 {
779     blockFlow().lineBoxes().attachLineBox(this);
780 }
781
782 LayoutRect RootInlineBox::paddedLayoutOverflowRect(LayoutUnit endPadding) const
783 {
784     LayoutRect lineLayoutOverflow = layoutOverflowRect(lineTop(), lineBottom());
785     if (!endPadding)
786         return lineLayoutOverflow;
787     
788     // FIXME: Audit whether to use pixel snapped values when not using integers for layout: https://bugs.webkit.org/show_bug.cgi?id=63656
789     if (isHorizontal()) {
790         if (isLeftToRightDirection())
791             lineLayoutOverflow.shiftMaxXEdgeTo(std::max<LayoutUnit>(lineLayoutOverflow.maxX(), pixelSnappedLogicalRight() + endPadding));
792         else
793             lineLayoutOverflow.shiftXEdgeTo(std::min<LayoutUnit>(lineLayoutOverflow.x(), pixelSnappedLogicalLeft() - endPadding));
794     } else {
795         if (isLeftToRightDirection())
796             lineLayoutOverflow.shiftMaxYEdgeTo(std::max<LayoutUnit>(lineLayoutOverflow.maxY(), pixelSnappedLogicalRight() + endPadding));
797         else
798             lineLayoutOverflow.shiftYEdgeTo(std::min<LayoutUnit>(lineLayoutOverflow.y(), pixelSnappedLogicalLeft() - endPadding));
799     }
800     
801     return lineLayoutOverflow;
802 }
803
804 static void setAscentAndDescent(int& ascent, int& descent, int newAscent, int newDescent, bool& ascentDescentSet)
805 {
806     if (!ascentDescentSet) {
807         ascentDescentSet = true;
808         ascent = newAscent;
809         descent = newDescent;
810     } else {
811         ascent = std::max(ascent, newAscent);
812         descent = std::max(descent, newDescent);
813     }
814 }
815
816 void RootInlineBox::ascentAndDescentForBox(InlineBox* box, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, int& ascent, int& descent,
817                                            bool& affectsAscent, bool& affectsDescent) const
818 {
819     bool ascentDescentSet = false;
820
821     // Replaced boxes will return 0 for the line-height if line-box-contain says they are
822     // not to be included.
823     if (box->renderer().isReplaced()) {
824         if (lineStyle().lineBoxContain() & LineBoxContainReplaced) {
825             ascent = box->baselinePosition(baselineType());
826             descent = box->lineHeight() - ascent;
827             
828             // Replaced elements always affect both the ascent and descent.
829             affectsAscent = true;
830             affectsDescent = true;
831         }
832         return;
833     }
834
835     Vector<const SimpleFontData*>* usedFonts = 0;
836     GlyphOverflow* glyphOverflow = 0;
837     if (box->isInlineTextBox()) {
838         GlyphOverflowAndFallbackFontsMap::iterator it = textBoxDataMap.find(toInlineTextBox(box));
839         usedFonts = it == textBoxDataMap.end() ? 0 : &it->value.first;
840         glyphOverflow = it == textBoxDataMap.end() ? 0 : &it->value.second;
841     }
842         
843     bool includeLeading = includeLeadingForBox(box);
844     bool includeFont = includeFontForBox(box);
845     
846     bool setUsedFont = false;
847     bool setUsedFontWithLeading = false;
848
849     const RenderStyle& boxLineStyle = box->lineStyle();
850     if (usedFonts && !usedFonts->isEmpty() && (includeFont || (boxLineStyle.lineHeight().isNegative() && includeLeading))) {
851         usedFonts->append(boxLineStyle.font().primaryFont());
852         for (size_t i = 0; i < usedFonts->size(); ++i) {
853             const FontMetrics& fontMetrics = usedFonts->at(i)->fontMetrics();
854             int usedFontAscent = fontMetrics.ascent(baselineType());
855             int usedFontDescent = fontMetrics.descent(baselineType());
856             int halfLeading = (fontMetrics.lineSpacing() - fontMetrics.height()) / 2;
857             int usedFontAscentAndLeading = usedFontAscent + halfLeading;
858             int usedFontDescentAndLeading = fontMetrics.lineSpacing() - usedFontAscentAndLeading;
859             if (includeFont) {
860                 setAscentAndDescent(ascent, descent, usedFontAscent, usedFontDescent, ascentDescentSet);
861                 setUsedFont = true;
862             }
863             if (includeLeading) {
864                 setAscentAndDescent(ascent, descent, usedFontAscentAndLeading, usedFontDescentAndLeading, ascentDescentSet);
865                 setUsedFontWithLeading = true;
866             }
867             if (!affectsAscent)
868                 affectsAscent = usedFontAscent - box->logicalTop() > 0;
869             if (!affectsDescent)
870                 affectsDescent = usedFontDescent + box->logicalTop() > 0;
871         }
872     }
873
874     // If leading is included for the box, then we compute that box.
875     if (includeLeading && !setUsedFontWithLeading) {
876         int ascentWithLeading = box->baselinePosition(baselineType());
877         int descentWithLeading = box->lineHeight() - ascentWithLeading;
878         setAscentAndDescent(ascent, descent, ascentWithLeading, descentWithLeading, ascentDescentSet);
879         
880         // Examine the font box for inline flows and text boxes to see if any part of it is above the baseline.
881         // If the top of our font box relative to the root box baseline is above the root box baseline, then
882         // we are contributing to the maxAscent value. Descent is similar. If any part of our font box is below
883         // the root box's baseline, then we contribute to the maxDescent value.
884         affectsAscent = ascentWithLeading - box->logicalTop() > 0;
885         affectsDescent = descentWithLeading + box->logicalTop() > 0; 
886     }
887     
888     if (includeFontForBox(box) && !setUsedFont) {
889         int fontAscent = boxLineStyle.fontMetrics().ascent(baselineType());
890         int fontDescent = boxLineStyle.fontMetrics().descent(baselineType());
891         setAscentAndDescent(ascent, descent, fontAscent, fontDescent, ascentDescentSet);
892         affectsAscent = fontAscent - box->logicalTop() > 0;
893         affectsDescent = fontDescent + box->logicalTop() > 0; 
894     }
895
896     if (includeGlyphsForBox(box) && glyphOverflow && glyphOverflow->computeBounds) {
897         setAscentAndDescent(ascent, descent, glyphOverflow->top, glyphOverflow->bottom, ascentDescentSet);
898         affectsAscent = glyphOverflow->top - box->logicalTop() > 0;
899         affectsDescent = glyphOverflow->bottom + box->logicalTop() > 0; 
900         glyphOverflow->top = std::min(glyphOverflow->top, std::max(0, glyphOverflow->top - boxLineStyle.fontMetrics().ascent(baselineType())));
901         glyphOverflow->bottom = std::min(glyphOverflow->bottom, std::max(0, glyphOverflow->bottom - boxLineStyle.fontMetrics().descent(baselineType())));
902     }
903
904     if (includeMarginForBox(box)) {
905         LayoutUnit ascentWithMargin = boxLineStyle.fontMetrics().ascent(baselineType());
906         LayoutUnit descentWithMargin = boxLineStyle.fontMetrics().descent(baselineType());
907         if (box->parent() && !box->renderer().isTextOrLineBreak()) {
908             ascentWithMargin += box->boxModelObject()->borderAndPaddingBefore() + box->boxModelObject()->marginBefore();
909             descentWithMargin += box->boxModelObject()->borderAndPaddingAfter() + box->boxModelObject()->marginAfter();
910         }
911         setAscentAndDescent(ascent, descent, ascentWithMargin, descentWithMargin, ascentDescentSet);
912         
913         // Treat like a replaced element, since we're using the margin box.
914         affectsAscent = true;
915         affectsDescent = true;
916     }
917 }
918
919 LayoutUnit RootInlineBox::verticalPositionForBox(InlineBox* box, VerticalPositionCache& verticalPositionCache)
920 {
921     if (box->renderer().isTextOrLineBreak())
922         return box->parent()->logicalTop();
923     
924     RenderBoxModelObject* renderer = box->boxModelObject();
925     ASSERT(renderer->isInline());
926     if (!renderer->isInline())
927         return 0;
928
929     // This method determines the vertical position for inline elements.
930     bool firstLine = isFirstLine();
931     if (firstLine && !renderer->document().styleSheetCollection().usesFirstLineRules())
932         firstLine = false;
933
934     // Check the cache.
935     bool isRenderInline = renderer->isRenderInline();
936     if (isRenderInline && !firstLine) {
937         LayoutUnit verticalPosition = verticalPositionCache.get(renderer, baselineType());
938         if (verticalPosition != PositionUndefined)
939             return verticalPosition;
940     }
941
942     LayoutUnit verticalPosition = 0;
943     EVerticalAlign verticalAlign = renderer->style().verticalAlign();
944     if (verticalAlign == TOP || verticalAlign == BOTTOM)
945         return 0;
946    
947     RenderElement* parent = renderer->parent();
948     if (parent->isRenderInline() && parent->style().verticalAlign() != TOP && parent->style().verticalAlign() != BOTTOM)
949         verticalPosition = box->parent()->logicalTop();
950     
951     if (verticalAlign != BASELINE) {
952         const RenderStyle& parentLineStyle = firstLine ? parent->firstLineStyle() : parent->style();
953         const Font& font = parentLineStyle.font();
954         const FontMetrics& fontMetrics = font.fontMetrics();
955         int fontSize = font.pixelSize();
956
957         LineDirectionMode lineDirection = parent->isHorizontalWritingMode() ? HorizontalLine : VerticalLine;
958
959         if (verticalAlign == SUB)
960             verticalPosition += fontSize / 5 + 1;
961         else if (verticalAlign == SUPER)
962             verticalPosition -= fontSize / 3 + 1;
963         else if (verticalAlign == TEXT_TOP)
964             verticalPosition += renderer->baselinePosition(baselineType(), firstLine, lineDirection) - fontMetrics.ascent(baselineType());
965         else if (verticalAlign == MIDDLE)
966             verticalPosition = (verticalPosition - static_cast<LayoutUnit>(fontMetrics.xHeight() / 2) - renderer->lineHeight(firstLine, lineDirection) / 2 + renderer->baselinePosition(baselineType(), firstLine, lineDirection)).round();
967         else if (verticalAlign == TEXT_BOTTOM) {
968             verticalPosition += fontMetrics.descent(baselineType());
969             // lineHeight - baselinePosition is always 0 for replaced elements (except inline blocks), so don't bother wasting time in that case.
970             if (!renderer->isReplaced() || renderer->isInlineBlockOrInlineTable())
971                 verticalPosition -= (renderer->lineHeight(firstLine, lineDirection) - renderer->baselinePosition(baselineType(), firstLine, lineDirection));
972         } else if (verticalAlign == BASELINE_MIDDLE)
973             verticalPosition += -renderer->lineHeight(firstLine, lineDirection) / 2 + renderer->baselinePosition(baselineType(), firstLine, lineDirection);
974         else if (verticalAlign == LENGTH) {
975             LayoutUnit lineHeight;
976             //Per http://www.w3.org/TR/CSS21/visudet.html#propdef-vertical-align: 'Percentages: refer to the 'line-height' of the element itself'.
977             if (renderer->style().verticalAlignLength().isPercent())
978                 lineHeight = renderer->style().computedLineHeight();
979             else
980                 lineHeight = renderer->lineHeight(firstLine, lineDirection);
981             verticalPosition -= valueForLength(renderer->style().verticalAlignLength(), lineHeight, &renderer->view());
982         }
983     }
984
985     // Store the cached value.
986     if (isRenderInline && !firstLine)
987         verticalPositionCache.set(renderer, baselineType(), verticalPosition);
988
989     return verticalPosition;
990 }
991
992 bool RootInlineBox::includeLeadingForBox(InlineBox* box) const
993 {
994     if (box->renderer().isReplaced() || (box->renderer().isTextOrLineBreak() && !box->behavesLikeText()))
995         return false;
996
997     LineBoxContain lineBoxContain = renderer().style().lineBoxContain();
998     return (lineBoxContain & LineBoxContainInline) || (box == this && (lineBoxContain & LineBoxContainBlock));
999 }
1000
1001 bool RootInlineBox::includeFontForBox(InlineBox* box) const
1002 {
1003     if (box->renderer().isReplaced() || (box->renderer().isTextOrLineBreak() && !box->behavesLikeText()))
1004         return false;
1005     
1006     if (!box->behavesLikeText() && box->isInlineFlowBox() && !toInlineFlowBox(box)->hasTextChildren())
1007         return false;
1008
1009     // For now map "glyphs" to "font" in vertical text mode until the bounds returned by glyphs aren't garbage.
1010     LineBoxContain lineBoxContain = renderer().style().lineBoxContain();
1011     return (lineBoxContain & LineBoxContainFont) || (!isHorizontal() && (lineBoxContain & LineBoxContainGlyphs));
1012 }
1013
1014 bool RootInlineBox::includeGlyphsForBox(InlineBox* box) const
1015 {
1016     if (box->renderer().isReplaced() || (box->renderer().isTextOrLineBreak() && !box->behavesLikeText()))
1017         return false;
1018     
1019     if (!box->behavesLikeText() && box->isInlineFlowBox() && !toInlineFlowBox(box)->hasTextChildren())
1020         return false;
1021
1022     // FIXME: We can't fit to glyphs yet for vertical text, since the bounds returned are garbage.
1023     LineBoxContain lineBoxContain = renderer().style().lineBoxContain();
1024     return isHorizontal() && (lineBoxContain & LineBoxContainGlyphs);
1025 }
1026
1027 bool RootInlineBox::includeMarginForBox(InlineBox* box) const
1028 {
1029     if (box->renderer().isReplaced() || (box->renderer().isTextOrLineBreak() && !box->behavesLikeText()))
1030         return false;
1031
1032     LineBoxContain lineBoxContain = renderer().style().lineBoxContain();
1033     return lineBoxContain & LineBoxContainInlineBox;
1034 }
1035
1036
1037 bool RootInlineBox::fitsToGlyphs() const
1038 {
1039     // FIXME: We can't fit to glyphs yet for vertical text, since the bounds returned are garbage.
1040     LineBoxContain lineBoxContain = renderer().style().lineBoxContain();
1041     return isHorizontal() && (lineBoxContain & LineBoxContainGlyphs);
1042 }
1043
1044 bool RootInlineBox::includesRootLineBoxFontOrLeading() const
1045 {
1046     LineBoxContain lineBoxContain = renderer().style().lineBoxContain();
1047     return (lineBoxContain & LineBoxContainBlock) || (lineBoxContain & LineBoxContainInline) || (lineBoxContain & LineBoxContainFont);
1048 }
1049
1050 Node* RootInlineBox::getLogicalStartBoxWithNode(InlineBox*& startBox) const
1051 {
1052     Vector<InlineBox*> leafBoxesInLogicalOrder;
1053     collectLeafBoxesInLogicalOrder(leafBoxesInLogicalOrder);
1054     for (size_t i = 0; i < leafBoxesInLogicalOrder.size(); ++i) {
1055         if (leafBoxesInLogicalOrder[i]->renderer().node()) {
1056             startBox = leafBoxesInLogicalOrder[i];
1057             return startBox->renderer().node();
1058         }
1059     }
1060     startBox = 0;
1061     return 0;
1062 }
1063     
1064 Node* RootInlineBox::getLogicalEndBoxWithNode(InlineBox*& endBox) const
1065 {
1066     Vector<InlineBox*> leafBoxesInLogicalOrder;
1067     collectLeafBoxesInLogicalOrder(leafBoxesInLogicalOrder);
1068     for (size_t i = leafBoxesInLogicalOrder.size(); i > 0; --i) { 
1069         if (leafBoxesInLogicalOrder[i - 1]->renderer().node()) {
1070             endBox = leafBoxesInLogicalOrder[i - 1];
1071             return endBox->renderer().node();
1072         }
1073     }
1074     endBox = 0;
1075     return 0;
1076 }
1077
1078 #ifndef NDEBUG
1079 const char* RootInlineBox::boxName() const
1080 {
1081     return "RootInlineBox";
1082 }
1083 #endif
1084
1085 } // namespace WebCore