857cace8a4521b700dcfeabf59a68d0e75c97734
[WebKit-https.git] / 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, 2005, 2006, 2007, 2008, 2009, 2010, 2011 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 "Chrome.h"
27 #include "ChromeClient.h"
28 #include "DashArray.h"
29 #include "Document.h"
30 #include "DocumentMarkerController.h"
31 #include "Editor.h"
32 #include "EllipsisBox.h"
33 #include "FontCache.h"
34 #include "Frame.h"
35 #include "GraphicsContext.h"
36 #include "HitTestResult.h"
37 #include "ImageBuffer.h"
38 #include "Page.h"
39 #include "PaintInfo.h"
40 #include "RenderedDocumentMarker.h"
41 #include "RenderBlock.h"
42 #include "RenderCombineText.h"
43 #include "RenderLineBreak.h"
44 #include "RenderRubyRun.h"
45 #include "RenderRubyText.h"
46 #include "RenderTheme.h"
47 #include "RenderView.h"
48 #include "Settings.h"
49 #include "SVGTextRunRenderingContext.h"
50 #include "Text.h"
51 #include "TextPaintStyle.h"
52 #include "TextPainter.h"
53 #include "break_lines.h"
54 #include <wtf/text/CString.h>
55
56 namespace WebCore {
57
58 struct SameSizeAsInlineTextBox : public InlineBox {
59     unsigned variables[1];
60     unsigned short variables2[2];
61     void* pointers[2];
62 };
63
64 COMPILE_ASSERT(sizeof(InlineTextBox) == sizeof(SameSizeAsInlineTextBox), InlineTextBox_should_stay_small);
65
66 typedef WTF::HashMap<const InlineTextBox*, LayoutRect> InlineTextBoxOverflowMap;
67 static InlineTextBoxOverflowMap* gTextBoxesWithOverflow;
68
69 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
70 static bool compareTuples(std::pair<float, float> l, std::pair<float, float> r)
71 {
72     return l.first < r.first;
73 }
74
75 static DashArray translateIntersectionPointsToSkipInkBoundaries(const DashArray& intersections, float dilationAmount, float totalWidth)
76 {
77     ASSERT(!(intersections.size() % 2));
78     
79     // Step 1: Make pairs so we can sort based on range starting-point. We dilate the ranges in this step as well.
80     Vector<std::pair<float, float>> tuples;
81     for (auto i = intersections.begin(); i != intersections.end(); i++, i++)
82         tuples.append(std::make_pair(*i - dilationAmount, *(i + 1) + dilationAmount));
83     std::sort(tuples.begin(), tuples.end(), &compareTuples);
84
85     // Step 2: Deal with intersecting ranges.
86     Vector<std::pair<float, float>> intermediateTuples;
87     if (tuples.size() >= 2) {
88         intermediateTuples.append(*tuples.begin());
89         for (auto i = tuples.begin() + 1; i != tuples.end(); i++) {
90             float& firstEnd = intermediateTuples.last().second;
91             float secondStart = i->first;
92             float secondEnd = i->second;
93             if (secondStart <= firstEnd && secondEnd <= firstEnd) {
94                 // Ignore this range completely
95             } else if (secondStart <= firstEnd)
96                 firstEnd = secondEnd;
97             else
98                 intermediateTuples.append(*i);
99         }
100     } else
101         intermediateTuples = tuples;
102
103     // Step 3: Output the space between the ranges, but only if the space warrants an underline.
104     float previous = 0;
105     DashArray result;
106     for (auto i = intermediateTuples.begin(); i != intermediateTuples.end(); i++) {
107         if (i->first - previous > dilationAmount) {
108             result.append(previous);
109             result.append(i->first);
110         }
111         previous = i->second;
112     }
113     if (totalWidth - previous > dilationAmount) {
114         result.append(previous);
115         result.append(totalWidth);
116     }
117     
118     return result;
119 }
120
121 static void drawSkipInkUnderline(TextPainter& textPainter, GraphicsContext& context, FloatPoint localOrigin, float underlineOffset, float width, bool isPrinting, int m_start, int m_len)
122 {
123     FloatPoint adjustedLocalOrigin = localOrigin;
124     adjustedLocalOrigin.move(0, underlineOffset);
125     FloatRect underlineBoundingBox = context.computeLineBoundsForText(adjustedLocalOrigin, width, isPrinting);
126     DashArray intersections = textPainter.dashesForIntersectionsWithRect(underlineBoundingBox, m_start, m_start + m_len);
127     DashArray a = translateIntersectionPointsToSkipInkBoundaries(intersections, underlineBoundingBox.height(), width);
128
129     ASSERT(!(a.size() % 2));
130     for (auto i = a.begin(); i != a.end(); i++, i++)
131         context.drawLineForText(FloatPoint(localOrigin.x() + *i, localOrigin.y() + underlineOffset), *(i+1) - *i, isPrinting);
132 }
133 #endif
134
135 InlineTextBox::~InlineTextBox()
136 {
137     if (!knownToHaveNoOverflow() && gTextBoxesWithOverflow)
138         gTextBoxesWithOverflow->remove(this);
139 }
140
141 void InlineTextBox::markDirty(bool dirty)
142 {
143     if (dirty) {
144         m_len = 0;
145         m_start = 0;
146     }
147     InlineBox::markDirty(dirty);
148 }
149
150 LayoutRect InlineTextBox::logicalOverflowRect() const
151 {
152     if (knownToHaveNoOverflow() || !gTextBoxesWithOverflow)
153         return enclosingIntRect(logicalFrameRect());
154     return gTextBoxesWithOverflow->get(this);
155 }
156
157 void InlineTextBox::setLogicalOverflowRect(const LayoutRect& rect)
158 {
159     ASSERT(!knownToHaveNoOverflow());
160     if (!gTextBoxesWithOverflow)
161         gTextBoxesWithOverflow = new InlineTextBoxOverflowMap;
162     gTextBoxesWithOverflow->add(this, rect);
163 }
164
165 int InlineTextBox::baselinePosition(FontBaseline baselineType) const
166 {
167     if (!parent())
168         return 0;
169     if (&parent()->renderer() == renderer().parent())
170         return parent()->baselinePosition(baselineType);
171     return toRenderBoxModelObject(renderer().parent())->baselinePosition(baselineType, isFirstLine(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
172 }
173
174 LayoutUnit InlineTextBox::lineHeight() const
175 {
176     if (!renderer().parent())
177         return 0;
178     if (&parent()->renderer() == renderer().parent())
179         return parent()->lineHeight();
180     return toRenderBoxModelObject(renderer().parent())->lineHeight(isFirstLine(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
181 }
182
183 LayoutUnit InlineTextBox::selectionTop() const
184 {
185     return root().selectionTop();
186 }
187
188 LayoutUnit InlineTextBox::selectionBottom() const
189 {
190     return root().selectionBottom();
191 }
192
193 LayoutUnit InlineTextBox::selectionHeight() const
194 {
195     return root().selectionHeight();
196 }
197
198 bool InlineTextBox::isSelected(int startPos, int endPos) const
199 {
200     LayoutUnit sPos = std::max<LayoutUnit>(startPos - m_start, 0);
201     LayoutUnit ePos = std::min<LayoutUnit>(endPos - m_start, m_len);
202     return (sPos < ePos);
203 }
204
205 RenderObject::SelectionState InlineTextBox::selectionState()
206 {
207     RenderObject::SelectionState state = renderer().selectionState();
208     if (state == RenderObject::SelectionStart || state == RenderObject::SelectionEnd || state == RenderObject::SelectionBoth) {
209         int startPos, endPos;
210         renderer().selectionStartEnd(startPos, endPos);
211         // The position after a hard line break is considered to be past its end.
212         int lastSelectable = start() + len() - (isLineBreak() ? 1 : 0);
213
214         bool start = (state != RenderObject::SelectionEnd && startPos >= m_start && startPos < m_start + m_len);
215         bool end = (state != RenderObject::SelectionStart && endPos > m_start && endPos <= lastSelectable);
216         if (start && end)
217             state = RenderObject::SelectionBoth;
218         else if (start)
219             state = RenderObject::SelectionStart;
220         else if (end)
221             state = RenderObject::SelectionEnd;
222         else if ((state == RenderObject::SelectionEnd || startPos < m_start) &&
223                  (state == RenderObject::SelectionStart || endPos > lastSelectable))
224             state = RenderObject::SelectionInside;
225         else if (state == RenderObject::SelectionBoth)
226             state = RenderObject::SelectionNone;
227     }
228
229     // If there are ellipsis following, make sure their selection is updated.
230     if (m_truncation != cNoTruncation && root().ellipsisBox()) {
231         EllipsisBox* ellipsis = root().ellipsisBox();
232         if (state != RenderObject::SelectionNone) {
233             int start, end;
234             selectionStartEnd(start, end);
235             // The ellipsis should be considered to be selected if the end of
236             // the selection is past the beginning of the truncation and the
237             // beginning of the selection is before or at the beginning of the
238             // truncation.
239             ellipsis->setSelectionState(end >= m_truncation && start <= m_truncation ?
240                 RenderObject::SelectionInside : RenderObject::SelectionNone);
241         } else
242             ellipsis->setSelectionState(RenderObject::SelectionNone);
243     }
244
245     return state;
246 }
247
248 static void adjustCharactersAndLengthForHyphen(BufferForAppendingHyphen& charactersWithHyphen, const RenderStyle& style, String& string, int& length)
249 {
250     const AtomicString& hyphenString = style.hyphenString();
251     charactersWithHyphen.reserveCapacity(length + hyphenString.length());
252     charactersWithHyphen.append(string);
253     charactersWithHyphen.append(hyphenString);
254     string = charactersWithHyphen.toString();
255     length += hyphenString.length();
256 }
257
258 static const Font& fontToUse(const RenderStyle& style, const RenderText& renderer)
259 {
260     if (style.hasTextCombine() && renderer.isCombineText()) {
261         const RenderCombineText& textCombineRenderer = toRenderCombineText(renderer);
262         if (textCombineRenderer.isCombined())
263             return textCombineRenderer.textCombineFont();
264     }
265     return style.font();
266 }
267
268 LayoutRect InlineTextBox::localSelectionRect(int startPos, int endPos) const
269 {
270     int sPos = std::max(startPos - m_start, 0);
271     int ePos = std::min(endPos - m_start, (int)m_len);
272     
273     if (sPos > ePos)
274         return LayoutRect();
275
276     FontCachePurgePreventer fontCachePurgePreventer;
277
278     LayoutUnit selTop = selectionTop();
279     LayoutUnit selHeight = selectionHeight();
280     const RenderStyle& lineStyle = this->lineStyle();
281     const Font& font = fontToUse(lineStyle, renderer());
282
283     BufferForAppendingHyphen charactersWithHyphen;
284     bool respectHyphen = ePos == m_len && hasHyphen();
285     TextRun textRun = constructTextRun(lineStyle, font, respectHyphen ? &charactersWithHyphen : 0);
286     if (respectHyphen)
287         endPos = textRun.length();
288
289     FloatPoint startingPoint = FloatPoint(logicalLeft(), selTop);
290     LayoutRect r;
291     if (sPos || ePos != static_cast<int>(m_len))
292         r = enclosingIntRect(font.selectionRectForText(textRun, startingPoint, selHeight, sPos, ePos));
293     else // Avoid computing the font width when the entire line box is selected as an optimization.
294         r = enclosingIntRect(FloatRect(startingPoint, FloatSize(m_logicalWidth, selHeight)));
295
296     LayoutUnit logicalWidth = r.width();
297     if (r.x() > logicalRight())
298         logicalWidth  = 0;
299     else if (r.maxX() > logicalRight())
300         logicalWidth = logicalRight() - r.x();
301
302     LayoutPoint topPoint = isHorizontal() ? LayoutPoint(r.x(), selTop) : LayoutPoint(selTop, r.x());
303     LayoutUnit width = isHorizontal() ? logicalWidth : selHeight;
304     LayoutUnit height = isHorizontal() ? selHeight : logicalWidth;
305
306     return LayoutRect(topPoint, LayoutSize(width, height));
307 }
308
309 void InlineTextBox::deleteLine()
310 {
311     renderer().removeTextBox(*this);
312     delete this;
313 }
314
315 void InlineTextBox::extractLine()
316 {
317     if (extracted())
318         return;
319
320     renderer().extractTextBox(*this);
321 }
322
323 void InlineTextBox::attachLine()
324 {
325     if (!extracted())
326         return;
327     
328     renderer().attachTextBox(*this);
329 }
330
331 float InlineTextBox::placeEllipsisBox(bool flowIsLTR, float visibleLeftEdge, float visibleRightEdge, float ellipsisWidth, float &truncatedWidth, bool& foundBox)
332 {
333     if (foundBox) {
334         m_truncation = cFullTruncation;
335         return -1;
336     }
337
338     // For LTR this is the left edge of the box, for RTL, the right edge in parent coordinates.
339     float ellipsisX = flowIsLTR ? visibleRightEdge - ellipsisWidth : visibleLeftEdge + ellipsisWidth;
340     
341     // Criteria for full truncation:
342     // LTR: the left edge of the ellipsis is to the left of our text run.
343     // RTL: the right edge of the ellipsis is to the right of our text run.
344     bool ltrFullTruncation = flowIsLTR && ellipsisX <= left();
345     bool rtlFullTruncation = !flowIsLTR && ellipsisX >= left() + logicalWidth();
346     if (ltrFullTruncation || rtlFullTruncation) {
347         // Too far.  Just set full truncation, but return -1 and let the ellipsis just be placed at the edge of the box.
348         m_truncation = cFullTruncation;
349         foundBox = true;
350         return -1;
351     }
352
353     bool ltrEllipsisWithinBox = flowIsLTR && (ellipsisX < right());
354     bool rtlEllipsisWithinBox = !flowIsLTR && (ellipsisX > left());
355     if (ltrEllipsisWithinBox || rtlEllipsisWithinBox) {
356         foundBox = true;
357
358         // The inline box may have different directionality than it's parent.  Since truncation
359         // behavior depends both on both the parent and the inline block's directionality, we
360         // must keep track of these separately.
361         bool ltr = isLeftToRightDirection();
362         if (ltr != flowIsLTR) {
363           // Width in pixels of the visible portion of the box, excluding the ellipsis.
364           int visibleBoxWidth = visibleRightEdge - visibleLeftEdge  - ellipsisWidth;
365           ellipsisX = ltr ? left() + visibleBoxWidth : right() - visibleBoxWidth;
366         }
367
368         int offset = offsetForPosition(ellipsisX, false);
369         if (offset == 0) {
370             // No characters should be rendered.  Set ourselves to full truncation and place the ellipsis at the min of our start
371             // and the ellipsis edge.
372             m_truncation = cFullTruncation;
373             truncatedWidth += ellipsisWidth;
374             return flowIsLTR ? std::min(ellipsisX, x()) : std::max(ellipsisX, right() - ellipsisWidth);
375         }
376
377         // Set the truncation index on the text run.
378         m_truncation = offset;
379
380         // If we got here that means that we were only partially truncated and we need to return the pixel offset at which
381         // to place the ellipsis.
382         float widthOfVisibleText = renderer().width(m_start, offset, textPos(), isFirstLine());
383
384         // The ellipsis needs to be placed just after the last visible character.
385         // Where "after" is defined by the flow directionality, not the inline
386         // box directionality.
387         // e.g. In the case of an LTR inline box truncated in an RTL flow then we can
388         // have a situation such as |Hello| -> |...He|
389         truncatedWidth += widthOfVisibleText + ellipsisWidth;
390         if (flowIsLTR)
391             return left() + widthOfVisibleText;
392         else
393             return right() - widthOfVisibleText - ellipsisWidth;
394     }
395     truncatedWidth += logicalWidth();
396     return -1;
397 }
398
399
400
401 bool InlineTextBox::isLineBreak() const
402 {
403     return renderer().style().preserveNewline() && len() == 1 && (*renderer().text())[start()] == '\n';
404 }
405
406 bool InlineTextBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit /* lineTop */, LayoutUnit /*lineBottom*/)
407 {
408     if (!visibleToHitTesting())
409         return false;
410
411     if (isLineBreak())
412         return false;
413
414     if (m_truncation == cFullTruncation)
415         return false;
416
417     FloatRect rect(locationIncludingFlipping(), size());
418     // Make sure truncated text is ignored while hittesting.
419     if (m_truncation != cNoTruncation) {
420         LayoutUnit widthOfVisibleText = renderer().width(m_start, m_truncation, textPos(), isFirstLine());
421
422         if (isHorizontal())
423             renderer().style().isLeftToRightDirection() ? rect.setWidth(widthOfVisibleText) : rect.shiftXEdgeTo(right() - widthOfVisibleText);
424         else
425             rect.setHeight(widthOfVisibleText);
426     }
427
428     rect.moveBy(accumulatedOffset);
429
430     if (locationInContainer.intersects(rect)) {
431         renderer().updateHitTestResult(result, flipForWritingMode(locationInContainer.point() - toLayoutSize(accumulatedOffset)));
432         if (!result.addNodeToRectBasedTestResult(renderer().textNode(), request, locationInContainer, rect))
433             return true;
434     }
435     return false;
436 }
437
438 FloatSize InlineTextBox::applyShadowToGraphicsContext(GraphicsContext* context, const ShadowData* shadow, const FloatRect& textRect, bool stroked, bool opaque, bool horizontal)
439 {
440     if (!shadow)
441         return FloatSize();
442
443     FloatSize extraOffset;
444     int shadowX = horizontal ? shadow->x() : shadow->y();
445     int shadowY = horizontal ? shadow->y() : -shadow->x();
446     FloatSize shadowOffset(shadowX, shadowY);
447     int shadowRadius = shadow->radius();
448     const Color& shadowColor = shadow->color();
449
450     if (shadow->next() || stroked || !opaque) {
451         FloatRect shadowRect(textRect);
452         shadowRect.inflate(shadow->paintingExtent());
453         shadowRect.move(shadowOffset);
454         context->save();
455         context->clip(shadowRect);
456
457         extraOffset = FloatSize(0, 2 * textRect.height() + std::max(0.0f, shadowOffset.height()) + shadowRadius);
458         shadowOffset -= extraOffset;
459     }
460
461     context->setShadow(shadowOffset, shadowRadius, shadowColor, context->fillColorSpace());
462     return extraOffset;
463 }
464
465 bool InlineTextBox::getEmphasisMarkPosition(const RenderStyle& style, TextEmphasisPosition& emphasisPosition) const
466 {
467     // This function returns true if there are text emphasis marks and they are suppressed by ruby text.
468     if (style.textEmphasisMark() == TextEmphasisMarkNone)
469         return false;
470
471     emphasisPosition = style.textEmphasisPosition();
472     if (emphasisPosition == TextEmphasisPositionUnder)
473         return true; // Ruby text is always over, so it cannot suppress emphasis marks under.
474
475     RenderBlock* containingBlock = renderer().containingBlock();
476     if (!containingBlock->isRubyBase())
477         return true; // This text is not inside a ruby base, so it does not have ruby text over it.
478
479     if (!containingBlock->parent()->isRubyRun())
480         return true; // Cannot get the ruby text.
481
482     RenderRubyText* rubyText = toRenderRubyRun(containingBlock->parent())->rubyText();
483
484     // The emphasis marks over are suppressed only if there is a ruby text box and it not empty.
485     return !rubyText || !rubyText->hasLines();
486 }
487
488 void InlineTextBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /*lineTop*/, LayoutUnit /*lineBottom*/)
489 {
490     if (isLineBreak() || !paintInfo.shouldPaintWithinRoot(renderer()) || renderer().style().visibility() != VISIBLE
491         || m_truncation == cFullTruncation || paintInfo.phase == PaintPhaseOutline || !m_len)
492         return;
493
494     ASSERT(paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines);
495
496     LayoutUnit logicalLeftSide = logicalLeftVisualOverflow();
497     LayoutUnit logicalRightSide = logicalRightVisualOverflow();
498     LayoutUnit logicalStart = logicalLeftSide + (isHorizontal() ? paintOffset.x() : paintOffset.y());
499     LayoutUnit logicalExtent = logicalRightSide - logicalLeftSide;
500     
501     LayoutUnit paintEnd = isHorizontal() ? paintInfo.rect.maxX() : paintInfo.rect.maxY();
502     LayoutUnit paintStart = isHorizontal() ? paintInfo.rect.x() : paintInfo.rect.y();
503     
504     LayoutPoint adjustedPaintOffset = roundedIntPoint(paintOffset);
505     
506     if (logicalStart >= paintEnd || logicalStart + logicalExtent <= paintStart)
507         return;
508
509     bool isPrinting = renderer().document().printing();
510     
511     // Determine whether or not we're selected.
512     bool haveSelection = !isPrinting && paintInfo.phase != PaintPhaseTextClip && selectionState() != RenderObject::SelectionNone;
513     if (!haveSelection && paintInfo.phase == PaintPhaseSelection)
514         // When only painting the selection, don't bother to paint if there is none.
515         return;
516
517     if (m_truncation != cNoTruncation) {
518         if (renderer().containingBlock()->style().isLeftToRightDirection() != isLeftToRightDirection()) {
519             // Make the visible fragment of text hug the edge closest to the rest of the run by moving the origin
520             // at which we start drawing text.
521             // e.g. In the case of LTR text truncated in an RTL Context, the correct behavior is:
522             // |Hello|CBA| -> |...He|CBA|
523             // In order to draw the fragment "He" aligned to the right edge of it's box, we need to start drawing
524             // farther to the right.
525             // NOTE: WebKit's behavior differs from that of IE which appears to just overlay the ellipsis on top of the
526             // truncated string i.e.  |Hello|CBA| -> |...lo|CBA|
527             LayoutUnit widthOfVisibleText = renderer().width(m_start, m_truncation, textPos(), isFirstLine());
528             LayoutUnit widthOfHiddenText = m_logicalWidth - widthOfVisibleText;
529             LayoutSize truncationOffset(isLeftToRightDirection() ? widthOfHiddenText : -widthOfHiddenText, 0);
530             adjustedPaintOffset.move(isHorizontal() ? truncationOffset : truncationOffset.transposedSize());
531         }
532     }
533
534     GraphicsContext* context = paintInfo.context;
535
536     const RenderStyle& lineStyle = this->lineStyle();
537     
538     adjustedPaintOffset.move(0, lineStyle.isHorizontalWritingMode() ? 0 : -logicalHeight());
539
540     FloatPoint boxOrigin = locationIncludingFlipping();
541     boxOrigin.move(adjustedPaintOffset.x(), adjustedPaintOffset.y());
542     FloatRect boxRect(boxOrigin, FloatSize(logicalWidth(), logicalHeight()));
543
544     RenderCombineText* combinedText = lineStyle.hasTextCombine() && renderer().isCombineText() && toRenderCombineText(renderer()).isCombined() ? &toRenderCombineText(renderer()) : 0;
545
546     bool shouldRotate = !isHorizontal() && !combinedText;
547     if (shouldRotate)
548         context->concatCTM(rotation(boxRect, Clockwise));
549
550     // Determine whether or not we have composition underlines to draw.
551     bool containsComposition = renderer().textNode() && renderer().frame().editor().compositionNode() == renderer().textNode();
552     bool useCustomUnderlines = containsComposition && renderer().frame().editor().compositionUsesCustomUnderlines();
553
554     // Determine the text colors and selection colors.
555     TextPaintStyle textPaintStyle = computeTextPaintStyle(renderer(), lineStyle, paintInfo);
556
557     bool paintSelectedTextOnly;
558     bool paintSelectedTextSeparately;
559     const ShadowData* selectionShadow;
560     TextPaintStyle selectionPaintStyle = computeTextSelectionPaintStyle(textPaintStyle, renderer(), lineStyle, paintInfo, paintSelectedTextOnly, paintSelectedTextSeparately, selectionShadow);
561
562     // Set our font.
563     const Font& font = fontToUse(lineStyle, renderer());
564
565     FloatPoint textOrigin = FloatPoint(boxOrigin.x(), boxOrigin.y() + font.fontMetrics().ascent());
566
567     if (combinedText)
568         combinedText->adjustTextOrigin(textOrigin, boxRect);
569
570     // 1. Paint backgrounds behind text if needed. Examples of such backgrounds include selection
571     // and composition underlines.
572     if (paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseTextClip && !isPrinting) {
573 #if PLATFORM(MAC)
574         // Custom highlighters go behind everything else.
575         if (lineStyle.highlight() != nullAtom && !context->paintingDisabled())
576             paintCustomHighlight(adjustedPaintOffset, lineStyle.highlight());
577 #endif
578
579         if (containsComposition && !useCustomUnderlines)
580             paintCompositionBackground(context, boxOrigin, lineStyle, font,
581                 renderer().frame().editor().compositionStart(),
582                 renderer().frame().editor().compositionEnd());
583
584         paintDocumentMarkers(context, boxOrigin, lineStyle, font, true);
585
586         if (haveSelection && !useCustomUnderlines)
587             paintSelection(context, boxOrigin, lineStyle, font, selectionPaintStyle.fillColor);
588     }
589
590     if (Page* page = renderer().frame().page()) {
591         // FIXME: Right now, InlineTextBoxes never call addRelevantUnpaintedObject() even though they might
592         // legitimately be unpainted if they are waiting on a slow-loading web font. We should fix that, and
593         // when we do, we will have to account for the fact the InlineTextBoxes do not always have unique
594         // renderers and Page currently relies on each unpainted object having a unique renderer.
595         if (paintInfo.phase == PaintPhaseForeground)
596             page->addRelevantRepaintedObject(&renderer(), IntRect(boxOrigin.x(), boxOrigin.y(), logicalWidth(), logicalHeight()));
597     }
598
599     // 2. Now paint the foreground, including text and decorations like underline/overline (in quirks mode only).
600     int length = m_len;
601     int maximumLength;
602     String string;
603     if (!combinedText) {
604         string = renderer().text();
605         if (static_cast<unsigned>(length) != string.length() || m_start) {
606             ASSERT_WITH_SECURITY_IMPLICATION(static_cast<unsigned>(m_start + length) <= string.length());
607             string = string.substringSharingImpl(m_start, length);
608         }
609         maximumLength = renderer().textLength() - m_start;
610     } else {
611         combinedText->getStringToRender(m_start, string, length);
612         maximumLength = length;
613     }
614
615     BufferForAppendingHyphen charactersWithHyphen;
616     TextRun textRun = constructTextRun(lineStyle, font, string, maximumLength, hasHyphen() ? &charactersWithHyphen : 0);
617     if (hasHyphen())
618         length = textRun.length();
619
620     int sPos = 0;
621     int ePos = 0;
622     if (haveSelection && (paintSelectedTextOnly || paintSelectedTextSeparately))
623         selectionStartEnd(sPos, ePos);
624
625     if (m_truncation != cNoTruncation) {
626         sPos = std::min<int>(sPos, m_truncation);
627         ePos = std::min<int>(ePos, m_truncation);
628         length = m_truncation;
629     }
630
631     int emphasisMarkOffset = 0;
632     TextEmphasisPosition emphasisMarkPosition;
633     bool hasTextEmphasis = getEmphasisMarkPosition(lineStyle, emphasisMarkPosition);
634     const AtomicString& emphasisMark = hasTextEmphasis ? lineStyle.textEmphasisMarkString() : nullAtom;
635     if (!emphasisMark.isEmpty())
636         emphasisMarkOffset = emphasisMarkPosition == TextEmphasisPositionOver ? -font.fontMetrics().ascent() - font.emphasisMarkDescent(emphasisMark) : font.fontMetrics().descent() + font.emphasisMarkAscent(emphasisMark);
637
638     const ShadowData* textShadow = paintInfo.forceBlackText() ? 0 : lineStyle.textShadow();
639
640     TextPainter textPainter(*context, paintSelectedTextOnly, paintSelectedTextSeparately, font, sPos, ePos, length, emphasisMark, combinedText, textRun, boxRect, textOrigin, emphasisMarkOffset, textShadow, selectionShadow, isHorizontal(), textPaintStyle, selectionPaintStyle);
641     textPainter.paintText();
642
643     // Paint decorations
644     TextDecoration textDecorations = lineStyle.textDecorationsInEffect();
645     if (textDecorations != TextDecorationNone && paintInfo.phase != PaintPhaseSelection) {
646         updateGraphicsContext(*context, textPaintStyle);
647         if (combinedText)
648             context->concatCTM(rotation(boxRect, Clockwise));
649         paintDecoration(*context, boxOrigin, textDecorations, lineStyle.textDecorationStyle(), textShadow, textPainter);
650         if (combinedText)
651             context->concatCTM(rotation(boxRect, Counterclockwise));
652     }
653
654     if (paintInfo.phase == PaintPhaseForeground) {
655         paintDocumentMarkers(context, boxOrigin, lineStyle, font, false);
656
657         if (useCustomUnderlines) {
658             const Vector<CompositionUnderline>& underlines = renderer().frame().editor().customCompositionUnderlines();
659             size_t numUnderlines = underlines.size();
660
661             for (size_t index = 0; index < numUnderlines; ++index) {
662                 const CompositionUnderline& underline = underlines[index];
663
664                 if (underline.endOffset <= start())
665                     // underline is completely before this run.  This might be an underline that sits
666                     // before the first run we draw, or underlines that were within runs we skipped 
667                     // due to truncation.
668                     continue;
669                 
670                 if (underline.startOffset <= end()) {
671                     // underline intersects this run.  Paint it.
672                     paintCompositionUnderline(context, boxOrigin, underline);
673                     if (underline.endOffset > end() + 1)
674                         // underline also runs into the next run. Bail now, no more marker advancement.
675                         break;
676                 } else
677                     // underline is completely after this run, bail.  A later run will paint it.
678                     break;
679             }
680         }
681     }
682     
683     if (shouldRotate)
684         context->concatCTM(rotation(boxRect, Counterclockwise));
685 }
686
687 void InlineTextBox::selectionStartEnd(int& sPos, int& ePos)
688 {
689     int startPos, endPos;
690     if (renderer().selectionState() == RenderObject::SelectionInside) {
691         startPos = 0;
692         endPos = renderer().textLength();
693     } else {
694         renderer().selectionStartEnd(startPos, endPos);
695         if (renderer().selectionState() == RenderObject::SelectionStart)
696             endPos = renderer().textLength();
697         else if (renderer().selectionState() == RenderObject::SelectionEnd)
698             startPos = 0;
699     }
700
701     sPos = std::max(startPos - m_start, 0);
702     ePos = std::min(endPos - m_start, (int)m_len);
703 }
704
705 void alignSelectionRectToDevicePixels(FloatRect& rect)
706 {
707     float maxX = floorf(rect.maxX());
708     rect.setX(floorf(rect.x()));
709     rect.setWidth(roundf(maxX - rect.x()));
710 }
711
712 void InlineTextBox::paintSelection(GraphicsContext* context, const FloatPoint& boxOrigin, const RenderStyle& style, const Font& font, Color textColor)
713 {
714 #if ENABLE(TEXT_SELECTION)
715     if (context->paintingDisabled())
716         return;
717
718     // See if we have a selection to paint at all.
719     int sPos, ePos;
720     selectionStartEnd(sPos, ePos);
721     if (sPos >= ePos)
722         return;
723
724     Color c = renderer().selectionBackgroundColor();
725     if (!c.isValid() || c.alpha() == 0)
726         return;
727
728     // If the text color ends up being the same as the selection background, invert the selection
729     // background.
730     if (textColor == c)
731         c = Color(0xff - c.red(), 0xff - c.green(), 0xff - c.blue());
732
733     GraphicsContextStateSaver stateSaver(*context);
734     updateGraphicsContext(*context, TextPaintStyle(c, style.colorSpace())); // Don't draw text at all!
735     
736     // If the text is truncated, let the thing being painted in the truncation
737     // draw its own highlight.
738     int length = m_truncation != cNoTruncation ? m_truncation : m_len;
739     String string = renderer().text();
740
741     if (string.length() != static_cast<unsigned>(length) || m_start) {
742         ASSERT_WITH_SECURITY_IMPLICATION(static_cast<unsigned>(m_start + length) <= string.length());
743         string = string.substringSharingImpl(m_start, length);
744     }
745
746     BufferForAppendingHyphen charactersWithHyphen;
747     bool respectHyphen = ePos == length && hasHyphen();
748     TextRun textRun = constructTextRun(style, font, string, renderer().textLength() - m_start, respectHyphen ? &charactersWithHyphen : 0);
749     if (respectHyphen)
750         ePos = textRun.length();
751
752     const RootInlineBox& rootBox = root();
753     LayoutUnit selectionBottom = rootBox.selectionBottom();
754     LayoutUnit selectionTop = rootBox.selectionTopAdjustedForPrecedingBlock();
755
756     int deltaY = roundToInt(renderer().style().isFlippedLinesWritingMode() ? selectionBottom - logicalBottom() : logicalTop() - selectionTop);
757     int selHeight = std::max(0, roundToInt(selectionBottom - selectionTop));
758
759     FloatPoint localOrigin(boxOrigin.x(), boxOrigin.y() - deltaY);
760     FloatRect clipRect(localOrigin, FloatSize(m_logicalWidth, selHeight));
761     alignSelectionRectToDevicePixels(clipRect);
762
763     context->clip(clipRect);
764
765     context->drawHighlightForText(font, textRun, localOrigin, selHeight, c, style.colorSpace(), sPos, ePos);
766 #else
767     UNUSED_PARAM(context);
768     UNUSED_PARAM(boxOrigin);
769     UNUSED_PARAM(style);
770     UNUSED_PARAM(font);
771     UNUSED_PARAM(textColor);
772 #endif
773 }
774
775 void InlineTextBox::paintCompositionBackground(GraphicsContext* context, const FloatPoint& boxOrigin, const RenderStyle& style, const Font& font, int startPos, int endPos)
776 {
777     int offset = m_start;
778     int sPos = std::max(startPos - offset, 0);
779     int ePos = std::min(endPos - offset, (int)m_len);
780
781     if (sPos >= ePos)
782         return;
783
784     GraphicsContextStateSaver stateSaver(*context);
785
786 #if !PLATFORM(IOS)
787     // FIXME: Is this color still applicable as of Mavericks? for non-Mac ports? We should
788     // be able to move this color information to RenderStyle.
789     Color c = Color(225, 221, 85);
790 #else
791     Color c = style.compositionFillColor();
792 #endif
793     
794     updateGraphicsContext(*context, TextPaintStyle(c, style.colorSpace())); // Don't draw text at all!
795
796     int deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom() - logicalBottom() : logicalTop() - selectionTop();
797     int selHeight = selectionHeight();
798     FloatPoint localOrigin(boxOrigin.x(), boxOrigin.y() - deltaY);
799     context->drawHighlightForText(font, constructTextRun(style, font), localOrigin, selHeight, c, style.colorSpace(), sPos, ePos);
800 }
801
802 #if PLATFORM(MAC)
803
804 void InlineTextBox::paintCustomHighlight(const LayoutPoint& paintOffset, const AtomicString& type)
805 {
806     Page* page = renderer().frame().page();
807     if (!page)
808         return;
809
810     const RootInlineBox& rootBox = root();
811     FloatRect rootRect(paintOffset.x() + rootBox.x(), paintOffset.y() + selectionTop(), rootBox.logicalWidth(), selectionHeight());
812     FloatRect textRect(paintOffset.x() + x(), rootRect.y(), logicalWidth(), rootRect.height());
813
814     page->chrome().client().paintCustomHighlight(renderer().textNode(), type, textRect, rootRect, true, false);
815 }
816
817 #endif
818
819 static StrokeStyle textDecorationStyleToStrokeStyle(TextDecorationStyle decorationStyle)
820 {
821     StrokeStyle strokeStyle = SolidStroke;
822     switch (decorationStyle) {
823     case TextDecorationStyleSolid:
824         strokeStyle = SolidStroke;
825         break;
826 #if ENABLE(CSS3_TEXT_DECORATION)
827     case TextDecorationStyleDouble:
828         strokeStyle = DoubleStroke;
829         break;
830     case TextDecorationStyleDotted:
831         strokeStyle = DottedStroke;
832         break;
833     case TextDecorationStyleDashed:
834         strokeStyle = DashedStroke;
835         break;
836     case TextDecorationStyleWavy:
837         strokeStyle = WavyStroke;
838         break;
839 #endif // CSS3_TEXT_DECORATION
840     }
841
842     return strokeStyle;
843 }
844
845 #if ENABLE(CSS3_TEXT_DECORATION)
846 static int computeUnderlineOffset(const TextUnderlinePosition underlinePosition, const FontMetrics& fontMetrics, const InlineTextBox* inlineTextBox, const int textDecorationThickness)
847 {
848     // Compute the gap between the font and the underline. Use at least one
849     // pixel gap, if underline is thick then use a bigger gap.
850     const int gap = std::max<int>(1, ceilf(textDecorationThickness / 2.0));
851
852     // According to the specification TextUnderlinePositionAuto should default to 'alphabetic' for horizontal text
853     // and to 'under Left' for vertical text (e.g. japanese). We support only horizontal text for now.
854     switch (underlinePosition) {
855     case TextUnderlinePositionAlphabetic:
856     case TextUnderlinePositionAuto:
857         return fontMetrics.ascent() + gap; // Position underline near the alphabetic baseline.
858     case TextUnderlinePositionUnder: {
859         // Position underline relative to the under edge of the lowest element's content box.
860         const float offset = inlineTextBox->root().maxLogicalTop() - inlineTextBox->logicalTop();
861         return inlineTextBox->logicalHeight() + gap + std::max<float>(offset, 0);
862     }
863     }
864
865     ASSERT_NOT_REACHED();
866     return fontMetrics.ascent() + gap;
867 }
868
869 static void adjustStepToDecorationLength(float& step, float& controlPointDistance, float length)
870 {
871     ASSERT(step > 0);
872
873     if (length <= 0)
874         return;
875
876     unsigned stepCount = static_cast<unsigned>(length / step);
877
878     // Each Bezier curve starts at the same pixel that the previous one
879     // ended. We need to subtract (stepCount - 1) pixels when calculating the
880     // length covered to account for that.
881     float uncoveredLength = length - (stepCount * step - (stepCount - 1));
882     float adjustment = uncoveredLength / stepCount;
883     step += adjustment;
884     controlPointDistance += adjustment;
885 }
886
887 static void getWavyStrokeParameters(float strokeThickness, float& controlPointDistance, float& step)
888 {
889     // Distance between decoration's axis and Bezier curve's control points.
890     // The height of the curve is based on this distance. Use a minimum of 6 pixels distance since
891     // the actual curve passes approximately at half of that distance, that is 3 pixels.
892     // The minimum height of the curve is also approximately 3 pixels. Increases the curve's height
893     // as strockThickness increases to make the curve looks better.
894     controlPointDistance = 3 * std::max<float>(2, strokeThickness);
895
896     // Increment used to form the diamond shape between start point (p1), control
897     // points and end point (p2) along the axis of the decoration. Makes the
898     // curve wider as strockThickness increases to make the curve looks better.
899     step = 2 * std::max<float>(2, strokeThickness);
900 }
901
902 /*
903  * Draw one cubic Bezier curve and repeat the same pattern long the the decoration's axis.
904  * The start point (p1), controlPoint1, controlPoint2 and end point (p2) of the Bezier curve
905  * form a diamond shape:
906  *
907  *                              step
908  *                         |-----------|
909  *
910  *                   controlPoint1
911  *                         +
912  *
913  *
914  *                  . .
915  *                .     .
916  *              .         .
917  * (x1, y1) p1 +           .            + p2 (x2, y2) - <--- Decoration's axis
918  *                          .         .               |
919  *                            .     .                 |
920  *                              . .                   | controlPointDistance
921  *                                                    |
922  *                                                    |
923  *                         +                          -
924  *                   controlPoint2
925  *
926  *             |-----------|
927  *                 step
928  */
929 static void strokeWavyTextDecoration(GraphicsContext& context, FloatPoint& p1, FloatPoint& p2, float strokeThickness)
930 {
931     context.adjustLineToPixelBoundaries(p1, p2, strokeThickness, context.strokeStyle());
932
933     Path path;
934     path.moveTo(p1);
935
936     float controlPointDistance;
937     float step;
938     getWavyStrokeParameters(strokeThickness, controlPointDistance, step);
939
940     bool isVerticalLine = (p1.x() == p2.x());
941
942     if (isVerticalLine) {
943         ASSERT(p1.x() == p2.x());
944
945         float xAxis = p1.x();
946         float y1;
947         float y2;
948
949         if (p1.y() < p2.y()) {
950             y1 = p1.y();
951             y2 = p2.y();
952         } else {
953             y1 = p2.y();
954             y2 = p1.y();
955         }
956
957         adjustStepToDecorationLength(step, controlPointDistance, y2 - y1);
958         FloatPoint controlPoint1(xAxis + controlPointDistance, 0);
959         FloatPoint controlPoint2(xAxis - controlPointDistance, 0);
960
961         for (float y = y1; y + 2 * step <= y2;) {
962             controlPoint1.setY(y + step);
963             controlPoint2.setY(y + step);
964             y += 2 * step;
965             path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(xAxis, y));
966         }
967     } else {
968         ASSERT(p1.y() == p2.y());
969
970         float yAxis = p1.y();
971         float x1;
972         float x2;
973
974         if (p1.x() < p2.x()) {
975             x1 = p1.x();
976             x2 = p2.x();
977         } else {
978             x1 = p2.x();
979             x2 = p1.x();
980         }
981
982         adjustStepToDecorationLength(step, controlPointDistance, x2 - x1);
983         FloatPoint controlPoint1(0, yAxis + controlPointDistance);
984         FloatPoint controlPoint2(0, yAxis - controlPointDistance);
985
986         for (float x = x1; x + 2 * step <= x2;) {
987             controlPoint1.setX(x + step);
988             controlPoint2.setX(x + step);
989             x += 2 * step;
990             path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(x, yAxis));
991         }
992     }
993
994     context.setShouldAntialias(true);
995     context.strokePath(path);
996 }
997
998 // Because finding the bounding box of an underline is structurally similar to finding
999 // the bounding box of a strikethrough, we can pull out the computation and parameterize
1000 // by the location of the decoration (yOffset, underlineOffset, and doubleOffset).
1001 static FloatRect boundingBoxForSingleDecoration(GraphicsContext& context, float textDecorationThickness,
1002     float width, FloatPoint localOrigin, TextDecorationStyle decorationStyle,
1003     bool isPrinting, float yOffset, float underlineOffset, float doubleOffset)
1004 {
1005     FloatRect boundingBox;
1006
1007     switch (decorationStyle) {
1008     case TextDecorationStyleWavy: {
1009         FloatPoint start(localOrigin.x(), localOrigin.y() + yOffset);
1010         FloatPoint end = start + FloatSize(width, 0);
1011         context.adjustLineToPixelBoundaries(start, end, textDecorationThickness, context.strokeStyle());
1012
1013         float controlPointDistance;
1014         float step;
1015         getWavyStrokeParameters(textDecorationThickness, controlPointDistance, step);
1016
1017         adjustStepToDecorationLength(step, controlPointDistance, width);
1018
1019         controlPointDistance += textDecorationThickness;
1020         FloatPoint boundingBoxOrigin = start - FloatSize(0, controlPointDistance);
1021         FloatSize boundingBoxSize = FloatSize(width, 2 * controlPointDistance);
1022         boundingBox = FloatRect(boundingBoxOrigin, boundingBoxSize);
1023         break;
1024     }
1025     default:
1026         boundingBox = context.computeLineBoundsForText(localOrigin + FloatSize(0, underlineOffset), width, isPrinting);
1027         if (decorationStyle == TextDecorationStyleDouble)
1028             boundingBox.unite(context.computeLineBoundsForText(localOrigin + FloatSize(0, doubleOffset), width, isPrinting));
1029     }
1030     return boundingBox;
1031 }
1032
1033 static FloatRect boundingBoxForAllActiveDecorations(InlineTextBox& inlineTextBox, GraphicsContext& context, TextDecoration decoration, float textDecorationThickness, float width, float doubleOffset, TextDecorationStyle decorationStyle, const FloatPoint localOrigin, const RenderStyle& lineStyle, bool isPrinting, int baseline)
1034 {
1035     FloatRect boundingBox;
1036     if (decoration & TextDecorationUnderline) {
1037         int underlineOffset = computeUnderlineOffset(lineStyle.textUnderlinePosition(), lineStyle.fontMetrics(), &inlineTextBox, textDecorationThickness);
1038         
1039         boundingBox.unite(boundingBoxForSingleDecoration(context, textDecorationThickness, width, localOrigin, decorationStyle, isPrinting, underlineOffset + doubleOffset, underlineOffset, baseline + 1));
1040     }
1041     if (decoration & TextDecorationOverline)
1042         boundingBox.unite(boundingBoxForSingleDecoration(context, textDecorationThickness, width, localOrigin, decorationStyle, isPrinting, -doubleOffset, 0, -doubleOffset));
1043     if (decoration & TextDecorationLineThrough)
1044         boundingBox.unite(boundingBoxForSingleDecoration(context, textDecorationThickness, width, localOrigin, decorationStyle, isPrinting, 2 * baseline / 3, 2 * baseline / 3, doubleOffset + 2 * baseline / 3));
1045     return boundingBox;
1046 }
1047 #endif // CSS3_TEXT_DECORATION
1048
1049 void InlineTextBox::paintDecoration(GraphicsContext& context, const FloatPoint& boxOrigin, TextDecoration decoration, TextDecorationStyle decorationStyle, const ShadowData* shadow, TextPainter& textPainter)
1050 {
1051 #if !ENABLE(CSS3_TEXT_DECORATION)
1052     UNUSED_PARAM(textPainter);
1053 #endif
1054     // FIXME: We should improve this rule and not always just assume 1.
1055     const float textDecorationThickness = 1.f;
1056
1057     if (m_truncation == cFullTruncation)
1058         return;
1059
1060     FloatPoint localOrigin = boxOrigin;
1061
1062     float width = m_logicalWidth;
1063     if (m_truncation != cNoTruncation) {
1064         width = renderer().width(m_start, m_truncation, textPos(), isFirstLine());
1065         if (!isLeftToRightDirection())
1066             localOrigin.move(m_logicalWidth - width, 0);
1067     }
1068     
1069     // Get the text decoration colors.
1070     Color underline, overline, linethrough;
1071     renderer().getTextDecorationColors(decoration, underline, overline, linethrough, true);
1072     if (isFirstLine())
1073         renderer().getTextDecorationColors(decoration, underline, overline, linethrough, true, true);
1074     
1075     // Use a special function for underlines to get the positioning exactly right.
1076     bool isPrinting = renderer().document().printing();
1077 #if !PLATFORM(IOS)
1078     context.setStrokeThickness(textDecorationThickness);
1079 #else
1080     // On iOS we want to draw crisp decorations. The function drawLineForText takes the context's
1081     // strokeThickness and renders that at device pixel scale (i.e. a strokeThickness of 1 will
1082     // produce a 1 device pixel line, so thinner on retina than non-retina). We will also scale
1083     // our thickness based on the size of the font. Since our default size is 16px we'll use that
1084     // as a scale reference.
1085     float pageScale = 1;
1086     if (Page* page = renderer().frame().page())
1087         pageScale = page->pageScaleFactor();
1088
1089     const float textDecorationBaseFontSize = 16;
1090     float fontSizeScaling = renderer().style().fontSize() / textDecorationBaseFontSize;
1091     float strokeThickness = roundf(textDecorationThickness * fontSizeScaling * pageScale);
1092     context.setStrokeThickness(strokeThickness);
1093 #endif
1094
1095     bool linesAreOpaque = !isPrinting && (!(decoration & TextDecorationUnderline) || underline.alpha() == 255) && (!(decoration & TextDecorationOverline) || overline.alpha() == 255) && (!(decoration & TextDecorationLineThrough) || linethrough.alpha() == 255);
1096
1097     const RenderStyle& lineStyle = this->lineStyle();
1098     int baseline = lineStyle.fontMetrics().ascent();
1099
1100     bool setClip = false;
1101     int extraOffset = 0;
1102     if (!linesAreOpaque && shadow && shadow->next()) {
1103         FloatRect clipRect(localOrigin, FloatSize(width, baseline + 2));
1104         for (const ShadowData* s = shadow; s; s = s->next()) {
1105             int shadowExtent = s->paintingExtent();
1106             FloatRect shadowRect(localOrigin, FloatSize(width, baseline + 2));
1107             shadowRect.inflate(shadowExtent);
1108             int shadowX = isHorizontal() ? s->x() : s->y();
1109             int shadowY = isHorizontal() ? s->y() : -s->x();
1110             shadowRect.move(shadowX, shadowY);
1111             clipRect.unite(shadowRect);
1112             extraOffset = std::max(extraOffset, std::max(0, shadowY) + shadowExtent);
1113         }
1114         context.save();
1115         context.clip(clipRect);
1116         extraOffset += baseline + 2;
1117         localOrigin.move(0, extraOffset);
1118         setClip = true;
1119     }
1120
1121     ColorSpace colorSpace = renderer().style().colorSpace();
1122     bool setShadow = false;
1123
1124     do {
1125         if (shadow) {
1126             if (!shadow->next()) {
1127                 // The last set of lines paints normally inside the clip.
1128                 localOrigin.move(0, -extraOffset);
1129                 extraOffset = 0;
1130             }
1131             int shadowX = isHorizontal() ? shadow->x() : shadow->y();
1132             int shadowY = isHorizontal() ? shadow->y() : -shadow->x();
1133             context.setShadow(FloatSize(shadowX, shadowY - extraOffset), shadow->radius(), shadow->color(), colorSpace);
1134             setShadow = true;
1135             shadow = shadow->next();
1136         }
1137
1138 #if ENABLE(CSS3_TEXT_DECORATION)
1139         // Offset between lines - always non-zero, so lines never cross each other.
1140         float doubleOffset = textDecorationThickness + 1;
1141         
1142         bool clipDecorationToMask = false;
1143         
1144         GraphicsContextStateSaver stateSaver(context, false);
1145         
1146         if (clipDecorationToMask) {
1147             const float skipInkGapWidth = 1;
1148
1149             stateSaver.save();
1150
1151             FloatRect underlineRect = boundingBoxForAllActiveDecorations(*this, context, decoration, textDecorationThickness, width, doubleOffset, decorationStyle, localOrigin, lineStyle, isPrinting, baseline);
1152             IntRect enclosingDeviceRect = enclosingIntRect(underlineRect);
1153             std::unique_ptr<ImageBuffer> imageBuffer = context.createCompatibleBuffer(enclosingDeviceRect.size());
1154
1155             if (imageBuffer.get()) {
1156                 GraphicsContext& maskContext = *imageBuffer->context();
1157                 maskContext.setFillColor(Color::black, ColorSpaceDeviceRGB);
1158                 maskContext.setLineJoin(RoundJoin);
1159                 maskContext.translate(FloatPoint() - enclosingDeviceRect.location());
1160
1161                 maskContext.fillRect(enclosingDeviceRect);
1162                 maskContext.setCompositeOperation(CompositeClear);
1163     
1164                 textPainter.paintTextInContext(maskContext, skipInkGapWidth);
1165
1166                 context.clipToImageBuffer(imageBuffer.get(), enclosingDeviceRect);
1167             }
1168         }
1169 #endif // CSS3_TEXT_DECORATION
1170         context.setStrokeStyle(textDecorationStyleToStrokeStyle(decorationStyle));
1171         if (decoration & TextDecorationUnderline) {
1172             context.setStrokeColor(underline, colorSpace);
1173 #if ENABLE(CSS3_TEXT_DECORATION)
1174             TextUnderlinePosition underlinePosition = lineStyle.textUnderlinePosition();
1175             const int underlineOffset = computeUnderlineOffset(underlinePosition, lineStyle.fontMetrics(), this, textDecorationThickness);
1176
1177             switch (decorationStyle) {
1178             case TextDecorationStyleWavy: {
1179                 FloatPoint start(localOrigin.x(), localOrigin.y() + underlineOffset + doubleOffset);
1180                 FloatPoint end(localOrigin.x() + width, localOrigin.y() + underlineOffset + doubleOffset);
1181                 strokeWavyTextDecoration(context, start, end, textDecorationThickness);
1182                 break;
1183             }
1184             default:
1185 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
1186                 if (lineStyle.textDecorationSkip() == TextDecorationSkipInk) {
1187                     if (!context.paintingDisabled()) {
1188                         drawSkipInkUnderline(textPainter, context, localOrigin, underlineOffset, width, isPrinting, m_start, m_len);
1189
1190                         if (decorationStyle == TextDecorationStyleDouble)
1191                             drawSkipInkUnderline(textPainter, context, localOrigin, underlineOffset + doubleOffset, width, isPrinting, m_start, m_len);
1192                     }
1193                 } else {
1194 #endif // CSS3_TEXT_DECORATION_SKIP_INK
1195                     context.drawLineForText(FloatPoint(localOrigin.x(), localOrigin.y() + underlineOffset), width, isPrinting);
1196
1197                     if (decorationStyle == TextDecorationStyleDouble)
1198                         context.drawLineForText(FloatPoint(localOrigin.x(), localOrigin.y() + underlineOffset + doubleOffset), width, isPrinting);
1199 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
1200                 }
1201 #endif
1202             }
1203 #else
1204             // Leave one pixel of white between the baseline and the underline.
1205             context.drawLineForText(FloatPoint(localOrigin.x(), localOrigin.y() + baseline + 1), width, isPrinting);
1206 #endif // CSS3_TEXT_DECORATION
1207         }
1208         if (decoration & TextDecorationOverline) {
1209             context.setStrokeColor(overline, colorSpace);
1210 #if ENABLE(CSS3_TEXT_DECORATION)
1211             switch (decorationStyle) {
1212             case TextDecorationStyleWavy: {
1213                 FloatPoint start(localOrigin.x(), localOrigin.y() - doubleOffset);
1214                 FloatPoint end(localOrigin.x() + width, localOrigin.y() - doubleOffset);
1215                 strokeWavyTextDecoration(context, start, end, textDecorationThickness);
1216                 break;
1217             }
1218             default:
1219 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
1220                 if (lineStyle.textDecorationSkip() == TextDecorationSkipInk) {
1221                     if (!context.paintingDisabled()) {
1222                         drawSkipInkUnderline(textPainter, context, localOrigin, 0, width, isPrinting, m_start, m_len);
1223
1224                         if (decorationStyle == TextDecorationStyleDouble)
1225                             drawSkipInkUnderline(textPainter, context, localOrigin, -doubleOffset, width, isPrinting, m_start, m_len);
1226                     }
1227                 } else {
1228 #endif // CSS3_TEXT_DECORATION_SKIP_INK
1229 #endif // CSS3_TEXT_DECORATION
1230                     context.drawLineForText(localOrigin, width, isPrinting);
1231 #if ENABLE(CSS3_TEXT_DECORATION)
1232                     if (decorationStyle == TextDecorationStyleDouble)
1233                         context.drawLineForText(FloatPoint(localOrigin.x(), localOrigin.y() - doubleOffset), width, isPrinting);
1234 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
1235                 }
1236 #endif
1237             }
1238 #endif // CSS3_TEXT_DECORATION
1239         }
1240 #if ENABLE(CSS3_TEXT_DECORATION)
1241         if (clipDecorationToMask)
1242             stateSaver.restore();
1243 #endif
1244         if (decoration & TextDecorationLineThrough) {
1245             context.setStrokeColor(linethrough, colorSpace);
1246 #if ENABLE(CSS3_TEXT_DECORATION)
1247             switch (decorationStyle) {
1248             case TextDecorationStyleWavy: {
1249                 FloatPoint start(localOrigin.x(), localOrigin.y() + 2 * baseline / 3);
1250                 FloatPoint end(localOrigin.x() + width, localOrigin.y() + 2 * baseline / 3);
1251                 strokeWavyTextDecoration(context, start, end, textDecorationThickness);
1252                 break;
1253             }
1254             default:
1255 #endif // CSS3_TEXT_DECORATION
1256                 context.drawLineForText(FloatPoint(localOrigin.x(), localOrigin.y() + 2 * baseline / 3), width, isPrinting);
1257 #if ENABLE(CSS3_TEXT_DECORATION)
1258                 if (decorationStyle == TextDecorationStyleDouble)
1259                     context.drawLineForText(FloatPoint(localOrigin.x(), localOrigin.y() + doubleOffset + 2 * baseline / 3), width, isPrinting);
1260             }
1261 #endif // CSS3_TEXT_DECORATION
1262         }
1263     } while (shadow);
1264
1265     if (setClip)
1266         context.restore();
1267     else if (setShadow)
1268         context.clearShadow();
1269 }
1270
1271 static GraphicsContext::DocumentMarkerLineStyle lineStyleForMarkerType(DocumentMarker::MarkerType markerType)
1272 {
1273     switch (markerType) {
1274     case DocumentMarker::Spelling:
1275         return GraphicsContext::DocumentMarkerSpellingLineStyle;
1276     case DocumentMarker::Grammar:
1277         return GraphicsContext::DocumentMarkerGrammarLineStyle;
1278     case DocumentMarker::CorrectionIndicator:
1279         return GraphicsContext::DocumentMarkerAutocorrectionReplacementLineStyle;
1280     case DocumentMarker::DictationAlternatives:
1281         return GraphicsContext::DocumentMarkerDictationAlternativesLineStyle;
1282 #if PLATFORM(IOS)
1283     case DocumentMarker::DictationPhraseWithAlternatives:
1284         // FIXME: Rename TextCheckingDictationPhraseWithAlternativesLineStyle and remove the PLATFORM(IOS)-guard.
1285         return GraphicsContext::TextCheckingDictationPhraseWithAlternativesLineStyle;
1286 #endif
1287     default:
1288         ASSERT_NOT_REACHED();
1289         return GraphicsContext::DocumentMarkerSpellingLineStyle;
1290     }
1291 }
1292
1293 void InlineTextBox::paintDocumentMarker(GraphicsContext* pt, const FloatPoint& boxOrigin, DocumentMarker* marker, const RenderStyle& style, const Font& font, bool grammar)
1294 {
1295     // Never print spelling/grammar markers (5327887)
1296     if (renderer().document().printing())
1297         return;
1298
1299     if (m_truncation == cFullTruncation)
1300         return;
1301
1302     float start = 0; // start of line to draw, relative to tx
1303     float width = m_logicalWidth; // how much line to draw
1304
1305     // Determine whether we need to measure text
1306     bool markerSpansWholeBox = true;
1307     if (m_start <= (int)marker->startOffset())
1308         markerSpansWholeBox = false;
1309     if ((end() + 1) != marker->endOffset()) // end points at the last char, not past it
1310         markerSpansWholeBox = false;
1311     if (m_truncation != cNoTruncation)
1312         markerSpansWholeBox = false;
1313
1314     bool isDictationMarker = marker->type() == DocumentMarker::DictationAlternatives;
1315     if (!markerSpansWholeBox || grammar || isDictationMarker) {
1316         int startPosition = std::max<int>(marker->startOffset() - m_start, 0);
1317         int endPosition = std::min<int>(marker->endOffset() - m_start, m_len);
1318         
1319         if (m_truncation != cNoTruncation)
1320             endPosition = std::min<int>(endPosition, m_truncation);
1321
1322         // Calculate start & width
1323         int deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom() - logicalBottom() : logicalTop() - selectionTop();
1324         int selHeight = selectionHeight();
1325         FloatPoint startPoint(boxOrigin.x(), boxOrigin.y() - deltaY);
1326         TextRun run = constructTextRun(style, font);
1327
1328         // FIXME: Convert the document markers to float rects.
1329         IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, startPoint, selHeight, startPosition, endPosition));
1330         start = markerRect.x() - startPoint.x();
1331         width = markerRect.width();
1332         
1333         // Store rendered rects for bad grammar markers, so we can hit-test against it elsewhere in order to
1334         // display a toolTip. We don't do this for misspelling markers.
1335         if (grammar || isDictationMarker) {
1336             markerRect.move(-boxOrigin.x(), -boxOrigin.y());
1337             markerRect = renderer().localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
1338             toRenderedDocumentMarker(marker)->setRenderedRect(markerRect);
1339         }
1340     }
1341     
1342     // IMPORTANT: The misspelling underline is not considered when calculating the text bounds, so we have to
1343     // make sure to fit within those bounds.  This means the top pixel(s) of the underline will overlap the
1344     // bottom pixel(s) of the glyphs in smaller font sizes.  The alternatives are to increase the line spacing (bad!!)
1345     // or decrease the underline thickness.  The overlap is actually the most useful, and matches what AppKit does.
1346     // So, we generally place the underline at the bottom of the text, but in larger fonts that's not so good so
1347     // we pin to two pixels under the baseline.
1348     int lineThickness = cMisspellingLineThickness;
1349     int baseline = lineStyle().fontMetrics().ascent();
1350     int descent = logicalHeight() - baseline;
1351     int underlineOffset;
1352     if (descent <= (2 + lineThickness)) {
1353         // Place the underline at the very bottom of the text in small/medium fonts.
1354         underlineOffset = logicalHeight() - lineThickness;
1355     } else {
1356         // In larger fonts, though, place the underline up near the baseline to prevent a big gap.
1357         underlineOffset = baseline + 2;
1358     }
1359     pt->drawLineForDocumentMarker(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + underlineOffset), width, lineStyleForMarkerType(marker->type()));
1360 }
1361
1362 void InlineTextBox::paintTextMatchMarker(GraphicsContext* pt, const FloatPoint& boxOrigin, DocumentMarker* marker, const RenderStyle& style, const Font& font)
1363 {
1364     // Use same y positioning and height as for selection, so that when the selection and this highlight are on
1365     // the same word there are no pieces sticking out.
1366     int deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom() - logicalBottom() : logicalTop() - selectionTop();
1367     int selHeight = selectionHeight();
1368
1369     int sPos = std::max(marker->startOffset() - m_start, (unsigned)0);
1370     int ePos = std::min(marker->endOffset() - m_start, (unsigned)m_len);
1371     TextRun run = constructTextRun(style, font);
1372
1373     // Always compute and store the rect associated with this marker. The computed rect is in absolute coordinates.
1374     IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, IntPoint(x(), selectionTop()), selHeight, sPos, ePos));
1375     markerRect = renderer().localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
1376     toRenderedDocumentMarker(marker)->setRenderedRect(markerRect);
1377     
1378     // Optionally highlight the text
1379     if (renderer().frame().editor().markedTextMatchesAreHighlighted()) {
1380         Color color = marker->activeMatch() ? renderer().theme().platformActiveTextSearchHighlightColor() : renderer().theme().platformInactiveTextSearchHighlightColor();
1381         GraphicsContextStateSaver stateSaver(*pt);
1382         updateGraphicsContext(*pt, TextPaintStyle(color, style.colorSpace())); // Don't draw text at all!
1383         pt->clip(FloatRect(boxOrigin.x(), boxOrigin.y() - deltaY, m_logicalWidth, selHeight));
1384         pt->drawHighlightForText(font, run, FloatPoint(boxOrigin.x(), boxOrigin.y() - deltaY), selHeight, color, style.colorSpace(), sPos, ePos);
1385     }
1386 }
1387
1388 void InlineTextBox::computeRectForReplacementMarker(DocumentMarker* marker, const RenderStyle& style, const Font& font)
1389 {
1390     // Replacement markers are not actually drawn, but their rects need to be computed for hit testing.
1391     int top = selectionTop();
1392     int h = selectionHeight();
1393     
1394     int sPos = std::max(marker->startOffset() - m_start, (unsigned)0);
1395     int ePos = std::min(marker->endOffset() - m_start, (unsigned)m_len);
1396     TextRun run = constructTextRun(style, font);
1397     IntPoint startPoint = IntPoint(x(), top);
1398     
1399     // Compute and store the rect associated with this marker.
1400     IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, startPoint, h, sPos, ePos));
1401     markerRect = renderer().localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
1402     toRenderedDocumentMarker(marker)->setRenderedRect(markerRect);
1403 }
1404     
1405 void InlineTextBox::paintDocumentMarkers(GraphicsContext* pt, const FloatPoint& boxOrigin, const RenderStyle& style, const Font& font, bool background)
1406 {
1407     if (!renderer().textNode())
1408         return;
1409
1410     Vector<DocumentMarker*> markers = renderer().document().markers().markersFor(renderer().textNode());
1411     Vector<DocumentMarker*>::const_iterator markerIt = markers.begin();
1412
1413     // Give any document markers that touch this run a chance to draw before the text has been drawn.
1414     // Note end() points at the last char, not one past it like endOffset and ranges do.
1415     for ( ; markerIt != markers.end(); ++markerIt) {
1416         DocumentMarker* marker = *markerIt;
1417         
1418         // Paint either the background markers or the foreground markers, but not both
1419         switch (marker->type()) {
1420             case DocumentMarker::Grammar:
1421             case DocumentMarker::Spelling:
1422             case DocumentMarker::CorrectionIndicator:
1423             case DocumentMarker::Replacement:
1424             case DocumentMarker::DictationAlternatives:
1425 #if PLATFORM(IOS)
1426             // FIXME: Remove the PLATFORM(IOS)-guard.
1427             case DocumentMarker::DictationPhraseWithAlternatives:
1428 #endif
1429                 if (background)
1430                     continue;
1431                 break;
1432             case DocumentMarker::TextMatch:
1433                 if (!background)
1434                     continue;
1435                 break;
1436             default:
1437                 continue;
1438         }
1439
1440         if (marker->endOffset() <= start())
1441             // marker is completely before this run.  This might be a marker that sits before the
1442             // first run we draw, or markers that were within runs we skipped due to truncation.
1443             continue;
1444         
1445         if (marker->startOffset() > end())
1446             // marker is completely after this run, bail.  A later run will paint it.
1447             break;
1448         
1449         // marker intersects this run.  Paint it.
1450         switch (marker->type()) {
1451             case DocumentMarker::Spelling:
1452             case DocumentMarker::CorrectionIndicator:
1453             case DocumentMarker::DictationAlternatives:
1454                 paintDocumentMarker(pt, boxOrigin, marker, style, font, false);
1455                 break;
1456             case DocumentMarker::Grammar:
1457                 paintDocumentMarker(pt, boxOrigin, marker, style, font, true);
1458                 break;
1459 #if PLATFORM(IOS)
1460             // FIXME: See <rdar://problem/8933352>. Also, remove the PLATFORM(IOS)-guard.
1461             case DocumentMarker::DictationPhraseWithAlternatives:
1462                 paintDocumentMarker(pt, boxOrigin, marker, style, font, true);
1463                 break;
1464 #endif
1465             case DocumentMarker::TextMatch:
1466                 paintTextMatchMarker(pt, boxOrigin, marker, style, font);
1467                 break;
1468             case DocumentMarker::Replacement:
1469                 computeRectForReplacementMarker(marker, style, font);
1470                 break;
1471             default:
1472                 ASSERT_NOT_REACHED();
1473         }
1474
1475     }
1476 }
1477
1478 void InlineTextBox::paintCompositionUnderline(GraphicsContext* ctx, const FloatPoint& boxOrigin, const CompositionUnderline& underline)
1479 {
1480     if (m_truncation == cFullTruncation)
1481         return;
1482     
1483     float start = 0; // start of line to draw, relative to tx
1484     float width = m_logicalWidth; // how much line to draw
1485     bool useWholeWidth = true;
1486     unsigned paintStart = m_start;
1487     unsigned paintEnd = end() + 1; // end points at the last char, not past it
1488     if (paintStart <= underline.startOffset) {
1489         paintStart = underline.startOffset;
1490         useWholeWidth = false;
1491         start = renderer().width(m_start, paintStart - m_start, textPos(), isFirstLine());
1492     }
1493     if (paintEnd != underline.endOffset) {      // end points at the last char, not past it
1494         paintEnd = std::min(paintEnd, (unsigned)underline.endOffset);
1495         useWholeWidth = false;
1496     }
1497     if (m_truncation != cNoTruncation) {
1498         paintEnd = std::min(paintEnd, (unsigned)m_start + m_truncation);
1499         useWholeWidth = false;
1500     }
1501     if (!useWholeWidth) {
1502         width = renderer().width(paintStart, paintEnd - paintStart, textPos() + start, isFirstLine());
1503     }
1504
1505     // Thick marked text underlines are 2px thick as long as there is room for the 2px line under the baseline.
1506     // All other marked text underlines are 1px thick.
1507     // If there's not enough space the underline will touch or overlap characters.
1508     int lineThickness = 1;
1509     int baseline = lineStyle().fontMetrics().ascent();
1510     if (underline.thick && logicalHeight() - baseline >= 2)
1511         lineThickness = 2;
1512
1513     // We need to have some space between underlines of subsequent clauses, because some input methods do not use different underline styles for those.
1514     // We make each line shorter, which has a harmless side effect of shortening the first and last clauses, too.
1515     start += 1;
1516     width -= 2;
1517
1518     ctx->setStrokeColor(underline.color, renderer().style().colorSpace());
1519     ctx->setStrokeThickness(lineThickness);
1520     ctx->drawLineForText(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + logicalHeight() - lineThickness), width, renderer().document().printing());
1521 }
1522
1523 int InlineTextBox::caretMinOffset() const
1524 {
1525     return m_start;
1526 }
1527
1528 int InlineTextBox::caretMaxOffset() const
1529 {
1530     return m_start + m_len;
1531 }
1532
1533 float InlineTextBox::textPos() const
1534 {
1535     // When computing the width of a text run, RenderBlock::computeInlineDirectionPositionsForLine() doesn't include the actual offset
1536     // from the containing block edge in its measurement. textPos() should be consistent so the text are rendered in the same width.
1537     if (logicalLeft() == 0)
1538         return 0;
1539     return logicalLeft() - root().logicalLeft();
1540 }
1541
1542 int InlineTextBox::offsetForPosition(float lineOffset, bool includePartialGlyphs) const
1543 {
1544     if (isLineBreak())
1545         return 0;
1546
1547     if (lineOffset - logicalLeft() > logicalWidth())
1548         return isLeftToRightDirection() ? len() : 0;
1549     if (lineOffset - logicalLeft() < 0)
1550         return isLeftToRightDirection() ? 0 : len();
1551
1552     FontCachePurgePreventer fontCachePurgePreventer;
1553
1554     const RenderStyle& lineStyle = this->lineStyle();
1555     const Font& font = fontToUse(lineStyle, renderer());
1556     return font.offsetForPosition(constructTextRun(lineStyle, font), lineOffset - logicalLeft(), includePartialGlyphs);
1557 }
1558
1559 float InlineTextBox::positionForOffset(int offset) const
1560 {
1561     ASSERT(offset >= m_start);
1562     ASSERT(offset <= m_start + m_len);
1563
1564     if (isLineBreak())
1565         return logicalLeft();
1566
1567     FontCachePurgePreventer fontCachePurgePreventer;
1568
1569     const RenderStyle& lineStyle = this->lineStyle();
1570     const Font& font = fontToUse(lineStyle, renderer());
1571     int from = !isLeftToRightDirection() ? offset - m_start : 0;
1572     int to = !isLeftToRightDirection() ? m_len : offset - m_start;
1573     // FIXME: Do we need to add rightBearing here?
1574     return font.selectionRectForText(constructTextRun(lineStyle, font), IntPoint(logicalLeft(), 0), 0, from, to).maxX();
1575 }
1576
1577 TextRun InlineTextBox::constructTextRun(const RenderStyle& style, const Font& font, BufferForAppendingHyphen* charactersWithHyphen) const
1578 {
1579     ASSERT(renderer().text());
1580
1581     String string = renderer().text();
1582     unsigned startPos = start();
1583     unsigned length = len();
1584
1585     if (string.length() != length || startPos)
1586         string = string.substringSharingImpl(startPos, length);
1587
1588     return constructTextRun(style, font, string, renderer().textLength() - startPos, charactersWithHyphen);
1589 }
1590
1591 TextRun InlineTextBox::constructTextRun(const RenderStyle& style, const Font& font, String string, int maximumLength, BufferForAppendingHyphen* charactersWithHyphen) const
1592 {
1593     int length = string.length();
1594
1595     if (charactersWithHyphen) {
1596         adjustCharactersAndLengthForHyphen(*charactersWithHyphen, style, string, length);
1597         maximumLength = length;
1598     }
1599
1600     ASSERT(maximumLength >= length);
1601
1602     TextRun run(string, textPos(), expansion(), expansionBehavior(), direction(), dirOverride() || style.rtlOrdering() == VisualOrder, !renderer().canUseSimpleFontCodePath());
1603     run.setTabSize(!style.collapseWhiteSpace(), style.tabSize());
1604     if (font.isSVGFont())
1605         run.setRenderingContext(SVGTextRunRenderingContext::create(renderer()));
1606
1607     // Propagate the maximum length of the characters buffer to the TextRun, even when we're only processing a substring.
1608     run.setCharactersLength(maximumLength);
1609     ASSERT(run.charactersLength() >= run.length());
1610     return run;
1611 }
1612
1613 #ifndef NDEBUG
1614
1615 const char* InlineTextBox::boxName() const
1616 {
1617     return "InlineTextBox";
1618 }
1619
1620 void InlineTextBox::showBox(int printedCharacters) const
1621 {
1622     String value = renderer().text();
1623     value = value.substring(start(), len());
1624     value.replaceWithLiteral('\\', "\\\\");
1625     value.replaceWithLiteral('\n', "\\n");
1626     printedCharacters += fprintf(stderr, "%s\t%p", boxName(), this);
1627     for (; printedCharacters < showTreeCharacterOffset; printedCharacters++)
1628         fputc(' ', stderr);
1629     printedCharacters = fprintf(stderr, "\t%s %p", renderer().renderName(), &renderer());
1630     const int rendererCharacterOffset = 24;
1631     for (; printedCharacters < rendererCharacterOffset; printedCharacters++)
1632         fputc(' ', stderr);
1633     fprintf(stderr, "(%d,%d) \"%s\"\n", start(), start() + len(), value.utf8().data());
1634 }
1635
1636 #endif
1637
1638 } // namespace WebCore