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