Source/WebCore/rendering/InlineTextBox.cpp

   1 /*
   2  * (C) 1999 Lars Knoll (knoll@kde.org)
   3  * (C) 2000 Dirk Mueller (mueller@kde.org)
   4  * Copyright (C) 2004-2014 Apple Inc. All rights reserved.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public License
  17  * along with this library; see the file COPYING.LIB.  If not, write to
  18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  *
  21  */
  22
  23 #include "config.h"
  24 #include "InlineTextBox.h"
  25
  26 #include "BreakLines.h"
  27 #include "DashArray.h"
  28 #include "Document.h"
  29 #include "DocumentMarkerController.h"
  30 #include "Editor.h"
  31 #include "EllipsisBox.h"
  32 #include "Frame.h"
  33 #include "GraphicsContext.h"
  34 #include "HitTestResult.h"
  35 #include "ImageBuffer.h"
  36 #include "InlineTextBoxStyle.h"
  37 #include "Page.h"
  38 #include "PaintInfo.h"
  39 #include "RenderBlock.h"
  40 #include "RenderCombineText.h"
  41 #include "RenderLineBreak.h"
  42 #include "RenderRubyRun.h"
  43 #include "RenderRubyText.h"
  44 #include "RenderTheme.h"
  45 #include "RenderView.h"
  46 #include "RenderedDocumentMarker.h"
  47 #include "Text.h"
  48 #include "TextDecorationPainter.h"
  49 #include "TextPaintStyle.h"
  50 #include "TextPainter.h"
  51 #include <stdio.h>
  52 #include <wtf/text/CString.h>
  53 #include <wtf/text/TextStream.h>
  54
  55 namespace WebCore {
  56
  57 struct SameSizeAsInlineTextBox : public InlineBox {
  58     unsigned variables[1];
  59     unsigned short variables2[2];
  60     void* pointers[2];
  61 };
  62
  63 COMPILE_ASSERT(sizeof(InlineTextBox) == sizeof(SameSizeAsInlineTextBox), InlineTextBox_should_stay_small);
  64
  65 typedef WTF::HashMap<const InlineTextBox*, LayoutRect> InlineTextBoxOverflowMap;
  66 static InlineTextBoxOverflowMap* gTextBoxesWithOverflow;
  67
  68 InlineTextBox::~InlineTextBox()
  69 {
  70     if (!knownToHaveNoOverflow() && gTextBoxesWithOverflow)
  71         gTextBoxesWithOverflow->remove(this);
  72 }
  73
  74 void InlineTextBox::markDirty(bool dirty)
  75 {
  76     if (dirty) {
  77         m_len = 0;
  78         m_start = 0;
  79     }
  80     InlineBox::markDirty(dirty);
  81 }
  82
  83 LayoutRect InlineTextBox::logicalOverflowRect() const
  84 {
  85     if (knownToHaveNoOverflow() || !gTextBoxesWithOverflow)
  86         return enclosingIntRect(logicalFrameRect());
  87     return gTextBoxesWithOverflow->get(this);
  88 }
  89
  90 void InlineTextBox::setLogicalOverflowRect(const LayoutRect& rect)
  91 {
  92     ASSERT(!knownToHaveNoOverflow());
  93     if (!gTextBoxesWithOverflow)
  94         gTextBoxesWithOverflow = new InlineTextBoxOverflowMap;
  95     gTextBoxesWithOverflow->add(this, rect);
  96 }
  97
  98 int InlineTextBox::baselinePosition(FontBaseline baselineType) const
  99 {
 100     if (!parent())
 101         return 0;
 102     if (&parent()->renderer() == renderer().parent())
 103         return parent()->baselinePosition(baselineType);
 104     return downcast<RenderBoxModelObject>(*renderer().parent()).baselinePosition(baselineType, isFirstLine(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
 105 }
 106
 107 LayoutUnit InlineTextBox::lineHeight() const
 108 {
 109     if (!renderer().parent())
 110         return 0;
 111     if (&parent()->renderer() == renderer().parent())
 112         return parent()->lineHeight();
 113     return downcast<RenderBoxModelObject>(*renderer().parent()).lineHeight(isFirstLine(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
 114 }
 115
 116 LayoutUnit InlineTextBox::selectionTop() const
 117 {
 118     return root().selectionTop();
 119 }
 120
 121 LayoutUnit InlineTextBox::selectionBottom() const
 122 {
 123     return root().selectionBottom();
 124 }
 125
 126 LayoutUnit InlineTextBox::selectionHeight() const
 127 {
 128     return root().selectionHeight();
 129 }
 130
 131 bool InlineTextBox::isSelected(unsigned startPos, unsigned endPos) const
 132 {
 133     int sPos = clampedOffset(startPos);
 134     int ePos = clampedOffset(endPos);
 135     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=160786
 136     // We should only be checking if sPos >= ePos here, because those are the
 137     // indices used to actually generate the selection rect. Allowing us past this guard
 138     // on any other condition creates zero-width selection rects.
 139     return sPos < ePos || (startPos == endPos && startPos >= start() && startPos <= (start() + len()));
 140 }
 141
 142 RenderObject::SelectionState InlineTextBox::selectionState()
 143 {
 144     RenderObject::SelectionState state = renderer().selectionState();
 145     if (state == RenderObject::SelectionStart || state == RenderObject::SelectionEnd || state == RenderObject::SelectionBoth) {
 146         unsigned startPos, endPos;
 147         renderer().selectionStartEnd(startPos, endPos);
 148         // The position after a hard line break is considered to be past its end.
 149         ASSERT(start() + len() >= (isLineBreak() ? 1 : 0));
 150         unsigned lastSelectable = start() + len() - (isLineBreak() ? 1 : 0);
 151
 152         bool start = (state != RenderObject::SelectionEnd && startPos >= m_start && startPos < m_start + m_len);
 153         bool end = (state != RenderObject::SelectionStart && endPos > m_start && endPos <= lastSelectable);
 154         if (start && end)
 155             state = RenderObject::SelectionBoth;
 156         else if (start)
 157             state = RenderObject::SelectionStart;
 158         else if (end)
 159             state = RenderObject::SelectionEnd;
 160         else if ((state == RenderObject::SelectionEnd || startPos < m_start) &&
 161                  (state == RenderObject::SelectionStart || endPos > lastSelectable))
 162             state = RenderObject::SelectionInside;
 163         else if (state == RenderObject::SelectionBoth)
 164             state = RenderObject::SelectionNone;
 165     }
 166
 167     // If there are ellipsis following, make sure their selection is updated.
 168     if (m_truncation != cNoTruncation && root().ellipsisBox()) {
 169         EllipsisBox* ellipsis = root().ellipsisBox();
 170         if (state != RenderObject::SelectionNone) {
 171             unsigned selectionStart;
 172             unsigned selectionEnd;
 173             std::tie(selectionStart, selectionEnd) = selectionStartEnd();
 174             // The ellipsis should be considered to be selected if the end of
 175             // the selection is past the beginning of the truncation and the
 176             // beginning of the selection is before or at the beginning of the
 177             // truncation.
 178             ellipsis->setSelectionState(selectionEnd >= m_truncation && selectionStart <= m_truncation ?
 179                 RenderObject::SelectionInside : RenderObject::SelectionNone);
 180         } else
 181             ellipsis->setSelectionState(RenderObject::SelectionNone);
 182     }
 183
 184     return state;
 185 }
 186
 187 static const FontCascade& fontToUse(const RenderStyle& style, const RenderText& renderer)
 188 {
 189     if (style.hasTextCombine() && is<RenderCombineText>(renderer)) {
 190         const auto& textCombineRenderer = downcast<RenderCombineText>(renderer);
 191         if (textCombineRenderer.isCombined())
 192             return textCombineRenderer.textCombineFont();
 193     }
 194     return style.fontCascade();
 195 }
 196
 197 LayoutRect InlineTextBox::localSelectionRect(unsigned startPos, unsigned endPos) const
 198 {
 199     unsigned sPos = clampedOffset(startPos);
 200     unsigned ePos = clampedOffset(endPos);
 201
 202     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=160786
 203     // We should only be checking if sPos >= ePos here, because those are the
 204     // indices used to actually generate the selection rect. Allowing us past this guard
 205     // on any other condition creates zero-width selection rects.
 206     if (sPos >= ePos && !(startPos == endPos && startPos >= start() && startPos <= (start() + len())))
 207         return LayoutRect();
 208
 209     LayoutUnit selectionTop = this->selectionTop();
 210     LayoutUnit selectionHeight = this->selectionHeight();
 211     const RenderStyle& lineStyle = this->lineStyle();
 212     const FontCascade& font = fontToUse(lineStyle, renderer());
 213
 214     String hyphenatedString;
 215     bool respectHyphen = ePos == m_len && hasHyphen();
 216     if (respectHyphen)
 217         hyphenatedString = hyphenatedStringForTextRun(lineStyle);
 218     TextRun textRun = constructTextRun(lineStyle, hyphenatedString);
 219
 220     LayoutRect selectionRect = LayoutRect(LayoutPoint(logicalLeft(), selectionTop), LayoutSize(m_logicalWidth, selectionHeight));
 221     // Avoid computing the font width when the entire line box is selected as an optimization.
 222     if (sPos || ePos != m_len)
 223         font.adjustSelectionRectForText(textRun, selectionRect, sPos, ePos);
 224     IntRect snappedSelectionRect = enclosingIntRect(selectionRect);
 225     LayoutUnit logicalWidth = snappedSelectionRect.width();
 226     if (snappedSelectionRect.x() > logicalRight())
 227         logicalWidth  = 0;
 228     else if (snappedSelectionRect.maxX() > logicalRight())
 229         logicalWidth = logicalRight() - snappedSelectionRect.x();
 230
 231     LayoutPoint topPoint = isHorizontal() ? LayoutPoint(snappedSelectionRect.x(), selectionTop) : LayoutPoint(selectionTop, snappedSelectionRect.x());
 232     LayoutUnit width = isHorizontal() ? logicalWidth : selectionHeight;
 233     LayoutUnit height = isHorizontal() ? selectionHeight : logicalWidth;
 234
 235     return LayoutRect(topPoint, LayoutSize(width, height));
 236 }
 237
 238 void InlineTextBox::deleteLine()
 239 {
 240     renderer().removeTextBox(*this);
 241     delete this;
 242 }
 243
 244 void InlineTextBox::extractLine()
 245 {
 246     if (extracted())
 247         return;
 248
 249     renderer().extractTextBox(*this);
 250 }
 251
 252 void InlineTextBox::attachLine()
 253 {
 254     if (!extracted())
 255         return;
 256
 257     renderer().attachTextBox(*this);
 258 }
 259
 260 float InlineTextBox::placeEllipsisBox(bool flowIsLTR, float visibleLeftEdge, float visibleRightEdge, float ellipsisWidth, float &truncatedWidth, bool& foundBox)
 261 {
 262     if (foundBox) {
 263         m_truncation = cFullTruncation;
 264         return -1;
 265     }
 266
 267     // For LTR this is the left edge of the box, for RTL, the right edge in parent coordinates.
 268     float ellipsisX = flowIsLTR ? visibleRightEdge - ellipsisWidth : visibleLeftEdge + ellipsisWidth;
 269
 270     // Criteria for full truncation:
 271     // LTR: the left edge of the ellipsis is to the left of our text run.
 272     // RTL: the right edge of the ellipsis is to the right of our text run.
 273     bool ltrFullTruncation = flowIsLTR && ellipsisX <= left();
 274     bool rtlFullTruncation = !flowIsLTR && ellipsisX >= left() + logicalWidth();
 275     if (ltrFullTruncation || rtlFullTruncation) {
 276         // Too far.  Just set full truncation, but return -1 and let the ellipsis just be placed at the edge of the box.
 277         m_truncation = cFullTruncation;
 278         foundBox = true;
 279         return -1;
 280     }
 281
 282     bool ltrEllipsisWithinBox = flowIsLTR && (ellipsisX < right());
 283     bool rtlEllipsisWithinBox = !flowIsLTR && (ellipsisX > left());
 284     if (ltrEllipsisWithinBox || rtlEllipsisWithinBox) {
 285         foundBox = true;
 286
 287         // The inline box may have different directionality than it's parent.  Since truncation
 288         // behavior depends both on both the parent and the inline block's directionality, we
 289         // must keep track of these separately.
 290         bool ltr = isLeftToRightDirection();
 291         if (ltr != flowIsLTR) {
 292           // Width in pixels of the visible portion of the box, excluding the ellipsis.
 293           int visibleBoxWidth = visibleRightEdge - visibleLeftEdge  - ellipsisWidth;
 294           ellipsisX = ltr ? left() + visibleBoxWidth : right() - visibleBoxWidth;
 295         }
 296
 297         int offset = offsetForPosition(ellipsisX, false);
 298         if (offset == 0) {
 299             // No characters should be rendered.  Set ourselves to full truncation and place the ellipsis at the min of our start
 300             // and the ellipsis edge.
 301             m_truncation = cFullTruncation;
 302             truncatedWidth += ellipsisWidth;
 303             return flowIsLTR ? std::min(ellipsisX, x()) : std::max(ellipsisX, right() - ellipsisWidth);
 304         }
 305
 306         // Set the truncation index on the text run.
 307         m_truncation = offset;
 308
 309         // If we got here that means that we were only partially truncated and we need to return the pixel offset at which
 310         // to place the ellipsis.
 311         float widthOfVisibleText = renderer().width(m_start, offset, textPos(), isFirstLine());
 312
 313         // The ellipsis needs to be placed just after the last visible character.
 314         // Where "after" is defined by the flow directionality, not the inline
 315         // box directionality.
 316         // e.g. In the case of an LTR inline box truncated in an RTL flow then we can
 317         // have a situation such as |Hello| -> |...He|
 318         truncatedWidth += widthOfVisibleText + ellipsisWidth;
 319         if (flowIsLTR)
 320             return left() + widthOfVisibleText;
 321         else
 322             return right() - widthOfVisibleText - ellipsisWidth;
 323     }
 324     truncatedWidth += logicalWidth();
 325     return -1;
 326 }
 327
 328
 329
 330 bool InlineTextBox::isLineBreak() const
 331 {
 332     return renderer().style().preserveNewline() && len() == 1 && (*renderer().text())[start()] == '\n';
 333 }
 334
 335 bool InlineTextBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit /* lineTop */, LayoutUnit /*lineBottom*/,
 336     HitTestAction /*hitTestAction*/)
 337 {
 338     if (!visibleToHitTesting())
 339         return false;
 340
 341     if (isLineBreak())
 342         return false;
 343
 344     if (m_truncation == cFullTruncation)
 345         return false;
 346
 347     FloatRect rect(locationIncludingFlipping(), size());
 348     // Make sure truncated text is ignored while hittesting.
 349     if (m_truncation != cNoTruncation) {
 350         LayoutUnit widthOfVisibleText = renderer().width(m_start, m_truncation, textPos(), isFirstLine());
 351
 352         if (isHorizontal())
 353             renderer().style().isLeftToRightDirection() ? rect.setWidth(widthOfVisibleText) : rect.shiftXEdgeTo(right() - widthOfVisibleText);
 354         else
 355             rect.setHeight(widthOfVisibleText);
 356     }
 357
 358     rect.moveBy(accumulatedOffset);
 359
 360     if (locationInContainer.intersects(rect)) {
 361         renderer().updateHitTestResult(result, flipForWritingMode(locationInContainer.point() - toLayoutSize(accumulatedOffset)));
 362         if (result.addNodeToListBasedTestResult(renderer().textNode(), request, locationInContainer, rect) == HitTestProgress::Stop)
 363             return true;
 364     }
 365     return false;
 366 }
 367
 368 static inline bool emphasisPositionHasNeitherLeftNorRight(TextEmphasisPosition emphasisPosition)
 369 {
 370     return !(emphasisPosition & TextEmphasisPositionLeft) && !(emphasisPosition & TextEmphasisPositionRight);
 371 }
 372
 373 bool InlineTextBox::emphasisMarkExistsAndIsAbove(const RenderStyle& style, bool& above) const
 374 {
 375     // This function returns true if there are text emphasis marks and they are suppressed by ruby text.
 376     if (style.textEmphasisMark() == TextEmphasisMarkNone)
 377         return false;
 378
 379     TextEmphasisPosition emphasisPosition = style.textEmphasisPosition();
 380     ASSERT(!((emphasisPosition & TextEmphasisPositionOver) && (emphasisPosition & TextEmphasisPositionUnder)));
 381     ASSERT(!((emphasisPosition & TextEmphasisPositionLeft) && (emphasisPosition & TextEmphasisPositionRight)));
 382
 383     if (emphasisPositionHasNeitherLeftNorRight(emphasisPosition))
 384         above = emphasisPosition & TextEmphasisPositionOver;
 385     else if (style.isHorizontalWritingMode())
 386         above = emphasisPosition & TextEmphasisPositionOver;
 387     else
 388         above = emphasisPosition & TextEmphasisPositionRight;
 389
 390     if ((style.isHorizontalWritingMode() && (emphasisPosition & TextEmphasisPositionUnder))
 391         || (!style.isHorizontalWritingMode() && (emphasisPosition & TextEmphasisPositionLeft)))
 392         return true; // Ruby text is always over, so it cannot suppress emphasis marks under.
 393
 394     RenderBlock* containingBlock = renderer().containingBlock();
 395     if (!containingBlock->isRubyBase())
 396         return true; // This text is not inside a ruby base, so it does not have ruby text over it.
 397
 398     if (!is<RenderRubyRun>(*containingBlock->parent()))
 399         return true; // Cannot get the ruby text.
 400
 401     RenderRubyText* rubyText = downcast<RenderRubyRun>(*containingBlock->parent()).rubyText();
 402
 403     // The emphasis marks over are suppressed only if there is a ruby text box and it not empty.
 404     return !rubyText || !rubyText->hasLines();
 405 }
 406
 407 void InlineTextBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /*lineTop*/, LayoutUnit /*lineBottom*/)
 408 {
 409     if (isLineBreak() || !paintInfo.shouldPaintWithinRoot(renderer()) || renderer().style().visibility() != VISIBLE
 410         || m_truncation == cFullTruncation || paintInfo.phase == PaintPhaseOutline || !m_len)
 411         return;
 412
 413     ASSERT(paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines);
 414
 415     LayoutUnit logicalLeftSide = logicalLeftVisualOverflow();
 416     LayoutUnit logicalRightSide = logicalRightVisualOverflow();
 417     LayoutUnit logicalStart = logicalLeftSide + (isHorizontal() ? paintOffset.x() : paintOffset.y());
 418     LayoutUnit logicalExtent = logicalRightSide - logicalLeftSide;
 419
 420     LayoutUnit paintEnd = isHorizontal() ? paintInfo.rect.maxX() : paintInfo.rect.maxY();
 421     LayoutUnit paintStart = isHorizontal() ? paintInfo.rect.x() : paintInfo.rect.y();
 422
 423     FloatPoint localPaintOffset(paintOffset);
 424
 425     if (logicalStart >= paintEnd || logicalStart + logicalExtent <= paintStart)
 426         return;
 427
 428     bool isPrinting = renderer().document().printing();
 429
 430     // Determine whether or not we're selected.
 431     bool haveSelection = !isPrinting && paintInfo.phase != PaintPhaseTextClip && selectionState() != RenderObject::SelectionNone;
 432     if (!haveSelection && paintInfo.phase == PaintPhaseSelection)
 433         // When only painting the selection, don't bother to paint if there is none.
 434         return;
 435
 436     if (m_truncation != cNoTruncation) {
 437         if (renderer().containingBlock()->style().isLeftToRightDirection() != isLeftToRightDirection()) {
 438             // Make the visible fragment of text hug the edge closest to the rest of the run by moving the origin
 439             // at which we start drawing text.
 440             // e.g. In the case of LTR text truncated in an RTL Context, the correct behavior is:
 441             // |Hello|CBA| -> |...He|CBA|
 442             // In order to draw the fragment "He" aligned to the right edge of it's box, we need to start drawing
 443             // farther to the right.
 444             // NOTE: WebKit's behavior differs from that of IE which appears to just overlay the ellipsis on top of the
 445             // truncated string i.e.  |Hello|CBA| -> |...lo|CBA|
 446             LayoutUnit widthOfVisibleText = renderer().width(m_start, m_truncation, textPos(), isFirstLine());
 447             LayoutUnit widthOfHiddenText = m_logicalWidth - widthOfVisibleText;
 448             LayoutSize truncationOffset(isLeftToRightDirection() ? widthOfHiddenText : -widthOfHiddenText, 0);
 449             localPaintOffset.move(isHorizontal() ? truncationOffset : truncationOffset.transposedSize());
 450         }
 451     }
 452
 453     GraphicsContext& context = paintInfo.context();
 454
 455     const RenderStyle& lineStyle = this->lineStyle();
 456
 457     localPaintOffset.move(0, lineStyle.isHorizontalWritingMode() ? 0 : -logicalHeight());
 458
 459     FloatPoint boxOrigin = locationIncludingFlipping();
 460     boxOrigin.moveBy(localPaintOffset);
 461     FloatRect boxRect(boxOrigin, FloatSize(logicalWidth(), logicalHeight()));
 462
 463     RenderCombineText* combinedText = lineStyle.hasTextCombine() && is<RenderCombineText>(renderer()) && downcast<RenderCombineText>(renderer()).isCombined() ? &downcast<RenderCombineText>(renderer()) : nullptr;
 464
 465     bool shouldRotate = !isHorizontal() && !combinedText;
 466     if (shouldRotate)
 467         context.concatCTM(rotation(boxRect, Clockwise));
 468
 469     // Determine whether or not we have composition underlines to draw.
 470     bool containsComposition = renderer().textNode() && renderer().frame().editor().compositionNode() == renderer().textNode();
 471     bool useCustomUnderlines = containsComposition && renderer().frame().editor().compositionUsesCustomUnderlines();
 472
 473     // Determine the text colors and selection colors.
 474     TextPaintStyle textPaintStyle = computeTextPaintStyle(renderer().frame(), lineStyle, paintInfo);
 475
 476     bool paintSelectedTextOnly = false;
 477     bool paintSelectedTextSeparately = false;
 478     bool paintNonSelectedTextOnly = false;
 479     const ShadowData* selectionShadow = nullptr;
 480
 481     // Text with custom underlines does not have selection background painted, so selection paint style is not appropriate for it.
 482     TextPaintStyle selectionPaintStyle = haveSelection && !useCustomUnderlines ? computeTextSelectionPaintStyle(textPaintStyle, renderer(), lineStyle, paintInfo, paintSelectedTextOnly, paintSelectedTextSeparately, paintNonSelectedTextOnly, selectionShadow) : textPaintStyle;
 483
 484     // Set our font.
 485     const FontCascade& font = fontToUse(lineStyle, renderer());
 486     // 1. Paint backgrounds behind text if needed. Examples of such backgrounds include selection
 487     // and composition underlines.
 488     if (paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseTextClip && !isPrinting) {
 489         if (containsComposition && !useCustomUnderlines)
 490             paintCompositionBackground(context, boxOrigin, lineStyle, font,
 491                 renderer().frame().editor().compositionStart(),
 492                 renderer().frame().editor().compositionEnd());
 493
 494         paintDocumentMarkers(context, boxOrigin, lineStyle, font, true);
 495
 496         if (haveSelection && !useCustomUnderlines)
 497             paintSelection(context, boxOrigin, lineStyle, font, selectionPaintStyle.fillColor);
 498     }
 499
 500     // FIXME: Right now, InlineTextBoxes never call addRelevantUnpaintedObject() even though they might
 501     // legitimately be unpainted if they are waiting on a slow-loading web font. We should fix that, and
 502     // when we do, we will have to account for the fact the InlineTextBoxes do not always have unique
 503     // renderers and Page currently relies on each unpainted object having a unique renderer.
 504     if (paintInfo.phase == PaintPhaseForeground)
 505         renderer().page().addRelevantRepaintedObject(&renderer(), IntRect(boxOrigin.x(), boxOrigin.y(), logicalWidth(), logicalHeight()));
 506
 507     // 2. Now paint the foreground, including text and decorations like underline/overline (in quirks mode only).
 508     String alternateStringToRender;
 509     if (combinedText)
 510         alternateStringToRender = combinedText->combinedStringForRendering();
 511     else if (hasHyphen())
 512         alternateStringToRender = hyphenatedStringForTextRun(lineStyle);
 513
 514     TextRun textRun = constructTextRun(lineStyle, alternateStringToRender);
 515     unsigned length = textRun.length();
 516
 517     unsigned selectionStart = 0;
 518     unsigned selectionEnd = 0;
 519     if (haveSelection && (paintSelectedTextOnly || paintSelectedTextSeparately))
 520         std::tie(selectionStart, selectionEnd) = selectionStartEnd();
 521
 522     if (m_truncation != cNoTruncation) {
 523         selectionStart = std::min(selectionStart, static_cast<unsigned>(m_truncation));
 524         selectionEnd = std::min(selectionEnd, static_cast<unsigned>(m_truncation));
 525         length = m_truncation;
 526     }
 527
 528     float emphasisMarkOffset = 0;
 529     bool emphasisMarkAbove;
 530     bool hasTextEmphasis = emphasisMarkExistsAndIsAbove(lineStyle, emphasisMarkAbove);
 531     const AtomicString& emphasisMark = hasTextEmphasis ? lineStyle.textEmphasisMarkString() : nullAtom();
 532     if (!emphasisMark.isEmpty())
 533         emphasisMarkOffset = emphasisMarkAbove ? -font.fontMetrics().ascent() - font.emphasisMarkDescent(emphasisMark) : font.fontMetrics().descent() + font.emphasisMarkAscent(emphasisMark);
 534
 535     const ShadowData* textShadow = (paintInfo.forceTextColor()) ? nullptr : lineStyle.textShadow();
 536
 537     FloatPoint textOrigin(boxOrigin.x(), boxOrigin.y() + font.fontMetrics().ascent());
 538     if (combinedText) {
 539         if (auto newOrigin = combinedText->computeTextOrigin(boxRect))
 540             textOrigin = newOrigin.value();
 541     }
 542
 543     if (isHorizontal())
 544         textOrigin.setY(roundToDevicePixel(LayoutUnit(textOrigin.y()), renderer().document().deviceScaleFactor()));
 545     else
 546         textOrigin.setX(roundToDevicePixel(LayoutUnit(textOrigin.x()), renderer().document().deviceScaleFactor()));
 547
 548     TextPainter textPainter(context);
 549     textPainter.setFont(font);
 550     textPainter.setStyle(textPaintStyle);
 551     textPainter.setSelectionStyle(selectionPaintStyle);
 552     textPainter.setIsHorizontal(isHorizontal());
 553     textPainter.setShadow(textShadow);
 554     textPainter.setSelectionShadow(selectionShadow);
 555     textPainter.setEmphasisMark(emphasisMark, emphasisMarkOffset, combinedText);
 556
 557     auto draggedContentRanges = renderer().draggedContentRangesBetweenOffsets(m_start, m_start + m_len);
 558     if (!draggedContentRanges.isEmpty() && !paintSelectedTextOnly && !paintNonSelectedTextOnly) {
 559         // FIXME: Painting with text effects ranges currently only works if we're not also painting the selection.
 560         // In the future, we may want to support this capability, but in the meantime, this isn't required by anything.
 561         unsigned currentEnd = 0;
 562         for (size_t index = 0; index < draggedContentRanges.size(); ++index) {
 563             unsigned previousEnd = index ? std::min(draggedContentRanges[index - 1].second, length) : 0;
 564             unsigned currentStart = draggedContentRanges[index].first - m_start;
 565             currentEnd = std::min(draggedContentRanges[index].second - m_start, length);
 566
 567             if (previousEnd < currentStart)
 568                 textPainter.paintRange(textRun, boxRect, textOrigin, previousEnd, currentStart);
 569
 570             if (currentStart < currentEnd) {
 571                 context.save();
 572                 context.setAlpha(0.25);
 573                 textPainter.paintRange(textRun, boxRect, textOrigin, currentStart, currentEnd);
 574                 context.restore();
 575             }
 576         }
 577         if (currentEnd < length)
 578             textPainter.paintRange(textRun, boxRect, textOrigin, currentEnd, length);
 579     } else
 580         textPainter.paint(textRun, length, boxRect, textOrigin, selectionStart, selectionEnd, paintSelectedTextOnly, paintSelectedTextSeparately, paintNonSelectedTextOnly);
 581
 582     // Paint decorations
 583     TextDecoration textDecorations = lineStyle.textDecorationsInEffect();
 584     if (textDecorations != TextDecorationNone && paintInfo.phase != PaintPhaseSelection) {
 585         FloatRect textDecorationSelectionClipOutRect;
 586         if ((paintInfo.paintBehavior & PaintBehaviorExcludeSelection) && selectionStart < selectionEnd && selectionEnd <= length) {
 587             textDecorationSelectionClipOutRect = logicalOverflowRect();
 588             textDecorationSelectionClipOutRect.moveBy(localPaintOffset);
 589             float logicalWidthBeforeRange;
 590             float logicalWidthAfterRange;
 591             float logicalSelectionWidth = font.widthOfTextRange(textRun, selectionStart, selectionEnd, nullptr, &logicalWidthBeforeRange, &logicalWidthAfterRange);
 592             // FIXME: Do we need to handle vertical bottom to top text?
 593             if (!isHorizontal()) {
 594                 textDecorationSelectionClipOutRect.move(0, logicalWidthBeforeRange);
 595                 textDecorationSelectionClipOutRect.setHeight(logicalSelectionWidth);
 596             } else if (direction() == RTL) {
 597                 textDecorationSelectionClipOutRect.move(logicalWidthAfterRange, 0);
 598                 textDecorationSelectionClipOutRect.setWidth(logicalSelectionWidth);
 599             } else {
 600                 textDecorationSelectionClipOutRect.move(logicalWidthBeforeRange, 0);
 601                 textDecorationSelectionClipOutRect.setWidth(logicalSelectionWidth);
 602             }
 603         }
 604         paintDecoration(context, font, combinedText, textRun, textOrigin, boxRect, textDecorations, textPaintStyle, textShadow, textDecorationSelectionClipOutRect);
 605     }
 606
 607     if (paintInfo.phase == PaintPhaseForeground) {
 608         paintDocumentMarkers(context, boxOrigin, lineStyle, font, false);
 609
 610         if (useCustomUnderlines) {
 611             const Vector<CompositionUnderline>& underlines = renderer().frame().editor().customCompositionUnderlines();
 612             size_t numUnderlines = underlines.size();
 613
 614             for (size_t index = 0; index < numUnderlines; ++index) {
 615                 const CompositionUnderline& underline = underlines[index];
 616
 617                 if (underline.endOffset <= start())
 618                     // underline is completely before this run.  This might be an underline that sits
 619                     // before the first run we draw, or underlines that were within runs we skipped
 620                     // due to truncation.
 621                     continue;
 622
 623                 if (underline.startOffset <= end()) {
 624                     // underline intersects this run.  Paint it.
 625                     paintCompositionUnderline(context, boxOrigin, underline);
 626                     if (underline.endOffset > end() + 1)
 627                         // underline also runs into the next run. Bail now, no more marker advancement.
 628                         break;
 629                 } else
 630                     // underline is completely after this run, bail.  A later run will paint it.
 631                     break;
 632             }
 633         }
 634     }
 635
 636     if (shouldRotate)
 637         context.concatCTM(rotation(boxRect, Counterclockwise));
 638 }
 639
 640 unsigned InlineTextBox::clampedOffset(unsigned x) const
 641 {
 642     return std::max(std::min(x, start() + len()), start()) - start();
 643 }
 644
 645 std::pair<unsigned, unsigned> InlineTextBox::selectionStartEnd() const
 646 {
 647     auto selectionState = renderer().selectionState();
 648     if (selectionState == RenderObject::SelectionInside)
 649         return { 0, m_len };
 650
 651     unsigned start;
 652     unsigned end;
 653     renderer().selectionStartEnd(start, end);
 654     if (selectionState == RenderObject::SelectionStart)
 655         end = renderer().textLength();
 656     else if (selectionState == RenderObject::SelectionEnd)
 657         start = 0;
 658     return { clampedOffset(start), clampedOffset(end) };
 659 }
 660
 661 void InlineTextBox::paintSelection(GraphicsContext& context, const FloatPoint& boxOrigin, const RenderStyle& style, const FontCascade& font, const Color& textColor)
 662 {
 663 #if ENABLE(TEXT_SELECTION)
 664     if (context.paintingDisabled())
 665         return;
 666
 667     // See if we have a selection to paint at all.
 668     unsigned selectionStart;
 669     unsigned selectionEnd;
 670     std::tie(selectionStart, selectionEnd) = selectionStartEnd();
 671     if (selectionStart >= selectionEnd)
 672         return;
 673
 674     Color c = renderer().selectionBackgroundColor();
 675     if (!c.isValid() || c.alpha() == 0)
 676         return;
 677
 678     // If the text color ends up being the same as the selection background, invert the selection
 679     // background.
 680     if (textColor == c)
 681         c = Color(0xff - c.red(), 0xff - c.green(), 0xff - c.blue());
 682
 683     GraphicsContextStateSaver stateSaver(context);
 684     updateGraphicsContext(context, TextPaintStyle(c)); // Don't draw text at all!
 685
 686     // If the text is truncated, let the thing being painted in the truncation
 687     // draw its own highlight.
 688
 689     unsigned length = m_truncation != cNoTruncation ? m_truncation : len();
 690
 691     String hyphenatedString;
 692     bool respectHyphen = selectionEnd == length && hasHyphen();
 693     if (respectHyphen)
 694         hyphenatedString = hyphenatedStringForTextRun(style, length);
 695     TextRun textRun = constructTextRun(style, hyphenatedString, std::optional<unsigned>(length));
 696     if (respectHyphen)
 697         selectionEnd = textRun.length();
 698
 699     const RootInlineBox& rootBox = root();
 700     LayoutUnit selectionBottom = rootBox.selectionBottom();
 701     LayoutUnit selectionTop = rootBox.selectionTopAdjustedForPrecedingBlock();
 702
 703     LayoutUnit deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom - logicalBottom() : logicalTop() - selectionTop;
 704     LayoutUnit selectionHeight = std::max<LayoutUnit>(0, selectionBottom - selectionTop);
 705
 706     LayoutRect selectionRect = LayoutRect(boxOrigin.x(), boxOrigin.y() - deltaY, m_logicalWidth, selectionHeight);
 707     font.adjustSelectionRectForText(textRun, selectionRect, selectionStart, selectionEnd);
 708     context.fillRect(snapRectToDevicePixelsWithWritingDirection(selectionRect, renderer().document().deviceScaleFactor(), textRun.ltr()), c);
 709 #else
 710     UNUSED_PARAM(context);
 711     UNUSED_PARAM(boxOrigin);
 712     UNUSED_PARAM(style);
 713     UNUSED_PARAM(font);
 714     UNUSED_PARAM(textColor);
 715 #endif
 716 }
 717
 718 void InlineTextBox::paintCompositionBackground(GraphicsContext& context, const FloatPoint& boxOrigin, const RenderStyle& style, const FontCascade& font, unsigned startPos, unsigned endPos)
 719 {
 720     unsigned selectionStart = clampedOffset(startPos);
 721     unsigned selectionEnd = clampedOffset(endPos);
 722     if (selectionStart >= selectionEnd)
 723         return;
 724
 725     GraphicsContextStateSaver stateSaver(context);
 726     Color compositionColor = Color::compositionFill;
 727     updateGraphicsContext(context, TextPaintStyle(compositionColor)); // Don't draw text at all!
 728
 729     LayoutUnit deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom() - logicalBottom() : logicalTop() - selectionTop();
 730     LayoutRect selectionRect = LayoutRect(boxOrigin.x(), boxOrigin.y() - deltaY, 0, selectionHeight());
 731     TextRun textRun = constructTextRun(style);
 732     font.adjustSelectionRectForText(textRun, selectionRect, selectionStart, selectionEnd);
 733     context.fillRect(snapRectToDevicePixelsWithWritingDirection(selectionRect, renderer().document().deviceScaleFactor(), textRun.ltr()), compositionColor);
 734 }
 735
 736 static inline void mirrorRTLSegment(float logicalWidth, TextDirection direction, float& start, float width)
 737 {
 738     if (direction == LTR)
 739         return;
 740     start = logicalWidth - width - start;
 741 }
 742
 743 void InlineTextBox::paintDecoration(GraphicsContext& context, const FontCascade& font, RenderCombineText* combinedText, const TextRun& textRun, const FloatPoint& textOrigin,
 744     const FloatRect& boxRect, TextDecoration decoration, TextPaintStyle textPaintStyle, const ShadowData* shadow, const FloatRect& clipOutRect)
 745 {
 746     if (m_truncation == cFullTruncation)
 747         return;
 748
 749     updateGraphicsContext(context, textPaintStyle);
 750     if (combinedText)
 751         context.concatCTM(rotation(boxRect, Clockwise));
 752
 753     float start = 0;
 754     float width = m_logicalWidth;
 755     if (m_truncation != cNoTruncation) {
 756         width = renderer().width(m_start, m_truncation, textPos(), isFirstLine());
 757         mirrorRTLSegment(m_logicalWidth, direction(), start, width);
 758     }
 759
 760     TextDecorationPainter decorationPainter(context, decoration, renderer(), isFirstLine());
 761     decorationPainter.setInlineTextBox(this);
 762     decorationPainter.setFont(font);
 763     decorationPainter.setWidth(width);
 764     decorationPainter.setBaseline(lineStyle().fontMetrics().ascent());
 765     decorationPainter.setIsHorizontal(isHorizontal());
 766     decorationPainter.addTextShadow(shadow);
 767
 768     FloatPoint localOrigin = boxRect.location();
 769     localOrigin.move(start, 0);
 770
 771     if (!clipOutRect.isEmpty()) {
 772         context.save();
 773         context.clipOut(clipOutRect);
 774     }
 775
 776     decorationPainter.paintTextDecoration(textRun, textOrigin, localOrigin);
 777
 778     if (!clipOutRect.isEmpty())
 779         context.restore();
 780
 781     if (combinedText)
 782         context.concatCTM(rotation(boxRect, Counterclockwise));
 783 }
 784
 785 static GraphicsContext::DocumentMarkerLineStyle lineStyleForMarkerType(DocumentMarker::MarkerType markerType)
 786 {
 787     switch (markerType) {
 788     case DocumentMarker::Spelling:
 789         return GraphicsContext::DocumentMarkerSpellingLineStyle;
 790     case DocumentMarker::Grammar:
 791         return GraphicsContext::DocumentMarkerGrammarLineStyle;
 792     case DocumentMarker::CorrectionIndicator:
 793         return GraphicsContext::DocumentMarkerAutocorrectionReplacementLineStyle;
 794     case DocumentMarker::DictationAlternatives:
 795         return GraphicsContext::DocumentMarkerDictationAlternativesLineStyle;
 796 #if PLATFORM(IOS)
 797     case DocumentMarker::DictationPhraseWithAlternatives:
 798         // FIXME: Rename TextCheckingDictationPhraseWithAlternativesLineStyle and remove the PLATFORM(IOS)-guard.
 799         return GraphicsContext::TextCheckingDictationPhraseWithAlternativesLineStyle;
 800 #endif
 801     default:
 802         ASSERT_NOT_REACHED();
 803         return GraphicsContext::DocumentMarkerSpellingLineStyle;
 804     }
 805 }
 806
 807 void InlineTextBox::paintDocumentMarker(GraphicsContext& context, const FloatPoint& boxOrigin, RenderedDocumentMarker& marker, const RenderStyle& style, const FontCascade& font, bool grammar)
 808 {
 809     // Never print spelling/grammar markers (5327887)
 810     if (renderer().document().printing())
 811         return;
 812
 813     if (m_truncation == cFullTruncation)
 814         return;
 815
 816     float start = 0; // start of line to draw, relative to tx
 817     float width = m_logicalWidth; // how much line to draw
 818
 819     // Determine whether we need to measure text
 820     bool markerSpansWholeBox = true;
 821     if (m_start <= marker.startOffset())
 822         markerSpansWholeBox = false;
 823     if ((end() + 1) != marker.endOffset()) // end points at the last char, not past it
 824         markerSpansWholeBox = false;
 825     if (m_truncation != cNoTruncation)
 826         markerSpansWholeBox = false;
 827
 828     bool isDictationMarker = marker.type() == DocumentMarker::DictationAlternatives;
 829     if (!markerSpansWholeBox || grammar || isDictationMarker) {
 830         unsigned startPosition = clampedOffset(marker.startOffset());
 831         unsigned endPosition = clampedOffset(marker.endOffset());
 832
 833         if (m_truncation != cNoTruncation)
 834             endPosition = std::min(endPosition, static_cast<unsigned>(m_truncation));
 835
 836         // Calculate start & width
 837         int deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom() - logicalBottom() : logicalTop() - selectionTop();
 838         int selHeight = selectionHeight();
 839         FloatPoint startPoint(boxOrigin.x(), boxOrigin.y() - deltaY);
 840         TextRun run = constructTextRun(style);
 841
 842         LayoutRect selectionRect = LayoutRect(startPoint, FloatSize(0, selHeight));
 843         font.adjustSelectionRectForText(run, selectionRect, startPosition, endPosition);
 844         IntRect markerRect = enclosingIntRect(selectionRect);
 845         start = markerRect.x() - startPoint.x();
 846         width = markerRect.width();
 847     }
 848
 849     // IMPORTANT: The misspelling underline is not considered when calculating the text bounds, so we have to
 850     // make sure to fit within those bounds.  This means the top pixel(s) of the underline will overlap the
 851     // bottom pixel(s) of the glyphs in smaller font sizes.  The alternatives are to increase the line spacing (bad!!)
 852     // or decrease the underline thickness.  The overlap is actually the most useful, and matches what AppKit does.
 853     // So, we generally place the underline at the bottom of the text, but in larger fonts that's not so good so
 854     // we pin to two pixels under the baseline.
 855     int lineThickness = cMisspellingLineThickness;
 856     int baseline = lineStyle().fontMetrics().ascent();
 857     int descent = logicalHeight() - baseline;
 858     int underlineOffset;
 859     if (descent <= (2 + lineThickness)) {
 860         // Place the underline at the very bottom of the text in small/medium fonts.
 861         underlineOffset = logicalHeight() - lineThickness;
 862     } else {
 863         // In larger fonts, though, place the underline up near the baseline to prevent a big gap.
 864         underlineOffset = baseline + 2;
 865     }
 866     context.drawLineForDocumentMarker(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + underlineOffset), width, lineStyleForMarkerType(marker.type()));
 867 }
 868
 869 void InlineTextBox::paintTextMatchMarker(GraphicsContext& context, const FloatPoint& boxOrigin, RenderedDocumentMarker& marker, const RenderStyle& style, const FontCascade& font)
 870 {
 871     if (!renderer().frame().editor().markedTextMatchesAreHighlighted())
 872         return;
 873
 874     Color color = marker.isActiveMatch() ? renderer().theme().platformActiveTextSearchHighlightColor() : renderer().theme().platformInactiveTextSearchHighlightColor();
 875     GraphicsContextStateSaver stateSaver(context);
 876     updateGraphicsContext(context, TextPaintStyle(color)); // Don't draw text at all!
 877
 878     // Use same y positioning and height as for selection, so that when the selection and this highlight are on
 879     // the same word there are no pieces sticking out.
 880     LayoutUnit deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom() - logicalBottom() : logicalTop() - selectionTop();
 881     LayoutRect selectionRect = LayoutRect(boxOrigin.x(), boxOrigin.y() - deltaY, 0, this->selectionHeight());
 882
 883     unsigned sPos = clampedOffset(marker.startOffset());
 884     unsigned ePos = clampedOffset(marker.endOffset());
 885     TextRun run = constructTextRun(style);
 886     font.adjustSelectionRectForText(run, selectionRect, sPos, ePos);
 887
 888     if (selectionRect.isEmpty())
 889         return;
 890
 891     context.fillRect(snapRectToDevicePixelsWithWritingDirection(selectionRect, renderer().document().deviceScaleFactor(), run.ltr()), color);
 892 }
 893
 894 void InlineTextBox::paintDocumentMarkers(GraphicsContext& context, const FloatPoint& boxOrigin, const RenderStyle& style, const FontCascade& font, bool background)
 895 {
 896     if (!renderer().textNode())
 897         return;
 898
 899     Vector<RenderedDocumentMarker*> markers = renderer().document().markers().markersFor(renderer().textNode());
 900
 901     // Give any document markers that touch this run a chance to draw before the text has been drawn.
 902     // Note end() points at the last char, not one past it like endOffset and ranges do.
 903     for (auto* marker : markers) {
 904         // Paint either the background markers or the foreground markers, but not both
 905         switch (marker->type()) {
 906             case DocumentMarker::Grammar:
 907             case DocumentMarker::Spelling:
 908             case DocumentMarker::CorrectionIndicator:
 909             case DocumentMarker::Replacement:
 910             case DocumentMarker::DictationAlternatives:
 911 #if PLATFORM(IOS)
 912             // FIXME: Remove the PLATFORM(IOS)-guard.
 913             case DocumentMarker::DictationPhraseWithAlternatives:
 914 #endif
 915                 if (background)
 916                     continue;
 917                 break;
 918             case DocumentMarker::TextMatch:
 919 #if ENABLE(TELEPHONE_NUMBER_DETECTION)
 920             case DocumentMarker::TelephoneNumber:
 921 #endif
 922                 if (!background)
 923                     continue;
 924                 break;
 925             default:
 926                 continue;
 927         }
 928
 929         if (marker->endOffset() <= start())
 930             // marker is completely before this run.  This might be a marker that sits before the
 931             // first run we draw, or markers that were within runs we skipped due to truncation.
 932             continue;
 933
 934         if (marker->startOffset() > end())
 935             // marker is completely after this run, bail.  A later run will paint it.
 936             break;
 937
 938         // marker intersects this run.  Paint it.
 939         switch (marker->type()) {
 940             case DocumentMarker::Spelling:
 941             case DocumentMarker::CorrectionIndicator:
 942             case DocumentMarker::DictationAlternatives:
 943                 paintDocumentMarker(context, boxOrigin, *marker, style, font, false);
 944                 break;
 945             case DocumentMarker::Grammar:
 946                 paintDocumentMarker(context, boxOrigin, *marker, style, font, true);
 947                 break;
 948 #if PLATFORM(IOS)
 949             // FIXME: See <rdar://problem/8933352>. Also, remove the PLATFORM(IOS)-guard.
 950             case DocumentMarker::DictationPhraseWithAlternatives:
 951                 paintDocumentMarker(context, boxOrigin, *marker, style, font, true);
 952                 break;
 953 #endif
 954             case DocumentMarker::TextMatch:
 955                 paintTextMatchMarker(context, boxOrigin, *marker, style, font);
 956                 break;
 957             case DocumentMarker::Replacement:
 958                 break;
 959 #if ENABLE(TELEPHONE_NUMBER_DETECTION)
 960             case DocumentMarker::TelephoneNumber:
 961                 break;
 962 #endif
 963             default:
 964                 ASSERT_NOT_REACHED();
 965         }
 966
 967     }
 968 }
 969
 970 void InlineTextBox::paintCompositionUnderline(GraphicsContext& context, const FloatPoint& boxOrigin, const CompositionUnderline& underline)
 971 {
 972     if (m_truncation == cFullTruncation)
 973         return;
 974
 975     float start = 0; // start of line to draw, relative to tx
 976     float width = m_logicalWidth; // how much line to draw
 977     bool useWholeWidth = true;
 978     unsigned paintStart = m_start;
 979     unsigned paintEnd = end() + 1; // end points at the last char, not past it
 980     if (paintStart <= underline.startOffset) {
 981         paintStart = underline.startOffset;
 982         useWholeWidth = false;
 983         start = renderer().width(m_start, paintStart - m_start, textPos(), isFirstLine());
 984     }
 985     if (paintEnd != underline.endOffset) {      // end points at the last char, not past it
 986         paintEnd = std::min(paintEnd, (unsigned)underline.endOffset);
 987         useWholeWidth = false;
 988     }
 989     if (m_truncation != cNoTruncation) {
 990         paintEnd = std::min(paintEnd, (unsigned)m_start + m_truncation);
 991         useWholeWidth = false;
 992     }
 993     if (!useWholeWidth) {
 994         width = renderer().width(paintStart, paintEnd - paintStart, textPos() + start, isFirstLine());
 995         mirrorRTLSegment(m_logicalWidth, direction(), start, width);
 996     }
 997
 998     // Thick marked text underlines are 2px thick as long as there is room for the 2px line under the baseline.
 999     // All other marked text underlines are 1px thick.
1000     // If there's not enough space the underline will touch or overlap characters.
1001     int lineThickness = 1;
1002     int baseline = lineStyle().fontMetrics().ascent();
1003     if (underline.thick && logicalHeight() - baseline >= 2)
1004         lineThickness = 2;
1005
1006     // We need to have some space between underlines of subsequent clauses, because some input methods do not use different underline styles for those.
1007     // We make each line shorter, which has a harmless side effect of shortening the first and last clauses, too.
1008     start += 1;
1009     width -= 2;
1010
1011     context.setStrokeColor(underline.compositionUnderlineColor == CompositionUnderlineColor::TextColor ? renderer().style().visitedDependentColor(CSSPropertyWebkitTextFillColor) : underline.color);
1012     context.setStrokeThickness(lineThickness);
1013     context.drawLineForText(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + logicalHeight() - lineThickness), width, renderer().document().printing());
1014 }
1015
1016 int InlineTextBox::caretMinOffset() const
1017 {
1018     return m_start;
1019 }
1020
1021 int InlineTextBox::caretMaxOffset() const
1022 {
1023     return m_start + m_len;
1024 }
1025
1026 float InlineTextBox::textPos() const
1027 {
1028     // When computing the width of a text run, RenderBlock::computeInlineDirectionPositionsForLine() doesn't include the actual offset
1029     // from the containing block edge in its measurement. textPos() should be consistent so the text are rendered in the same width.
1030     if (logicalLeft() == 0)
1031         return 0;
1032     return logicalLeft() - root().logicalLeft();
1033 }
1034
1035 int InlineTextBox::offsetForPosition(float lineOffset, bool includePartialGlyphs) const
1036 {
1037     if (isLineBreak())
1038         return 0;
1039
1040     if (lineOffset - logicalLeft() > logicalWidth())
1041         return isLeftToRightDirection() ? len() : 0;
1042     if (lineOffset - logicalLeft() < 0)
1043         return isLeftToRightDirection() ? 0 : len();
1044
1045     const RenderStyle& lineStyle = this->lineStyle();
1046     const FontCascade& font = fontToUse(lineStyle, renderer());
1047     return font.offsetForPosition(constructTextRun(lineStyle), lineOffset - logicalLeft(), includePartialGlyphs);
1048 }
1049
1050 float InlineTextBox::positionForOffset(unsigned offset) const
1051 {
1052     ASSERT(offset >= m_start);
1053     ASSERT(offset <= m_start + len());
1054
1055     if (isLineBreak())
1056         return logicalLeft();
1057
1058     const RenderStyle& lineStyle = this->lineStyle();
1059     const FontCascade& font = fontToUse(lineStyle, renderer());
1060     unsigned from = !isLeftToRightDirection() ? clampedOffset(offset) : 0;
1061     unsigned to = !isLeftToRightDirection() ? m_len : clampedOffset(offset);
1062     // FIXME: Do we need to add rightBearing here?
1063     LayoutRect selectionRect = LayoutRect(logicalLeft(), 0, 0, 0);
1064     TextRun run = constructTextRun(lineStyle);
1065     font.adjustSelectionRectForText(run, selectionRect, from, to);
1066     return snapRectToDevicePixelsWithWritingDirection(selectionRect, renderer().document().deviceScaleFactor(), run.ltr()).maxX();
1067 }
1068
1069 StringView InlineTextBox::substringToRender(std::optional<unsigned> overridingLength) const
1070 {
1071     return StringView(renderer().text()).substring(start(), overridingLength.value_or(len()));
1072 }
1073
1074 String InlineTextBox::hyphenatedStringForTextRun(const RenderStyle& style, std::optional<unsigned> alternateLength) const
1075 {
1076     ASSERT(hasHyphen());
1077     return makeString(substringToRender(alternateLength), style.hyphenString());
1078 }
1079
1080 TextRun InlineTextBox::constructTextRun(const RenderStyle& style, StringView alternateStringToRender, std::optional<unsigned> alternateLength) const
1081 {
1082     if (alternateStringToRender.isNull())
1083         return constructTextRun(style, substringToRender(alternateLength), renderer().textLength() - start());
1084     return constructTextRun(style, alternateStringToRender, alternateStringToRender.length());
1085 }
1086
1087 TextRun InlineTextBox::constructTextRun(const RenderStyle& style, StringView string, unsigned maximumLength) const
1088 {
1089     ASSERT(maximumLength >= string.length());
1090
1091     TextRun run(string, textPos(), expansion(), expansionBehavior(), direction(), dirOverride() || style.rtlOrdering() == VisualOrder, !renderer().canUseSimpleFontCodePath());
1092     run.setTabSize(!style.collapseWhiteSpace(), style.tabSize());
1093
1094     // Propagate the maximum length of the characters buffer to the TextRun, even when we're only processing a substring.
1095     run.setCharactersLength(maximumLength);
1096     ASSERT(run.charactersLength() >= run.length());
1097     return run;
1098 }
1099
1100 ExpansionBehavior InlineTextBox::expansionBehavior() const
1101 {
1102     ExpansionBehavior leadingBehavior;
1103     if (forceLeadingExpansion())
1104         leadingBehavior = ForceLeadingExpansion;
1105     else if (canHaveLeadingExpansion())
1106         leadingBehavior = AllowLeadingExpansion;
1107     else
1108         leadingBehavior = ForbidLeadingExpansion;
1109
1110     ExpansionBehavior trailingBehavior;
1111     if (forceTrailingExpansion())
1112         trailingBehavior = ForceTrailingExpansion;
1113     else if (expansion() && nextLeafChild() && !nextLeafChild()->isLineBreak())
1114         trailingBehavior = AllowTrailingExpansion;
1115     else
1116         trailingBehavior = ForbidTrailingExpansion;
1117
1118     return leadingBehavior | trailingBehavior;
1119 }
1120
1121 #if ENABLE(TREE_DEBUGGING)
1122
1123 const char* InlineTextBox::boxName() const
1124 {
1125     return "InlineTextBox";
1126 }
1127
1128 void InlineTextBox::outputLineBox(TextStream& stream, bool mark, int depth) const
1129 {
1130     stream << "-------- " << (isDirty() ? "D" : "-") << "-";
1131
1132     int printedCharacters = 0;
1133     if (mark) {
1134         stream << "*";
1135         ++printedCharacters;
1136     }
1137     while (++printedCharacters <= depth * 2)
1138         stream << " ";
1139
1140     String value = renderer().text();
1141     value = value.substring(start(), len());
1142     value.replaceWithLiteral('\\', "\\\\");
1143     value.replaceWithLiteral('\n', "\\n");
1144     stream << boxName() << " " << FloatRect(x(), y(), width(), height()) << " (" << this << ") renderer->(" << &renderer() << ") run(" << start() << ", " << start() + len() << ") \"" << value.utf8().data() << "\"";
1145     stream.nextLine();
1146 }
1147
1148 #endif
1149
1150 } // namespace WebCore