src/third_party/WebKit/Source/core/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 "core/rendering/RootInlineBox.h"
  22
  23 #include "core/dom/Document.h"
  24 #include "core/dom/StyleEngine.h"
  25 #include "core/rendering/EllipsisBox.h"
  26 #include "core/rendering/HitTestResult.h"
  27 #include "core/rendering/InlineTextBox.h"
  28 #include "core/rendering/PaintInfo.h"
  29 #include "core/rendering/RenderBlockFlow.h"
  30 #include "core/rendering/RenderFlowThread.h"
  31 #include "core/rendering/RenderInline.h"
  32 #include "core/rendering/RenderView.h"
  33 #include "core/rendering/VerticalPositionCache.h"
  34 #include "platform/text/BidiResolver.h"
  35 #include "wtf/unicode/Unicode.h"
  36
  37 namespace blink {
  38
  39 struct SameSizeAsRootInlineBox : public InlineFlowBox {
  40     unsigned unsignedVariable;
  41     void* pointers[4];
  42     LayoutUnit layoutVariables[5];
  43 };
  44
  45 COMPILE_ASSERT(sizeof(RootInlineBox) == sizeof(SameSizeAsRootInlineBox), RootInlineBox_should_stay_small);
  46
  47 typedef WTF::HashMap<const RootInlineBox*, EllipsisBox*> EllipsisBoxMap;
  48 static EllipsisBoxMap* gEllipsisBoxMap = 0;
  49
  50 RootInlineBox::RootInlineBox(RenderBlockFlow& block)
  51     : InlineFlowBox(block)
  52     , m_lineBreakPos(0)
  53     , m_lineBreakObj(0)
  54     , m_lineTop(0)
  55     , m_lineBottom(0)
  56     , m_lineTopWithLeading(0)
  57     , m_lineBottomWithLeading(0)
  58     , m_selectionBottom(0)
  59 {
  60     setIsHorizontal(block.isHorizontalWritingMode());
  61 }
  62
  63
  64 void RootInlineBox::destroy()
  65 {
  66     detachEllipsisBox();
  67     InlineFlowBox::destroy();
  68 }
  69
  70 void RootInlineBox::detachEllipsisBox()
  71 {
  72     if (hasEllipsisBox()) {
  73         EllipsisBox* box = gEllipsisBoxMap->take(this);
  74         box->setParent(0);
  75         box->destroy();
  76         setHasEllipsisBox(false);
  77     }
  78 }
  79
  80 RenderLineBoxList* RootInlineBox::rendererLineBoxes() const
  81 {
  82     return block().lineBoxes();
  83 }
  84
  85 void RootInlineBox::clearTruncation()
  86 {
  87     if (hasEllipsisBox()) {
  88         detachEllipsisBox();
  89         InlineFlowBox::clearTruncation();
  90     }
  91 }
  92
  93 int RootInlineBox::baselinePosition(FontBaseline baselineType) const
  94 {
  95     return boxModelObject()->baselinePosition(baselineType, isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOfInteriorLineBoxes);
  96 }
  97
  98 LayoutUnit RootInlineBox::lineHeight() const
  99 {
 100     return boxModelObject()->lineHeight(isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOfInteriorLineBoxes);
 101 }
 102
 103 bool RootInlineBox::lineCanAccommodateEllipsis(bool ltr, int blockEdge, int lineBoxEdge, int ellipsisWidth)
 104 {
 105     // First sanity-check the unoverflowed width of the whole line to see if there is sufficient room.
 106     int delta = ltr ? lineBoxEdge - blockEdge : blockEdge - lineBoxEdge;
 107     if (logicalWidth() - delta < ellipsisWidth)
 108         return false;
 109
 110     // Next iterate over all the line boxes on the line.  If we find a replaced element that intersects
 111     // then we refuse to accommodate the ellipsis.  Otherwise we're ok.
 112     return InlineFlowBox::canAccommodateEllipsis(ltr, blockEdge, ellipsisWidth);
 113 }
 114
 115 float RootInlineBox::placeEllipsis(const AtomicString& ellipsisStr,  bool ltr, float blockLeftEdge, float blockRightEdge, float ellipsisWidth,
 116                                   InlineBox* markupBox)
 117 {
 118     // Create an ellipsis box.
 119     EllipsisBox* ellipsisBox = new EllipsisBox(renderer(), ellipsisStr, this,
 120         ellipsisWidth - (markupBox ? markupBox->logicalWidth() : 0), logicalHeight(),
 121         x(), y(), !prevRootBox(), isHorizontal(), markupBox);
 122
 123     if (!gEllipsisBoxMap)
 124         gEllipsisBoxMap = new EllipsisBoxMap();
 125     gEllipsisBoxMap->add(this, ellipsisBox);
 126     setHasEllipsisBox(true);
 127
 128     // FIXME: Do we need an RTL version of this?
 129     if (ltr && (logicalLeft() + logicalWidth() + ellipsisWidth) <= blockRightEdge) {
 130         ellipsisBox->setLogicalLeft(logicalLeft() + logicalWidth());
 131         return logicalWidth() + ellipsisWidth;
 132     }
 133
 134     // Now attempt to find the nearest glyph horizontally and place just to the right (or left in RTL)
 135     // of that glyph.  Mark all of the objects that intersect the ellipsis box as not painting (as being
 136     // truncated).
 137     bool foundBox = false;
 138     float truncatedWidth = 0;
 139     float position = placeEllipsisBox(ltr, blockLeftEdge, blockRightEdge, ellipsisWidth, truncatedWidth, foundBox);
 140     ellipsisBox->setLogicalLeft(position);
 141     return truncatedWidth;
 142 }
 143
 144 float RootInlineBox::placeEllipsisBox(bool ltr, float blockLeftEdge, float blockRightEdge, float ellipsisWidth, float &truncatedWidth, bool& foundBox)
 145 {
 146     float result = InlineFlowBox::placeEllipsisBox(ltr, blockLeftEdge, blockRightEdge, ellipsisWidth, truncatedWidth, foundBox);
 147     if (result == -1) {
 148         result = ltr ? blockRightEdge - ellipsisWidth : blockLeftEdge;
 149         truncatedWidth = blockRightEdge - blockLeftEdge;
 150     }
 151     return result;
 152 }
 153
 154 void RootInlineBox::paintEllipsisBox(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom) const
 155 {
 156     if (hasEllipsisBox() && paintInfo.shouldPaintWithinRoot(&renderer()) && renderer().style()->visibility() == VISIBLE
 157             && paintInfo.phase == PaintPhaseForeground)
 158         ellipsisBox()->paint(paintInfo, paintOffset, lineTop, lineBottom);
 159 }
 160
 161 void RootInlineBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
 162 {
 163     InlineFlowBox::paint(paintInfo, paintOffset, lineTop, lineBottom);
 164     paintEllipsisBox(paintInfo, paintOffset, lineTop, lineBottom);
 165 }
 166
 167 bool RootInlineBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
 168 {
 169     if (hasEllipsisBox() && visibleToHitTestRequest(request)) {
 170         if (ellipsisBox()->nodeAtPoint(request, result, locationInContainer, accumulatedOffset, lineTop, lineBottom)) {
 171             renderer().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));
 172             return true;
 173         }
 174     }
 175     return InlineFlowBox::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, lineTop, lineBottom);
 176 }
 177
 178 void RootInlineBox::adjustPosition(float dx, float dy)
 179 {
 180     InlineFlowBox::adjustPosition(dx, dy);
 181     LayoutUnit blockDirectionDelta = isHorizontal() ? dy : dx; // The block direction delta is a LayoutUnit.
 182     m_lineTop += blockDirectionDelta;
 183     m_lineBottom += blockDirectionDelta;
 184     m_lineTopWithLeading += blockDirectionDelta;
 185     m_lineBottomWithLeading += blockDirectionDelta;
 186     m_selectionBottom += blockDirectionDelta;
 187     if (hasEllipsisBox())
 188         ellipsisBox()->adjustPosition(dx, dy);
 189 }
 190
 191 void RootInlineBox::childRemoved(InlineBox* box)
 192 {
 193     if (&box->renderer() == m_lineBreakObj)
 194         setLineBreakInfo(0, 0, BidiStatus());
 195
 196     for (RootInlineBox* prev = prevRootBox(); prev && prev->lineBreakObj() == &box->renderer(); prev = prev->prevRootBox()) {
 197         prev->setLineBreakInfo(0, 0, BidiStatus());
 198         prev->markDirty();
 199     }
 200 }
 201
 202 LayoutUnit RootInlineBox::alignBoxesInBlockDirection(LayoutUnit heightOfBlock, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache& verticalPositionCache)
 203 {
 204     // SVG will handle vertical alignment on its own.
 205     if (isSVGRootInlineBox())
 206         return 0;
 207
 208     LayoutUnit maxPositionTop = 0;
 209     LayoutUnit maxPositionBottom = 0;
 210     int maxAscent = 0;
 211     int maxDescent = 0;
 212     bool setMaxAscent = false;
 213     bool setMaxDescent = false;
 214
 215     // Figure out if we're in no-quirks mode.
 216     bool noQuirksMode = renderer().document().inNoQuirksMode();
 217
 218     m_baselineType = requiresIdeographicBaseline(textBoxDataMap) ? IdeographicBaseline : AlphabeticBaseline;
 219
 220     computeLogicalBoxHeights(this, maxPositionTop, maxPositionBottom, maxAscent, maxDescent, setMaxAscent, setMaxDescent, noQuirksMode,
 221                              textBoxDataMap, baselineType(), verticalPositionCache);
 222
 223     if (maxAscent + maxDescent < std::max(maxPositionTop, maxPositionBottom))
 224         adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);
 225
 226     LayoutUnit maxHeight = maxAscent + maxDescent;
 227     LayoutUnit lineTop = heightOfBlock;
 228     LayoutUnit lineBottom = heightOfBlock;
 229     LayoutUnit lineTopIncludingMargins = heightOfBlock;
 230     LayoutUnit lineBottomIncludingMargins = heightOfBlock;
 231     LayoutUnit selectionBottom = heightOfBlock;
 232     bool setLineTop = false;
 233     bool hasAnnotationsBefore = false;
 234     bool hasAnnotationsAfter = false;
 235     placeBoxesInBlockDirection(heightOfBlock, maxHeight, maxAscent, noQuirksMode, lineTop, lineBottom, selectionBottom, setLineTop,
 236                                lineTopIncludingMargins, lineBottomIncludingMargins, hasAnnotationsBefore, hasAnnotationsAfter, baselineType());
 237     m_hasAnnotationsBefore = hasAnnotationsBefore;
 238     m_hasAnnotationsAfter = hasAnnotationsAfter;
 239
 240     maxHeight = std::max<LayoutUnit>(0, maxHeight); // FIXME: Is this really necessary?
 241
 242     setLineTopBottomPositions(lineTop, lineBottom, heightOfBlock, heightOfBlock + maxHeight, selectionBottom);
 243     if (block().view()->layoutState()->isPaginated())
 244         setPaginatedLineWidth(block().availableLogicalWidthForContent());
 245
 246     LayoutUnit annotationsAdjustment = beforeAnnotationsAdjustment();
 247     if (annotationsAdjustment) {
 248         // FIXME: Need to handle pagination here. We might have to move to the next page/column as a result of the
 249         // ruby expansion.
 250         adjustBlockDirectionPosition(annotationsAdjustment.toFloat());
 251         heightOfBlock += annotationsAdjustment;
 252     }
 253
 254     return heightOfBlock + maxHeight;
 255 }
 256
 257 float RootInlineBox::maxLogicalTop() const
 258 {
 259     float maxLogicalTop = 0;
 260     computeMaxLogicalTop(maxLogicalTop);
 261     return maxLogicalTop;
 262 }
 263
 264 LayoutUnit RootInlineBox::beforeAnnotationsAdjustment() const
 265 {
 266     LayoutUnit result = 0;
 267
 268     if (!renderer().style()->isFlippedLinesWritingMode()) {
 269         // Annotations under the previous line may push us down.
 270         if (prevRootBox() && prevRootBox()->hasAnnotationsAfter())
 271             result = prevRootBox()->computeUnderAnnotationAdjustment(lineTop());
 272
 273         if (!hasAnnotationsBefore())
 274             return result;
 275
 276         // Annotations over this line may push us further down.
 277         LayoutUnit highestAllowedPosition = prevRootBox() ? std::min(prevRootBox()->lineBottom(), lineTop()) + result : static_cast<LayoutUnit>(block().borderBefore());
 278         result = computeOverAnnotationAdjustment(highestAllowedPosition);
 279     } else {
 280         // Annotations under this line may push us up.
 281         if (hasAnnotationsBefore())
 282             result = computeUnderAnnotationAdjustment(prevRootBox() ? prevRootBox()->lineBottom() : static_cast<LayoutUnit>(block().borderBefore()));
 283
 284         if (!prevRootBox() || !prevRootBox()->hasAnnotationsAfter())
 285             return result;
 286
 287         // We have to compute the expansion for annotations over the previous line to see how much we should move.
 288         LayoutUnit lowestAllowedPosition = std::max(prevRootBox()->lineBottom(), lineTop()) - result;
 289         result = prevRootBox()->computeOverAnnotationAdjustment(lowestAllowedPosition);
 290     }
 291
 292     return result;
 293 }
 294
 295 GapRects RootInlineBox::lineSelectionGap(const RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
 296                                          LayoutUnit selTop, LayoutUnit selHeight, const PaintInfo* paintInfo) const
 297 {
 298     RenderObject::SelectionState lineState = selectionState();
 299
 300     bool leftGap, rightGap;
 301     block().getSelectionGapInfo(lineState, leftGap, rightGap);
 302
 303     GapRects result;
 304
 305     InlineBox* firstBox = firstSelectedBox();
 306     InlineBox* lastBox = lastSelectedBox();
 307     if (leftGap) {
 308         result.uniteLeft(block().logicalLeftSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock,
 309             &firstBox->parent()->renderer(), firstBox->logicalLeft(), selTop, selHeight, paintInfo));
 310     }
 311     if (rightGap) {
 312         result.uniteRight(block().logicalRightSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock,
 313             &lastBox->parent()->renderer(), lastBox->logicalRight(), selTop, selHeight, paintInfo));
 314     }
 315
 316     // When dealing with bidi text, a non-contiguous selection region is possible.
 317     // e.g. The logical text aaaAAAbbb (capitals denote RTL text and non-capitals LTR) is layed out
 318     // visually as 3 text runs |aaa|bbb|AAA| if we select 4 characters from the start of the text the
 319     // selection will look like (underline denotes selection):
 320     // |aaa|bbb|AAA|
 321     //  ___       _
 322     // We can see that the |bbb| run is not part of the selection while the runs around it are.
 323     if (firstBox && firstBox != lastBox) {
 324         // Now fill in any gaps on the line that occurred between two selected elements.
 325         LayoutUnit lastLogicalLeft = firstBox->logicalRight();
 326         bool isPreviousBoxSelected = firstBox->selectionState() != RenderObject::SelectionNone;
 327         for (InlineBox* box = firstBox->nextLeafChild(); box; box = box->nextLeafChild()) {
 328             if (box->selectionState() != RenderObject::SelectionNone) {
 329                 LayoutRect logicalRect(lastLogicalLeft, selTop, box->logicalLeft() - lastLogicalLeft, selHeight);
 330                 logicalRect.move(renderer().isHorizontalWritingMode() ? offsetFromRootBlock : LayoutSize(offsetFromRootBlock.height(), offsetFromRootBlock.width()));
 331                 LayoutRect gapRect = rootBlock->logicalRectToPhysicalRect(rootBlockPhysicalPosition, logicalRect);
 332                 if (isPreviousBoxSelected && gapRect.width() > 0 && gapRect.height() > 0) {
 333                     if (paintInfo && box->parent()->renderer().style()->visibility() == VISIBLE)
 334                         paintInfo->context->fillRect(gapRect, box->parent()->renderer().selectionBackgroundColor());
 335                     // VisibleSelection may be non-contiguous, see comment above.
 336                     result.uniteCenter(gapRect);
 337                 }
 338                 lastLogicalLeft = box->logicalRight();
 339             }
 340             if (box == lastBox)
 341                 break;
 342             isPreviousBoxSelected = box->selectionState() != RenderObject::SelectionNone;
 343         }
 344     }
 345
 346     return result;
 347 }
 348
 349 RenderObject::SelectionState RootInlineBox::selectionState() const
 350 {
 351     // Walk over all of the selected boxes.
 352     RenderObject::SelectionState state = RenderObject::SelectionNone;
 353     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
 354         RenderObject::SelectionState boxState = box->selectionState();
 355         if ((boxState == RenderObject::SelectionStart && state == RenderObject::SelectionEnd) ||
 356             (boxState == RenderObject::SelectionEnd && state == RenderObject::SelectionStart))
 357             state = RenderObject::SelectionBoth;
 358         else if (state == RenderObject::SelectionNone ||
 359                  ((boxState == RenderObject::SelectionStart || boxState == RenderObject::SelectionEnd) &&
 360                   (state == RenderObject::SelectionNone || state == RenderObject::SelectionInside)))
 361             state = boxState;
 362         else if (boxState == RenderObject::SelectionNone && state == RenderObject::SelectionStart) {
 363             // We are past the end of the selection.
 364             state = RenderObject::SelectionBoth;
 365         }
 366         if (state == RenderObject::SelectionBoth)
 367             break;
 368     }
 369
 370     return state;
 371 }
 372
 373 InlineBox* RootInlineBox::firstSelectedBox() const
 374 {
 375     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
 376         if (box->selectionState() != RenderObject::SelectionNone)
 377             return box;
 378     }
 379
 380     return 0;
 381 }
 382
 383 InlineBox* RootInlineBox::lastSelectedBox() const
 384 {
 385     for (InlineBox* box = lastLeafChild(); box; box = box->prevLeafChild()) {
 386         if (box->selectionState() != RenderObject::SelectionNone)
 387             return box;
 388     }
 389
 390     return 0;
 391 }
 392
 393 LayoutUnit RootInlineBox::selectionTop() const
 394 {
 395     LayoutUnit selectionTop = m_lineTop;
 396
 397     if (m_hasAnnotationsBefore)
 398         selectionTop -= !renderer().style()->isFlippedLinesWritingMode() ? computeOverAnnotationAdjustment(m_lineTop) : computeUnderAnnotationAdjustment(m_lineTop);
 399
 400     if (renderer().style()->isFlippedLinesWritingMode() || !prevRootBox())
 401         return selectionTop;
 402
 403     LayoutUnit prevBottom = prevRootBox()->selectionBottom();
 404     if (prevBottom < selectionTop && block().containsFloats()) {
 405         // This line has actually been moved further down, probably from a large line-height, but possibly because the
 406         // line was forced to clear floats.  If so, let's check the offsets, and only be willing to use the previous
 407         // line's bottom if the offsets are greater on both sides.
 408         LayoutUnit prevLeft = block().logicalLeftOffsetForLine(prevBottom, false);
 409         LayoutUnit prevRight = block().logicalRightOffsetForLine(prevBottom, false);
 410         LayoutUnit newLeft = block().logicalLeftOffsetForLine(selectionTop, false);
 411         LayoutUnit newRight = block().logicalRightOffsetForLine(selectionTop, false);
 412         if (prevLeft > newLeft || prevRight < newRight)
 413             return selectionTop;
 414     }
 415
 416     return prevBottom;
 417 }
 418
 419 LayoutUnit RootInlineBox::selectionTopAdjustedForPrecedingBlock() const
 420 {
 421     LayoutUnit top = selectionTop();
 422
 423     RenderObject::SelectionState blockSelectionState = root().block().selectionState();
 424     if (blockSelectionState != RenderObject::SelectionInside && blockSelectionState != RenderObject::SelectionEnd)
 425         return top;
 426
 427     LayoutSize offsetToBlockBefore;
 428     if (RenderBlock* block = root().block().blockBeforeWithinSelectionRoot(offsetToBlockBefore)) {
 429         if (block->isRenderBlockFlow()) {
 430             if (RootInlineBox* lastLine = toRenderBlockFlow(block)->lastRootBox()) {
 431                 RenderObject::SelectionState lastLineSelectionState = lastLine->selectionState();
 432                 if (lastLineSelectionState != RenderObject::SelectionInside && lastLineSelectionState != RenderObject::SelectionStart)
 433                     return top;
 434
 435                 LayoutUnit lastLineSelectionBottom = lastLine->selectionBottom() + offsetToBlockBefore.height();
 436                 top = std::max(top, lastLineSelectionBottom);
 437             }
 438         }
 439     }
 440
 441     return top;
 442 }
 443
 444 LayoutUnit RootInlineBox::selectionBottom() const
 445 {
 446     LayoutUnit selectionBottom = m_selectionBottom;
 447
 448     if (m_hasAnnotationsAfter)
 449         selectionBottom += !renderer().style()->isFlippedLinesWritingMode() ? computeUnderAnnotationAdjustment(m_lineBottom) : computeOverAnnotationAdjustment(m_lineBottom);
 450
 451     if (!renderer().style()->isFlippedLinesWritingMode() || !nextRootBox())
 452         return selectionBottom;
 453
 454     LayoutUnit nextTop = nextRootBox()->selectionTop();
 455     if (nextTop > selectionBottom && block().containsFloats()) {
 456         // The next line has actually been moved further over, probably from a large line-height, but possibly because the
 457         // line was forced to clear floats.  If so, let's check the offsets, and only be willing to use the next
 458         // line's top if the offsets are greater on both sides.
 459         LayoutUnit nextLeft = block().logicalLeftOffsetForLine(nextTop, false);
 460         LayoutUnit nextRight = block().logicalRightOffsetForLine(nextTop, false);
 461         LayoutUnit newLeft = block().logicalLeftOffsetForLine(selectionBottom, false);
 462         LayoutUnit newRight = block().logicalRightOffsetForLine(selectionBottom, false);
 463         if (nextLeft > newLeft || nextRight < newRight)
 464             return selectionBottom;
 465     }
 466
 467     return nextTop;
 468 }
 469
 470 int RootInlineBox::blockDirectionPointInLine() const
 471 {
 472     return !block().style()->isFlippedBlocksWritingMode() ? std::max(lineTop(), selectionTop()) : std::min(lineBottom(), selectionBottom());
 473 }
 474
 475 RenderBlockFlow& RootInlineBox::block() const
 476 {
 477     return toRenderBlockFlow(renderer());
 478 }
 479
 480 static bool isEditableLeaf(InlineBox* leaf)
 481 {
 482     return leaf && leaf->renderer().node() && leaf->renderer().node()->hasEditableStyle();
 483 }
 484
 485 InlineBox* RootInlineBox::closestLeafChildForPoint(const IntPoint& pointInContents, bool onlyEditableLeaves)
 486 {
 487     return closestLeafChildForLogicalLeftPosition(block().isHorizontalWritingMode() ? pointInContents.x() : pointInContents.y(), onlyEditableLeaves);
 488 }
 489
 490 InlineBox* RootInlineBox::closestLeafChildForLogicalLeftPosition(int leftPosition, bool onlyEditableLeaves)
 491 {
 492     InlineBox* firstLeaf = firstLeafChild();
 493     InlineBox* lastLeaf = lastLeafChild();
 494
 495     if (firstLeaf != lastLeaf) {
 496         if (firstLeaf->isLineBreak())
 497             firstLeaf = firstLeaf->nextLeafChildIgnoringLineBreak();
 498         else if (lastLeaf->isLineBreak())
 499             lastLeaf = lastLeaf->prevLeafChildIgnoringLineBreak();
 500     }
 501
 502     if (firstLeaf == lastLeaf && (!onlyEditableLeaves || isEditableLeaf(firstLeaf)))
 503         return firstLeaf;
 504
 505     // Avoid returning a list marker when possible.
 506     if (leftPosition <= firstLeaf->logicalLeft() && !firstLeaf->renderer().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(firstLeaf)))
 507         // The leftPosition coordinate is less or equal to left edge of the firstLeaf.
 508         // Return it.
 509         return firstLeaf;
 510
 511     if (leftPosition >= lastLeaf->logicalRight() && !lastLeaf->renderer().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(lastLeaf)))
 512         // The leftPosition coordinate is greater or equal to right edge of the lastLeaf.
 513         // Return it.
 514         return lastLeaf;
 515
 516     InlineBox* closestLeaf = 0;
 517     for (InlineBox* leaf = firstLeaf; leaf; leaf = leaf->nextLeafChildIgnoringLineBreak()) {
 518         if (!leaf->renderer().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(leaf))) {
 519             closestLeaf = leaf;
 520             if (leftPosition < leaf->logicalRight())
 521                 // The x coordinate is less than the right edge of the box.
 522                 // Return it.
 523                 return leaf;
 524         }
 525     }
 526
 527     return closestLeaf ? closestLeaf : lastLeaf;
 528 }
 529
 530 BidiStatus RootInlineBox::lineBreakBidiStatus() const
 531 {
 532     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);
 533 }
 534
 535 void RootInlineBox::setLineBreakInfo(RenderObject* obj, unsigned breakPos, const BidiStatus& status)
 536 {
 537     // When setting lineBreakObj, the RenderObject must not be a RenderInline
 538     // with no line boxes, otherwise all sorts of invariants are broken later.
 539     // This has security implications because if the RenderObject does not
 540     // point to at least one line box, then that RenderInline can be deleted
 541     // later without resetting the lineBreakObj, leading to use-after-free.
 542     ASSERT_WITH_SECURITY_IMPLICATION(!obj || obj->isText() || !(obj->isRenderInline() && obj->isBox() && !toRenderBox(obj)->inlineBoxWrapper()));
 543
 544     m_lineBreakObj = obj;
 545     m_lineBreakPos = breakPos;
 546     m_lineBreakBidiStatusEor = status.eor;
 547     m_lineBreakBidiStatusLastStrong = status.lastStrong;
 548     m_lineBreakBidiStatusLast = status.last;
 549     m_lineBreakContext = status.context;
 550 }
 551
 552 EllipsisBox* RootInlineBox::ellipsisBox() const
 553 {
 554     if (!hasEllipsisBox())
 555         return 0;
 556     return gEllipsisBoxMap->get(this);
 557 }
 558
 559 void RootInlineBox::removeLineBoxFromRenderObject()
 560 {
 561     block().lineBoxes()->removeLineBox(this);
 562 }
 563
 564 void RootInlineBox::extractLineBoxFromRenderObject()
 565 {
 566     block().lineBoxes()->extractLineBox(this);
 567 }
 568
 569 void RootInlineBox::attachLineBoxToRenderObject()
 570 {
 571     block().lineBoxes()->attachLineBox(this);
 572 }
 573
 574 LayoutRect RootInlineBox::paddedLayoutOverflowRect(LayoutUnit endPadding) const
 575 {
 576     LayoutRect lineLayoutOverflow = layoutOverflowRect(lineTop(), lineBottom());
 577     if (!endPadding)
 578         return lineLayoutOverflow;
 579
 580     if (isHorizontal()) {
 581         if (isLeftToRightDirection())
 582             lineLayoutOverflow.shiftMaxXEdgeTo(std::max<LayoutUnit>(lineLayoutOverflow.maxX(), logicalRight() + endPadding));
 583         else
 584             lineLayoutOverflow.shiftXEdgeTo(std::min<LayoutUnit>(lineLayoutOverflow.x(), logicalLeft() - endPadding));
 585     } else {
 586         if (isLeftToRightDirection())
 587             lineLayoutOverflow.shiftMaxYEdgeTo(std::max<LayoutUnit>(lineLayoutOverflow.maxY(), logicalRight() + endPadding));
 588         else
 589             lineLayoutOverflow.shiftYEdgeTo(std::min<LayoutUnit>(lineLayoutOverflow.y(), logicalLeft() - endPadding));
 590     }
 591
 592     return lineLayoutOverflow;
 593 }
 594
 595 static void setAscentAndDescent(int& ascent, int& descent, int newAscent, int newDescent, bool& ascentDescentSet)
 596 {
 597     if (!ascentDescentSet) {
 598         ascentDescentSet = true;
 599         ascent = newAscent;
 600         descent = newDescent;
 601     } else {
 602         ascent = std::max(ascent, newAscent);
 603         descent = std::max(descent, newDescent);
 604     }
 605 }
 606
 607 void RootInlineBox::ascentAndDescentForBox(InlineBox* box, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, int& ascent, int& descent,
 608                                            bool& affectsAscent, bool& affectsDescent) const
 609 {
 610     bool ascentDescentSet = false;
 611
 612     // Replaced boxes will return 0 for the line-height if line-box-contain says they are
 613     // not to be included.
 614     if (box->renderer().isReplaced()) {
 615         if (renderer().style(isFirstLineStyle())->lineBoxContain() & LineBoxContainReplaced) {
 616             ascent = box->baselinePosition(baselineType());
 617             descent = box->lineHeight() - ascent;
 618
 619             // Replaced elements always affect both the ascent and descent.
 620             affectsAscent = true;
 621             affectsDescent = true;
 622         }
 623         return;
 624     }
 625
 626     Vector<const SimpleFontData*>* usedFonts = 0;
 627     GlyphOverflow* glyphOverflow = 0;
 628     if (box->isText()) {
 629         GlyphOverflowAndFallbackFontsMap::iterator it = textBoxDataMap.find(toInlineTextBox(box));
 630         usedFonts = it == textBoxDataMap.end() ? 0 : &it->value.first;
 631         glyphOverflow = it == textBoxDataMap.end() ? 0 : &it->value.second;
 632     }
 633
 634     bool includeLeading = includeLeadingForBox(box);
 635     bool includeFont = includeFontForBox(box);
 636
 637     bool setUsedFont = false;
 638     bool setUsedFontWithLeading = false;
 639
 640     if (usedFonts && !usedFonts->isEmpty() && (includeFont || (box->renderer().style(isFirstLineStyle())->lineHeight().isNegative() && includeLeading))) {
 641         usedFonts->append(box->renderer().style(isFirstLineStyle())->font().primaryFont());
 642         for (size_t i = 0; i < usedFonts->size(); ++i) {
 643             const FontMetrics& fontMetrics = usedFonts->at(i)->fontMetrics();
 644             int usedFontAscent = fontMetrics.ascent(baselineType());
 645             int usedFontDescent = fontMetrics.descent(baselineType());
 646             int halfLeading = (fontMetrics.lineSpacing() - fontMetrics.height()) / 2;
 647             int usedFontAscentAndLeading = usedFontAscent + halfLeading;
 648             int usedFontDescentAndLeading = fontMetrics.lineSpacing() - usedFontAscentAndLeading;
 649             if (includeFont) {
 650                 setAscentAndDescent(ascent, descent, usedFontAscent, usedFontDescent, ascentDescentSet);
 651                 setUsedFont = true;
 652             }
 653             if (includeLeading) {
 654                 setAscentAndDescent(ascent, descent, usedFontAscentAndLeading, usedFontDescentAndLeading, ascentDescentSet);
 655                 setUsedFontWithLeading = true;
 656             }
 657             if (!affectsAscent)
 658                 affectsAscent = usedFontAscent - box->logicalTop() > 0;
 659             if (!affectsDescent)
 660                 affectsDescent = usedFontDescent + box->logicalTop() > 0;
 661         }
 662     }
 663
 664     // If leading is included for the box, then we compute that box.
 665     if (includeLeading && !setUsedFontWithLeading) {
 666         int ascentWithLeading = box->baselinePosition(baselineType());
 667         int descentWithLeading = box->lineHeight() - ascentWithLeading;
 668         setAscentAndDescent(ascent, descent, ascentWithLeading, descentWithLeading, ascentDescentSet);
 669
 670         // Examine the font box for inline flows and text boxes to see if any part of it is above the baseline.
 671         // If the top of our font box relative to the root box baseline is above the root box baseline, then
 672         // we are contributing to the maxAscent value. Descent is similar. If any part of our font box is below
 673         // the root box's baseline, then we contribute to the maxDescent value.
 674         affectsAscent = ascentWithLeading - box->logicalTop() > 0;
 675         affectsDescent = descentWithLeading + box->logicalTop() > 0;
 676     }
 677
 678     if (includeFontForBox(box) && !setUsedFont) {
 679         int fontAscent = box->renderer().style(isFirstLineStyle())->fontMetrics().ascent(baselineType());
 680         int fontDescent = box->renderer().style(isFirstLineStyle())->fontMetrics().descent(baselineType());
 681         setAscentAndDescent(ascent, descent, fontAscent, fontDescent, ascentDescentSet);
 682         affectsAscent = fontAscent - box->logicalTop() > 0;
 683         affectsDescent = fontDescent + box->logicalTop() > 0;
 684     }
 685
 686     if (includeGlyphsForBox(box) && glyphOverflow && glyphOverflow->computeBounds) {
 687         setAscentAndDescent(ascent, descent, glyphOverflow->top, glyphOverflow->bottom, ascentDescentSet);
 688         affectsAscent = glyphOverflow->top - box->logicalTop() > 0;
 689         affectsDescent = glyphOverflow->bottom + box->logicalTop() > 0;
 690         glyphOverflow->top = std::min(glyphOverflow->top, std::max(0, glyphOverflow->top - box->renderer().style(isFirstLineStyle())->fontMetrics().ascent(baselineType())));
 691         glyphOverflow->bottom = std::min(glyphOverflow->bottom, std::max(0, glyphOverflow->bottom - box->renderer().style(isFirstLineStyle())->fontMetrics().descent(baselineType())));
 692     }
 693
 694     if (includeMarginForBox(box)) {
 695         LayoutUnit ascentWithMargin = box->renderer().style(isFirstLineStyle())->fontMetrics().ascent(baselineType());
 696         LayoutUnit descentWithMargin = box->renderer().style(isFirstLineStyle())->fontMetrics().descent(baselineType());
 697         if (box->parent() && !box->renderer().isText()) {
 698             ascentWithMargin += box->boxModelObject()->borderBefore() + box->boxModelObject()->paddingBefore() + box->boxModelObject()->marginBefore();
 699             descentWithMargin += box->boxModelObject()->borderAfter() + box->boxModelObject()->paddingAfter() + box->boxModelObject()->marginAfter();
 700         }
 701         setAscentAndDescent(ascent, descent, ascentWithMargin, descentWithMargin, ascentDescentSet);
 702
 703         // Treat like a replaced element, since we're using the margin box.
 704         affectsAscent = true;
 705         affectsDescent = true;
 706     }
 707 }
 708
 709 LayoutUnit RootInlineBox::verticalPositionForBox(InlineBox* box, VerticalPositionCache& verticalPositionCache)
 710 {
 711     if (box->renderer().isText())
 712         return box->parent()->logicalTop();
 713
 714     RenderBoxModelObject* renderer = box->boxModelObject();
 715     ASSERT(renderer->isInline());
 716     if (!renderer->isInline())
 717         return 0;
 718
 719     // This method determines the vertical position for inline elements.
 720     bool firstLine = isFirstLineStyle();
 721     if (firstLine && !renderer->document().styleEngine()->usesFirstLineRules())
 722         firstLine = false;
 723
 724     // Check the cache.
 725     bool isRenderInline = renderer->isRenderInline();
 726     if (isRenderInline && !firstLine) {
 727         LayoutUnit verticalPosition = verticalPositionCache.get(renderer, baselineType());
 728         if (verticalPosition != PositionUndefined)
 729             return verticalPosition;
 730     }
 731
 732     LayoutUnit verticalPosition = 0;
 733     EVerticalAlign verticalAlign = renderer->style()->verticalAlign();
 734     if (verticalAlign == TOP || verticalAlign == BOTTOM)
 735         return 0;
 736
 737     RenderObject* parent = renderer->parent();
 738     if (parent->isRenderInline() && parent->style()->verticalAlign() != TOP && parent->style()->verticalAlign() != BOTTOM)
 739         verticalPosition = box->parent()->logicalTop();
 740
 741     if (verticalAlign != BASELINE) {
 742         const Font& font = parent->style(firstLine)->font();
 743         const FontMetrics& fontMetrics = font.fontMetrics();
 744         int fontSize = font.fontDescription().computedPixelSize();
 745
 746         LineDirectionMode lineDirection = parent->isHorizontalWritingMode() ? HorizontalLine : VerticalLine;
 747
 748         if (verticalAlign == SUB)
 749             verticalPosition += fontSize / 5 + 1;
 750         else if (verticalAlign == SUPER)
 751             verticalPosition -= fontSize / 3 + 1;
 752         else if (verticalAlign == TEXT_TOP)
 753             verticalPosition += renderer->baselinePosition(baselineType(), firstLine, lineDirection) - fontMetrics.ascent(baselineType());
 754         else if (verticalAlign == MIDDLE)
 755             verticalPosition = (verticalPosition - static_cast<LayoutUnit>(fontMetrics.xHeight() / 2) - renderer->lineHeight(firstLine, lineDirection) / 2 + renderer->baselinePosition(baselineType(), firstLine, lineDirection)).round();
 756         else if (verticalAlign == TEXT_BOTTOM) {
 757             verticalPosition += fontMetrics.descent(baselineType());
 758             // lineHeight - baselinePosition is always 0 for replaced elements (except inline blocks), so don't bother wasting time in that case.
 759             if (!renderer->isReplaced() || renderer->isInlineBlockOrInlineTable())
 760                 verticalPosition -= (renderer->lineHeight(firstLine, lineDirection) - renderer->baselinePosition(baselineType(), firstLine, lineDirection));
 761         } else if (verticalAlign == BASELINE_MIDDLE)
 762             verticalPosition += -renderer->lineHeight(firstLine, lineDirection) / 2 + renderer->baselinePosition(baselineType(), firstLine, lineDirection);
 763         else if (verticalAlign == LENGTH) {
 764             LayoutUnit lineHeight;
 765             //Per http://www.w3.org/TR/CSS21/visudet.html#propdef-vertical-align: 'Percentages: refer to the 'line-height' of the element itself'.
 766             if (renderer->style()->verticalAlignLength().isPercent())
 767                 lineHeight = renderer->style()->computedLineHeight();
 768             else
 769                 lineHeight = renderer->lineHeight(firstLine, lineDirection);
 770             verticalPosition -= valueForLength(renderer->style()->verticalAlignLength(), lineHeight);
 771         }
 772     }
 773
 774     // Store the cached value.
 775     if (isRenderInline && !firstLine)
 776         verticalPositionCache.set(renderer, baselineType(), verticalPosition);
 777
 778     return verticalPosition;
 779 }
 780
 781 bool RootInlineBox::includeLeadingForBox(InlineBox* box) const
 782 {
 783     if (box->renderer().isReplaced() || (box->renderer().isText() && !box->isText()))
 784         return false;
 785
 786     LineBoxContain lineBoxContain = renderer().style()->lineBoxContain();
 787     return (lineBoxContain & LineBoxContainInline) || (box == this && (lineBoxContain & LineBoxContainBlock));
 788 }
 789
 790 bool RootInlineBox::includeFontForBox(InlineBox* box) const
 791 {
 792     if (box->renderer().isReplaced() || (box->renderer().isText() && !box->isText()))
 793         return false;
 794
 795     if (!box->isText() && box->isInlineFlowBox() && !toInlineFlowBox(box)->hasTextChildren())
 796         return false;
 797
 798     // For now map "glyphs" to "font" in vertical text mode until the bounds returned by glyphs aren't garbage.
 799     LineBoxContain lineBoxContain = renderer().style()->lineBoxContain();
 800     return (lineBoxContain & LineBoxContainFont) || (!isHorizontal() && (lineBoxContain & LineBoxContainGlyphs));
 801 }
 802
 803 bool RootInlineBox::includeGlyphsForBox(InlineBox* box) const
 804 {
 805     if (box->renderer().isReplaced() || (box->renderer().isText() && !box->isText()))
 806         return false;
 807
 808     if (!box->isText() && box->isInlineFlowBox() && !toInlineFlowBox(box)->hasTextChildren())
 809         return false;
 810
 811     // FIXME: We can't fit to glyphs yet for vertical text, since the bounds returned are garbage.
 812     LineBoxContain lineBoxContain = renderer().style()->lineBoxContain();
 813     return isHorizontal() && (lineBoxContain & LineBoxContainGlyphs);
 814 }
 815
 816 bool RootInlineBox::includeMarginForBox(InlineBox* box) const
 817 {
 818     if (box->renderer().isReplaced() || (box->renderer().isText() && !box->isText()))
 819         return false;
 820
 821     LineBoxContain lineBoxContain = renderer().style()->lineBoxContain();
 822     return lineBoxContain & LineBoxContainInlineBox;
 823 }
 824
 825
 826 bool RootInlineBox::fitsToGlyphs() const
 827 {
 828     // FIXME: We can't fit to glyphs yet for vertical text, since the bounds returned are garbage.
 829     LineBoxContain lineBoxContain = renderer().style()->lineBoxContain();
 830     return isHorizontal() && (lineBoxContain & LineBoxContainGlyphs);
 831 }
 832
 833 bool RootInlineBox::includesRootLineBoxFontOrLeading() const
 834 {
 835     LineBoxContain lineBoxContain = renderer().style()->lineBoxContain();
 836     return (lineBoxContain & LineBoxContainBlock) || (lineBoxContain & LineBoxContainInline) || (lineBoxContain & LineBoxContainFont);
 837 }
 838
 839 Node* RootInlineBox::getLogicalStartBoxWithNode(InlineBox*& startBox) const
 840 {
 841     Vector<InlineBox*> leafBoxesInLogicalOrder;
 842     collectLeafBoxesInLogicalOrder(leafBoxesInLogicalOrder);
 843     for (size_t i = 0; i < leafBoxesInLogicalOrder.size(); ++i) {
 844         if (leafBoxesInLogicalOrder[i]->renderer().node()) {
 845             startBox = leafBoxesInLogicalOrder[i];
 846             return startBox->renderer().node();
 847         }
 848     }
 849     startBox = 0;
 850     return 0;
 851 }
 852
 853 Node* RootInlineBox::getLogicalEndBoxWithNode(InlineBox*& endBox) const
 854 {
 855     Vector<InlineBox*> leafBoxesInLogicalOrder;
 856     collectLeafBoxesInLogicalOrder(leafBoxesInLogicalOrder);
 857     for (size_t i = leafBoxesInLogicalOrder.size(); i > 0; --i) {
 858         if (leafBoxesInLogicalOrder[i - 1]->renderer().node()) {
 859             endBox = leafBoxesInLogicalOrder[i - 1];
 860             return endBox->renderer().node();
 861         }
 862     }
 863     endBox = 0;
 864     return 0;
 865 }
 866
 867 #ifndef NDEBUG
 868 const char* RootInlineBox::boxName() const
 869 {
 870     return "RootInlineBox";
 871 }
 872 #endif
 873
 874 } // namespace blink