Subpixel rendering: Inline text selection painting should not snap to integral CSS...
[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 <stdio.h>
55 #include <wtf/text/CString.h>
56
57 namespace WebCore {
58
59 struct SameSizeAsInlineTextBox : public InlineBox {
60     unsigned variables[1];
61     unsigned short variables2[2];
62     void* pointers[2];
63 };
64
65 COMPILE_ASSERT(sizeof(InlineTextBox) == sizeof(SameSizeAsInlineTextBox), InlineTextBox_should_stay_small);
66
67 typedef WTF::HashMap<const InlineTextBox*, LayoutRect> InlineTextBoxOverflowMap;
68 static InlineTextBoxOverflowMap* gTextBoxesWithOverflow;
69
70 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
71 static bool compareTuples(std::pair<float, float> l, std::pair<float, float> r)
72 {
73     return l.first < r.first;
74 }
75
76 static DashArray translateIntersectionPointsToSkipInkBoundaries(const DashArray& intersections, float dilationAmount, float totalWidth)
77 {
78     ASSERT(!(intersections.size() % 2));
79     
80     // Step 1: Make pairs so we can sort based on range starting-point. We dilate the ranges in this step as well.
81     Vector<std::pair<float, float>> tuples;
82     for (auto i = intersections.begin(); i != intersections.end(); i++, i++)
83         tuples.append(std::make_pair(*i - dilationAmount, *(i + 1) + dilationAmount));
84     std::sort(tuples.begin(), tuples.end(), &compareTuples);
85
86     // Step 2: Deal with intersecting ranges.
87     Vector<std::pair<float, float>> intermediateTuples;
88     if (tuples.size() >= 2) {
89         intermediateTuples.append(*tuples.begin());
90         for (auto i = tuples.begin() + 1; i != tuples.end(); i++) {
91             float& firstEnd = intermediateTuples.last().second;
92             float secondStart = i->first;
93             float secondEnd = i->second;
94             if (secondStart <= firstEnd && secondEnd <= firstEnd) {
95                 // Ignore this range completely
96             } else if (secondStart <= firstEnd)
97                 firstEnd = secondEnd;
98             else
99                 intermediateTuples.append(*i);
100         }
101     } else
102         intermediateTuples = tuples;
103
104     // Step 3: Output the space between the ranges, but only if the space warrants an underline.
105     float previous = 0;
106     DashArray result;
107     for (const auto& tuple : intermediateTuples) {
108         if (tuple.first - previous > dilationAmount) {
109             result.append(previous);
110             result.append(tuple.first);
111         }
112         previous = tuple.second;
113     }
114     if (totalWidth - previous > dilationAmount) {
115         result.append(previous);
116         result.append(totalWidth);
117     }
118     
119     return result;
120 }
121
122 static void drawSkipInkUnderline(TextPainter& textPainter, GraphicsContext& context, FloatPoint localOrigin, float underlineOffset, float width, bool isPrinting, bool doubleLines)
123 {
124     FloatPoint adjustedLocalOrigin = localOrigin;
125     adjustedLocalOrigin.move(0, underlineOffset);
126     FloatRect underlineBoundingBox = context.computeLineBoundsForText(adjustedLocalOrigin, width, isPrinting);
127     DashArray intersections = textPainter.dashesForIntersectionsWithRect(underlineBoundingBox);
128     DashArray a = translateIntersectionPointsToSkipInkBoundaries(intersections, underlineBoundingBox.height(), width);
129
130     ASSERT(!(a.size() % 2));
131     context.drawLinesForText(adjustedLocalOrigin, a, isPrinting, doubleLines);
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     int sPos = std::max(startPos - m_start, 0);
201     int ePos = std::min(endPos - m_start, static_cast<int>(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 static inline bool emphasisPositionHasNeitherLeftNorRight(TextEmphasisPosition emphasisPosition)
466 {
467     return !(emphasisPosition & TextEmphasisPositionLeft) && !(emphasisPosition & TextEmphasisPositionRight);
468 }
469
470 bool InlineTextBox::emphasisMarkExistsAndIsAbove(const RenderStyle& style, bool& above) const
471 {
472     // This function returns true if there are text emphasis marks and they are suppressed by ruby text.
473     if (style.textEmphasisMark() == TextEmphasisMarkNone)
474         return false;
475
476     TextEmphasisPosition emphasisPosition = style.textEmphasisPosition();
477     ASSERT(!((emphasisPosition & TextEmphasisPositionOver) && (emphasisPosition & TextEmphasisPositionUnder)));
478     ASSERT(!((emphasisPosition & TextEmphasisPositionLeft) && (emphasisPosition & TextEmphasisPositionRight)));
479     
480     if (emphasisPositionHasNeitherLeftNorRight(emphasisPosition))
481         above = emphasisPosition & TextEmphasisPositionOver;
482     else if (style.isHorizontalWritingMode())
483         above = emphasisPosition & TextEmphasisPositionOver;
484     else
485         above = emphasisPosition & TextEmphasisPositionRight;
486     
487     if ((style.isHorizontalWritingMode() && (emphasisPosition & TextEmphasisPositionUnder))
488         || (!style.isHorizontalWritingMode() && (emphasisPosition & TextEmphasisPositionLeft)))
489         return true; // Ruby text is always over, so it cannot suppress emphasis marks under.
490
491     RenderBlock* containingBlock = renderer().containingBlock();
492     if (!containingBlock->isRubyBase())
493         return true; // This text is not inside a ruby base, so it does not have ruby text over it.
494
495     if (!containingBlock->parent()->isRubyRun())
496         return true; // Cannot get the ruby text.
497
498     RenderRubyText* rubyText = toRenderRubyRun(containingBlock->parent())->rubyText();
499
500     // The emphasis marks over are suppressed only if there is a ruby text box and it not empty.
501     return !rubyText || !rubyText->hasLines();
502 }
503
504 void InlineTextBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /*lineTop*/, LayoutUnit /*lineBottom*/)
505 {
506     if (isLineBreak() || !paintInfo.shouldPaintWithinRoot(renderer()) || renderer().style().visibility() != VISIBLE
507         || m_truncation == cFullTruncation || paintInfo.phase == PaintPhaseOutline || !m_len)
508         return;
509
510     ASSERT(paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines);
511
512     LayoutUnit logicalLeftSide = logicalLeftVisualOverflow();
513     LayoutUnit logicalRightSide = logicalRightVisualOverflow();
514     LayoutUnit logicalStart = logicalLeftSide + (isHorizontal() ? paintOffset.x() : paintOffset.y());
515     LayoutUnit logicalExtent = logicalRightSide - logicalLeftSide;
516     
517     LayoutUnit paintEnd = isHorizontal() ? paintInfo.rect.maxX() : paintInfo.rect.maxY();
518     LayoutUnit paintStart = isHorizontal() ? paintInfo.rect.x() : paintInfo.rect.y();
519     
520     FloatPoint adjustedPaintOffset = roundedForPainting(paintOffset, renderer().document().deviceScaleFactor());
521     
522     if (logicalStart >= paintEnd || logicalStart + logicalExtent <= paintStart)
523         return;
524
525     bool isPrinting = renderer().document().printing();
526     
527     // Determine whether or not we're selected.
528     bool haveSelection = !isPrinting && paintInfo.phase != PaintPhaseTextClip && selectionState() != RenderObject::SelectionNone;
529     if (!haveSelection && paintInfo.phase == PaintPhaseSelection)
530         // When only painting the selection, don't bother to paint if there is none.
531         return;
532
533     if (m_truncation != cNoTruncation) {
534         if (renderer().containingBlock()->style().isLeftToRightDirection() != isLeftToRightDirection()) {
535             // Make the visible fragment of text hug the edge closest to the rest of the run by moving the origin
536             // at which we start drawing text.
537             // e.g. In the case of LTR text truncated in an RTL Context, the correct behavior is:
538             // |Hello|CBA| -> |...He|CBA|
539             // In order to draw the fragment "He" aligned to the right edge of it's box, we need to start drawing
540             // farther to the right.
541             // NOTE: WebKit's behavior differs from that of IE which appears to just overlay the ellipsis on top of the
542             // truncated string i.e.  |Hello|CBA| -> |...lo|CBA|
543             LayoutUnit widthOfVisibleText = renderer().width(m_start, m_truncation, textPos(), isFirstLine());
544             LayoutUnit widthOfHiddenText = m_logicalWidth - widthOfVisibleText;
545             LayoutSize truncationOffset(isLeftToRightDirection() ? widthOfHiddenText : -widthOfHiddenText, 0);
546             adjustedPaintOffset.move(isHorizontal() ? truncationOffset : truncationOffset.transposedSize());
547         }
548     }
549
550     GraphicsContext* context = paintInfo.context;
551
552     const RenderStyle& lineStyle = this->lineStyle();
553     
554     adjustedPaintOffset.move(0, lineStyle.isHorizontalWritingMode() ? 0 : -logicalHeight());
555
556     FloatPoint boxOrigin = locationIncludingFlipping();
557     boxOrigin.move(adjustedPaintOffset.x(), adjustedPaintOffset.y());
558     FloatRect boxRect(boxOrigin, FloatSize(logicalWidth(), logicalHeight()));
559
560     RenderCombineText* combinedText = lineStyle.hasTextCombine() && renderer().isCombineText() && toRenderCombineText(renderer()).isCombined() ? &toRenderCombineText(renderer()) : 0;
561
562     bool shouldRotate = !isHorizontal() && !combinedText;
563     if (shouldRotate)
564         context->concatCTM(rotation(boxRect, Clockwise));
565
566     // Determine whether or not we have composition underlines to draw.
567     bool containsComposition = renderer().textNode() && renderer().frame().editor().compositionNode() == renderer().textNode();
568     bool useCustomUnderlines = containsComposition && renderer().frame().editor().compositionUsesCustomUnderlines();
569
570     // Determine the text colors and selection colors.
571     TextPaintStyle textPaintStyle = computeTextPaintStyle(renderer(), lineStyle, paintInfo);
572
573     bool paintSelectedTextOnly;
574     bool paintSelectedTextSeparately;
575     const ShadowData* selectionShadow;
576     TextPaintStyle selectionPaintStyle = computeTextSelectionPaintStyle(textPaintStyle, renderer(), lineStyle, paintInfo, paintSelectedTextOnly, paintSelectedTextSeparately, selectionShadow);
577
578     // Set our font.
579     const Font& font = fontToUse(lineStyle, renderer());
580
581     FloatPoint textOrigin = FloatPoint(boxOrigin.x(), boxOrigin.y() + font.fontMetrics().ascent());
582
583     if (combinedText)
584         combinedText->adjustTextOrigin(textOrigin, boxRect);
585
586     // 1. Paint backgrounds behind text if needed. Examples of such backgrounds include selection
587     // and composition underlines.
588     if (paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseTextClip && !isPrinting) {
589         if (containsComposition && !useCustomUnderlines)
590             paintCompositionBackground(context, boxOrigin, lineStyle, font,
591                 renderer().frame().editor().compositionStart(),
592                 renderer().frame().editor().compositionEnd());
593
594         paintDocumentMarkers(context, boxOrigin, lineStyle, font, true);
595
596         if (haveSelection && !useCustomUnderlines)
597             paintSelection(context, boxOrigin, lineStyle, font, selectionPaintStyle.fillColor);
598     }
599
600     if (Page* page = renderer().frame().page()) {
601         // FIXME: Right now, InlineTextBoxes never call addRelevantUnpaintedObject() even though they might
602         // legitimately be unpainted if they are waiting on a slow-loading web font. We should fix that, and
603         // when we do, we will have to account for the fact the InlineTextBoxes do not always have unique
604         // renderers and Page currently relies on each unpainted object having a unique renderer.
605         if (paintInfo.phase == PaintPhaseForeground)
606             page->addRelevantRepaintedObject(&renderer(), IntRect(boxOrigin.x(), boxOrigin.y(), logicalWidth(), logicalHeight()));
607     }
608
609     // 2. Now paint the foreground, including text and decorations like underline/overline (in quirks mode only).
610     int length = m_len;
611     int maximumLength;
612     String string;
613     if (!combinedText) {
614         string = renderer().text();
615         if (static_cast<unsigned>(length) != string.length() || m_start) {
616             ASSERT_WITH_SECURITY_IMPLICATION(static_cast<unsigned>(m_start + length) <= string.length());
617             string = string.substringSharingImpl(m_start, length);
618         }
619         maximumLength = renderer().textLength() - m_start;
620     } else {
621         combinedText->getStringToRender(m_start, string, length);
622         maximumLength = length;
623     }
624
625     BufferForAppendingHyphen charactersWithHyphen;
626     TextRun textRun = constructTextRun(lineStyle, font, string, maximumLength, hasHyphen() ? &charactersWithHyphen : 0);
627     if (hasHyphen())
628         length = textRun.length();
629
630     int sPos = 0;
631     int ePos = 0;
632     if (haveSelection && (paintSelectedTextOnly || paintSelectedTextSeparately))
633         selectionStartEnd(sPos, ePos);
634
635     if (m_truncation != cNoTruncation) {
636         sPos = std::min<int>(sPos, m_truncation);
637         ePos = std::min<int>(ePos, m_truncation);
638         length = m_truncation;
639     }
640
641     int emphasisMarkOffset = 0;
642     bool emphasisMarkAbove;
643     bool hasTextEmphasis = emphasisMarkExistsAndIsAbove(lineStyle, emphasisMarkAbove);
644     const AtomicString& emphasisMark = hasTextEmphasis ? lineStyle.textEmphasisMarkString() : nullAtom;
645     if (!emphasisMark.isEmpty())
646         emphasisMarkOffset = emphasisMarkAbove ? -font.fontMetrics().ascent() - font.emphasisMarkDescent(emphasisMark) : font.fontMetrics().descent() + font.emphasisMarkAscent(emphasisMark);
647
648     const ShadowData* textShadow = paintInfo.forceBlackText() ? 0 : lineStyle.textShadow();
649
650     TextPainter textPainter(*context, paintSelectedTextOnly, paintSelectedTextSeparately, font, sPos, ePos, length, emphasisMark, combinedText, textRun, boxRect, textOrigin, emphasisMarkOffset, textShadow, selectionShadow, isHorizontal(), textPaintStyle, selectionPaintStyle);
651     textPainter.paintText();
652
653     // Paint decorations
654     TextDecoration textDecorations = lineStyle.textDecorationsInEffect();
655     if (textDecorations != TextDecorationNone && paintInfo.phase != PaintPhaseSelection) {
656         updateGraphicsContext(*context, textPaintStyle);
657         if (combinedText)
658             context->concatCTM(rotation(boxRect, Clockwise));
659         paintDecoration(*context, boxOrigin, textDecorations, lineStyle.textDecorationStyle(), textShadow, textPainter);
660         if (combinedText)
661             context->concatCTM(rotation(boxRect, Counterclockwise));
662     }
663
664     if (paintInfo.phase == PaintPhaseForeground) {
665         paintDocumentMarkers(context, boxOrigin, lineStyle, font, false);
666
667         if (useCustomUnderlines) {
668             const Vector<CompositionUnderline>& underlines = renderer().frame().editor().customCompositionUnderlines();
669             size_t numUnderlines = underlines.size();
670
671             for (size_t index = 0; index < numUnderlines; ++index) {
672                 const CompositionUnderline& underline = underlines[index];
673
674                 if (underline.endOffset <= start())
675                     // underline is completely before this run.  This might be an underline that sits
676                     // before the first run we draw, or underlines that were within runs we skipped 
677                     // due to truncation.
678                     continue;
679                 
680                 if (underline.startOffset <= end()) {
681                     // underline intersects this run.  Paint it.
682                     paintCompositionUnderline(context, boxOrigin, underline);
683                     if (underline.endOffset > end() + 1)
684                         // underline also runs into the next run. Bail now, no more marker advancement.
685                         break;
686                 } else
687                     // underline is completely after this run, bail.  A later run will paint it.
688                     break;
689             }
690         }
691     }
692     
693     if (shouldRotate)
694         context->concatCTM(rotation(boxRect, Counterclockwise));
695 }
696
697 void InlineTextBox::selectionStartEnd(int& sPos, int& ePos)
698 {
699     int startPos, endPos;
700     if (renderer().selectionState() == RenderObject::SelectionInside) {
701         startPos = 0;
702         endPos = renderer().textLength();
703     } else {
704         renderer().selectionStartEnd(startPos, endPos);
705         if (renderer().selectionState() == RenderObject::SelectionStart)
706             endPos = renderer().textLength();
707         else if (renderer().selectionState() == RenderObject::SelectionEnd)
708             startPos = 0;
709     }
710
711     sPos = std::max(startPos - m_start, 0);
712     ePos = std::min(endPos - m_start, (int)m_len);
713 }
714
715 void InlineTextBox::paintSelection(GraphicsContext* context, const FloatPoint& boxOrigin, const RenderStyle& style, const Font& font, Color textColor)
716 {
717 #if ENABLE(TEXT_SELECTION)
718     if (context->paintingDisabled())
719         return;
720
721     // See if we have a selection to paint at all.
722     int sPos, ePos;
723     selectionStartEnd(sPos, ePos);
724     if (sPos >= ePos)
725         return;
726
727     Color c = renderer().selectionBackgroundColor();
728     if (!c.isValid() || c.alpha() == 0)
729         return;
730
731     // If the text color ends up being the same as the selection background, invert the selection
732     // background.
733     if (textColor == c)
734         c = Color(0xff - c.red(), 0xff - c.green(), 0xff - c.blue());
735
736     GraphicsContextStateSaver stateSaver(*context);
737     updateGraphicsContext(*context, TextPaintStyle(c, style.colorSpace())); // Don't draw text at all!
738     
739     // If the text is truncated, let the thing being painted in the truncation
740     // draw its own highlight.
741     int length = m_truncation != cNoTruncation ? m_truncation : m_len;
742     String string = renderer().text();
743
744     if (string.length() != static_cast<unsigned>(length) || m_start) {
745         ASSERT_WITH_SECURITY_IMPLICATION(static_cast<unsigned>(m_start + length) <= string.length());
746         string = string.substringSharingImpl(m_start, length);
747     }
748
749     BufferForAppendingHyphen charactersWithHyphen;
750     bool respectHyphen = ePos == length && hasHyphen();
751     TextRun textRun = constructTextRun(style, font, string, renderer().textLength() - m_start, respectHyphen ? &charactersWithHyphen : 0);
752     if (respectHyphen)
753         ePos = textRun.length();
754
755     const RootInlineBox& rootBox = root();
756     LayoutUnit selectionBottom = rootBox.selectionBottom();
757     LayoutUnit selectionTop = rootBox.selectionTopAdjustedForPrecedingBlock();
758
759     LayoutUnit deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom - logicalBottom() : logicalTop() - selectionTop;
760     LayoutUnit selectionHeight = std::max<LayoutUnit>(0, selectionBottom - selectionTop);
761
762     float deviceScaleFactor = renderer().document().deviceScaleFactor();
763     FloatPoint localOrigin = roundedForPainting(LayoutPoint(boxOrigin.x(), boxOrigin.y() - deltaY), deviceScaleFactor);
764     context->clip(pixelSnappedForPainting(LayoutRect(LayoutPoint(localOrigin), LayoutSize(m_logicalWidth, selectionHeight)), deviceScaleFactor));
765     context->drawHighlightForText(font, textRun, localOrigin, selectionHeight, 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 static StrokeStyle textDecorationStyleToStrokeStyle(TextDecorationStyle decorationStyle)
803 {
804     StrokeStyle strokeStyle = SolidStroke;
805     switch (decorationStyle) {
806     case TextDecorationStyleSolid:
807         strokeStyle = SolidStroke;
808         break;
809     case TextDecorationStyleDouble:
810         strokeStyle = DoubleStroke;
811         break;
812     case TextDecorationStyleDotted:
813         strokeStyle = DottedStroke;
814         break;
815     case TextDecorationStyleDashed:
816         strokeStyle = DashedStroke;
817         break;
818     case TextDecorationStyleWavy:
819         strokeStyle = WavyStroke;
820         break;
821     }
822
823     return strokeStyle;
824 }
825
826 static int computeUnderlineOffset(const TextUnderlinePosition underlinePosition, const FontMetrics& fontMetrics, const InlineTextBox* inlineTextBox, const int textDecorationThickness)
827 {
828     // Compute the gap between the font and the underline. Use at least one
829     // pixel gap, if underline is thick then use a bigger gap.
830     const int gap = std::max<int>(1, ceilf(textDecorationThickness / 2.0));
831
832     // According to the specification TextUnderlinePositionAuto should default to 'alphabetic' for horizontal text
833     // and to 'under Left' for vertical text (e.g. japanese). We support only horizontal text for now.
834     switch (underlinePosition) {
835     case TextUnderlinePositionAlphabetic:
836     case TextUnderlinePositionAuto:
837         return fontMetrics.ascent() + gap; // Position underline near the alphabetic baseline.
838     case TextUnderlinePositionUnder: {
839         // Position underline relative to the under edge of the lowest element's content box.
840         const float offset = inlineTextBox->root().maxLogicalTop() - inlineTextBox->logicalTop();
841         return inlineTextBox->logicalHeight() + gap + std::max<float>(offset, 0);
842     }
843     }
844
845     ASSERT_NOT_REACHED();
846     return fontMetrics.ascent() + gap;
847 }
848
849 static void adjustStepToDecorationLength(float& step, float& controlPointDistance, float length)
850 {
851     ASSERT(step > 0);
852
853     if (length <= 0)
854         return;
855
856     unsigned stepCount = static_cast<unsigned>(length / step);
857
858     // Each Bezier curve starts at the same pixel that the previous one
859     // ended. We need to subtract (stepCount - 1) pixels when calculating the
860     // length covered to account for that.
861     float uncoveredLength = length - (stepCount * step - (stepCount - 1));
862     float adjustment = uncoveredLength / stepCount;
863     step += adjustment;
864     controlPointDistance += adjustment;
865 }
866
867 static void getWavyStrokeParameters(float strokeThickness, float& controlPointDistance, float& step)
868 {
869     // Distance between decoration's axis and Bezier curve's control points.
870     // The height of the curve is based on this distance. Use a minimum of 6 pixels distance since
871     // the actual curve passes approximately at half of that distance, that is 3 pixels.
872     // The minimum height of the curve is also approximately 3 pixels. Increases the curve's height
873     // as strockThickness increases to make the curve looks better.
874     controlPointDistance = 3 * std::max<float>(2, strokeThickness);
875
876     // Increment used to form the diamond shape between start point (p1), control
877     // points and end point (p2) along the axis of the decoration. Makes the
878     // curve wider as strockThickness increases to make the curve looks better.
879     step = 2 * std::max<float>(2, strokeThickness);
880 }
881
882 /*
883  * Draw one cubic Bezier curve and repeat the same pattern long the the decoration's axis.
884  * The start point (p1), controlPoint1, controlPoint2 and end point (p2) of the Bezier curve
885  * form a diamond shape:
886  *
887  *                              step
888  *                         |-----------|
889  *
890  *                   controlPoint1
891  *                         +
892  *
893  *
894  *                  . .
895  *                .     .
896  *              .         .
897  * (x1, y1) p1 +           .            + p2 (x2, y2) - <--- Decoration's axis
898  *                          .         .               |
899  *                            .     .                 |
900  *                              . .                   | controlPointDistance
901  *                                                    |
902  *                                                    |
903  *                         +                          -
904  *                   controlPoint2
905  *
906  *             |-----------|
907  *                 step
908  */
909 static void strokeWavyTextDecoration(GraphicsContext& context, FloatPoint& p1, FloatPoint& p2, float strokeThickness)
910 {
911     context.adjustLineToPixelBoundaries(p1, p2, strokeThickness, context.strokeStyle());
912
913     Path path;
914     path.moveTo(p1);
915
916     float controlPointDistance;
917     float step;
918     getWavyStrokeParameters(strokeThickness, controlPointDistance, step);
919
920     bool isVerticalLine = (p1.x() == p2.x());
921
922     if (isVerticalLine) {
923         ASSERT(p1.x() == p2.x());
924
925         float xAxis = p1.x();
926         float y1;
927         float y2;
928
929         if (p1.y() < p2.y()) {
930             y1 = p1.y();
931             y2 = p2.y();
932         } else {
933             y1 = p2.y();
934             y2 = p1.y();
935         }
936
937         adjustStepToDecorationLength(step, controlPointDistance, y2 - y1);
938         FloatPoint controlPoint1(xAxis + controlPointDistance, 0);
939         FloatPoint controlPoint2(xAxis - controlPointDistance, 0);
940
941         for (float y = y1; y + 2 * step <= y2;) {
942             controlPoint1.setY(y + step);
943             controlPoint2.setY(y + step);
944             y += 2 * step;
945             path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(xAxis, y));
946         }
947     } else {
948         ASSERT(p1.y() == p2.y());
949
950         float yAxis = p1.y();
951         float x1;
952         float x2;
953
954         if (p1.x() < p2.x()) {
955             x1 = p1.x();
956             x2 = p2.x();
957         } else {
958             x1 = p2.x();
959             x2 = p1.x();
960         }
961
962         adjustStepToDecorationLength(step, controlPointDistance, x2 - x1);
963         FloatPoint controlPoint1(0, yAxis + controlPointDistance);
964         FloatPoint controlPoint2(0, yAxis - controlPointDistance);
965
966         for (float x = x1; x + 2 * step <= x2;) {
967             controlPoint1.setX(x + step);
968             controlPoint2.setX(x + step);
969             x += 2 * step;
970             path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(x, yAxis));
971         }
972     }
973
974     context.setShouldAntialias(true);
975     context.strokePath(path);
976 }
977
978 void InlineTextBox::paintDecoration(GraphicsContext& context, const FloatPoint& boxOrigin, TextDecoration decoration, TextDecorationStyle decorationStyle, const ShadowData* shadow, TextPainter& textPainter)
979 {
980 #if !ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
981     UNUSED_PARAM(textPainter);
982 #endif
983
984     // FIXME: We should improve this rule and not always just assume 1.
985     const float textDecorationThickness = 1.f;
986
987     if (m_truncation == cFullTruncation)
988         return;
989
990     FloatPoint localOrigin = boxOrigin;
991
992     float width = m_logicalWidth;
993     if (m_truncation != cNoTruncation) {
994         width = renderer().width(m_start, m_truncation, textPos(), isFirstLine());
995         if (!isLeftToRightDirection())
996             localOrigin.move(m_logicalWidth - width, 0);
997     }
998     
999     // Get the text decoration colors.
1000     Color underline, overline, linethrough;
1001     renderer().getTextDecorationColors(decoration, underline, overline, linethrough, true);
1002     if (isFirstLine())
1003         renderer().getTextDecorationColors(decoration, underline, overline, linethrough, true, true);
1004     
1005     // Use a special function for underlines to get the positioning exactly right.
1006     bool isPrinting = renderer().document().printing();
1007
1008     const float textDecorationBaseFontSize = 16;
1009     float fontSizeScaling = renderer().style().fontSize() / textDecorationBaseFontSize;
1010     float strokeThickness = roundf(textDecorationThickness * fontSizeScaling);
1011     context.setStrokeThickness(strokeThickness);
1012
1013     bool linesAreOpaque = !isPrinting && (!(decoration & TextDecorationUnderline) || underline.alpha() == 255) && (!(decoration & TextDecorationOverline) || overline.alpha() == 255) && (!(decoration & TextDecorationLineThrough) || linethrough.alpha() == 255);
1014
1015     const RenderStyle& lineStyle = this->lineStyle();
1016     int baseline = lineStyle.fontMetrics().ascent();
1017
1018     bool setClip = false;
1019     int extraOffset = 0;
1020     if (!linesAreOpaque && shadow && shadow->next()) {
1021         FloatRect clipRect(localOrigin, FloatSize(width, baseline + 2));
1022         for (const ShadowData* s = shadow; s; s = s->next()) {
1023             int shadowExtent = s->paintingExtent();
1024             FloatRect shadowRect(localOrigin, FloatSize(width, baseline + 2));
1025             shadowRect.inflate(shadowExtent);
1026             int shadowX = isHorizontal() ? s->x() : s->y();
1027             int shadowY = isHorizontal() ? s->y() : -s->x();
1028             shadowRect.move(shadowX, shadowY);
1029             clipRect.unite(shadowRect);
1030             extraOffset = std::max(extraOffset, std::max(0, shadowY) + shadowExtent);
1031         }
1032         context.save();
1033         context.clip(clipRect);
1034         extraOffset += baseline + 2;
1035         localOrigin.move(0, extraOffset);
1036         setClip = true;
1037     }
1038
1039     ColorSpace colorSpace = renderer().style().colorSpace();
1040     bool setShadow = false;
1041
1042     do {
1043         if (shadow) {
1044             if (!shadow->next()) {
1045                 // The last set of lines paints normally inside the clip.
1046                 localOrigin.move(0, -extraOffset);
1047                 extraOffset = 0;
1048             }
1049             int shadowX = isHorizontal() ? shadow->x() : shadow->y();
1050             int shadowY = isHorizontal() ? shadow->y() : -shadow->x();
1051             context.setShadow(FloatSize(shadowX, shadowY - extraOffset), shadow->radius(), shadow->color(), colorSpace);
1052             setShadow = true;
1053             shadow = shadow->next();
1054         }
1055         
1056         float wavyOffset = 2.f;
1057
1058         context.setStrokeStyle(textDecorationStyleToStrokeStyle(decorationStyle));
1059         if (decoration & TextDecorationUnderline) {
1060             context.setStrokeColor(underline, colorSpace);
1061             TextUnderlinePosition underlinePosition = lineStyle.textUnderlinePosition();
1062             const int underlineOffset = computeUnderlineOffset(underlinePosition, lineStyle.fontMetrics(), this, textDecorationThickness);
1063
1064             switch (decorationStyle) {
1065             case TextDecorationStyleWavy: {
1066                 FloatPoint start(localOrigin.x(), localOrigin.y() + underlineOffset + wavyOffset);
1067                 FloatPoint end(localOrigin.x() + width, localOrigin.y() + underlineOffset + wavyOffset);
1068                 strokeWavyTextDecoration(context, start, end, textDecorationThickness);
1069                 break;
1070             }
1071             default:
1072 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
1073                 if ((lineStyle.textDecorationSkip() == TextDecorationSkipInk || lineStyle.textDecorationSkip() == TextDecorationSkipAuto) && isHorizontal()) {
1074                     if (!context.paintingDisabled()) {
1075                         drawSkipInkUnderline(textPainter, context, localOrigin, underlineOffset, width, isPrinting, decorationStyle == TextDecorationStyleDouble);
1076                     }
1077                 } else
1078                     // FIXME: Need to support text-decoration-skip: none.
1079 #endif // CSS3_TEXT_DECORATION_SKIP_INK
1080                     context.drawLineForText(FloatPoint(localOrigin.x(), localOrigin.y() + underlineOffset), width, isPrinting, decorationStyle == TextDecorationStyleDouble);
1081             }
1082         }
1083         if (decoration & TextDecorationOverline) {
1084             context.setStrokeColor(overline, colorSpace);
1085             switch (decorationStyle) {
1086             case TextDecorationStyleWavy: {
1087                 FloatPoint start(localOrigin.x(), localOrigin.y() - wavyOffset);
1088                 FloatPoint end(localOrigin.x() + width, localOrigin.y() - wavyOffset);
1089                 strokeWavyTextDecoration(context, start, end, textDecorationThickness);
1090                 break;
1091             }
1092             default:
1093 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
1094                 if ((lineStyle.textDecorationSkip() == TextDecorationSkipInk || lineStyle.textDecorationSkip() == TextDecorationSkipAuto) && isHorizontal()) {
1095                     if (!context.paintingDisabled())
1096                         drawSkipInkUnderline(textPainter, context, localOrigin, 0, width, isPrinting, decorationStyle == TextDecorationStyleDouble);
1097                 } else
1098                     // FIXME: Need to support text-decoration-skip: none.
1099 #endif // CSS3_TEXT_DECORATION_SKIP_INK
1100                     context.drawLineForText(localOrigin, width, isPrinting, decorationStyle == TextDecorationStyleDouble);
1101             }
1102         }
1103         if (decoration & TextDecorationLineThrough) {
1104             context.setStrokeColor(linethrough, colorSpace);
1105             switch (decorationStyle) {
1106             case TextDecorationStyleWavy: {
1107                 FloatPoint start(localOrigin.x(), localOrigin.y() + 2 * baseline / 3);
1108                 FloatPoint end(localOrigin.x() + width, localOrigin.y() + 2 * baseline / 3);
1109                 strokeWavyTextDecoration(context, start, end, textDecorationThickness);
1110                 break;
1111             }
1112             default:
1113                 context.drawLineForText(FloatPoint(localOrigin.x(), localOrigin.y() + 2 * baseline / 3), width, isPrinting, decorationStyle == TextDecorationStyleDouble);
1114             }
1115         }
1116     } while (shadow);
1117
1118     if (setClip)
1119         context.restore();
1120     else if (setShadow)
1121         context.clearShadow();
1122 }
1123
1124 static GraphicsContext::DocumentMarkerLineStyle lineStyleForMarkerType(DocumentMarker::MarkerType markerType)
1125 {
1126     switch (markerType) {
1127     case DocumentMarker::Spelling:
1128         return GraphicsContext::DocumentMarkerSpellingLineStyle;
1129     case DocumentMarker::Grammar:
1130         return GraphicsContext::DocumentMarkerGrammarLineStyle;
1131     case DocumentMarker::CorrectionIndicator:
1132         return GraphicsContext::DocumentMarkerAutocorrectionReplacementLineStyle;
1133     case DocumentMarker::DictationAlternatives:
1134         return GraphicsContext::DocumentMarkerDictationAlternativesLineStyle;
1135 #if PLATFORM(IOS)
1136     case DocumentMarker::DictationPhraseWithAlternatives:
1137         // FIXME: Rename TextCheckingDictationPhraseWithAlternativesLineStyle and remove the PLATFORM(IOS)-guard.
1138         return GraphicsContext::TextCheckingDictationPhraseWithAlternativesLineStyle;
1139 #endif
1140     default:
1141         ASSERT_NOT_REACHED();
1142         return GraphicsContext::DocumentMarkerSpellingLineStyle;
1143     }
1144 }
1145
1146 void InlineTextBox::paintDocumentMarker(GraphicsContext* pt, const FloatPoint& boxOrigin, DocumentMarker* marker, const RenderStyle& style, const Font& font, bool grammar)
1147 {
1148     // Never print spelling/grammar markers (5327887)
1149     if (renderer().document().printing())
1150         return;
1151
1152     if (m_truncation == cFullTruncation)
1153         return;
1154
1155     float start = 0; // start of line to draw, relative to tx
1156     float width = m_logicalWidth; // how much line to draw
1157
1158     // Determine whether we need to measure text
1159     bool markerSpansWholeBox = true;
1160     if (m_start <= (int)marker->startOffset())
1161         markerSpansWholeBox = false;
1162     if ((end() + 1) != marker->endOffset()) // end points at the last char, not past it
1163         markerSpansWholeBox = false;
1164     if (m_truncation != cNoTruncation)
1165         markerSpansWholeBox = false;
1166
1167     bool isDictationMarker = marker->type() == DocumentMarker::DictationAlternatives;
1168     if (!markerSpansWholeBox || grammar || isDictationMarker) {
1169         int startPosition = std::max<int>(marker->startOffset() - m_start, 0);
1170         int endPosition = std::min<int>(marker->endOffset() - m_start, m_len);
1171         
1172         if (m_truncation != cNoTruncation)
1173             endPosition = std::min<int>(endPosition, m_truncation);
1174
1175         // Calculate start & width
1176         int deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom() - logicalBottom() : logicalTop() - selectionTop();
1177         int selHeight = selectionHeight();
1178         FloatPoint startPoint(boxOrigin.x(), boxOrigin.y() - deltaY);
1179         TextRun run = constructTextRun(style, font);
1180
1181         // FIXME: Convert the document markers to float rects.
1182         IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, startPoint, selHeight, startPosition, endPosition));
1183         start = markerRect.x() - startPoint.x();
1184         width = markerRect.width();
1185         
1186         // Store rendered rects for bad grammar markers, so we can hit-test against it elsewhere in order to
1187         // display a toolTip. We don't do this for misspelling markers.
1188         if (grammar || isDictationMarker) {
1189             markerRect.move(-boxOrigin.x(), -boxOrigin.y());
1190             markerRect = renderer().localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
1191             toRenderedDocumentMarker(marker)->setRenderedRect(markerRect);
1192         }
1193     }
1194     
1195     // IMPORTANT: The misspelling underline is not considered when calculating the text bounds, so we have to
1196     // make sure to fit within those bounds.  This means the top pixel(s) of the underline will overlap the
1197     // bottom pixel(s) of the glyphs in smaller font sizes.  The alternatives are to increase the line spacing (bad!!)
1198     // or decrease the underline thickness.  The overlap is actually the most useful, and matches what AppKit does.
1199     // So, we generally place the underline at the bottom of the text, but in larger fonts that's not so good so
1200     // we pin to two pixels under the baseline.
1201     int lineThickness = cMisspellingLineThickness;
1202     int baseline = lineStyle().fontMetrics().ascent();
1203     int descent = logicalHeight() - baseline;
1204     int underlineOffset;
1205     if (descent <= (2 + lineThickness)) {
1206         // Place the underline at the very bottom of the text in small/medium fonts.
1207         underlineOffset = logicalHeight() - lineThickness;
1208     } else {
1209         // In larger fonts, though, place the underline up near the baseline to prevent a big gap.
1210         underlineOffset = baseline + 2;
1211     }
1212     pt->drawLineForDocumentMarker(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + underlineOffset), width, lineStyleForMarkerType(marker->type()));
1213 }
1214
1215 void InlineTextBox::paintTextMatchMarker(GraphicsContext* pt, const FloatPoint& boxOrigin, DocumentMarker* marker, const RenderStyle& style, const Font& font)
1216 {
1217     // Use same y positioning and height as for selection, so that when the selection and this highlight are on
1218     // the same word there are no pieces sticking out.
1219     int deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom() - logicalBottom() : logicalTop() - selectionTop();
1220     int selHeight = selectionHeight();
1221
1222     int sPos = std::max(marker->startOffset() - m_start, (unsigned)0);
1223     int ePos = std::min(marker->endOffset() - m_start, (unsigned)m_len);
1224     TextRun run = constructTextRun(style, font);
1225
1226     // Always compute and store the rect associated with this marker. The computed rect is in absolute coordinates.
1227     IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, IntPoint(x(), selectionTop()), selHeight, sPos, ePos));
1228     markerRect = renderer().localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
1229     toRenderedDocumentMarker(marker)->setRenderedRect(markerRect);
1230     
1231     // Optionally highlight the text
1232     if (renderer().frame().editor().markedTextMatchesAreHighlighted()) {
1233         Color color = marker->activeMatch() ? renderer().theme().platformActiveTextSearchHighlightColor() : renderer().theme().platformInactiveTextSearchHighlightColor();
1234         GraphicsContextStateSaver stateSaver(*pt);
1235         updateGraphicsContext(*pt, TextPaintStyle(color, style.colorSpace())); // Don't draw text at all!
1236         pt->clip(FloatRect(boxOrigin.x(), boxOrigin.y() - deltaY, m_logicalWidth, selHeight));
1237         pt->drawHighlightForText(font, run, FloatPoint(boxOrigin.x(), boxOrigin.y() - deltaY), selHeight, color, style.colorSpace(), sPos, ePos);
1238     }
1239 }
1240
1241 void InlineTextBox::computeRectForReplacementMarker(DocumentMarker* marker, const RenderStyle& style, const Font& font)
1242 {
1243     // Replacement markers are not actually drawn, but their rects need to be computed for hit testing.
1244     int top = selectionTop();
1245     int h = selectionHeight();
1246     
1247     int sPos = std::max(marker->startOffset() - m_start, (unsigned)0);
1248     int ePos = std::min(marker->endOffset() - m_start, (unsigned)m_len);
1249     TextRun run = constructTextRun(style, font);
1250     IntPoint startPoint = IntPoint(x(), top);
1251     
1252     // Compute and store the rect associated with this marker.
1253     IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, startPoint, h, sPos, ePos));
1254     markerRect = renderer().localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
1255     toRenderedDocumentMarker(marker)->setRenderedRect(markerRect);
1256 }
1257     
1258 void InlineTextBox::paintDocumentMarkers(GraphicsContext* pt, const FloatPoint& boxOrigin, const RenderStyle& style, const Font& font, bool background)
1259 {
1260     if (!renderer().textNode())
1261         return;
1262
1263     Vector<DocumentMarker*> markers = renderer().document().markers().markersFor(renderer().textNode());
1264     Vector<DocumentMarker*>::const_iterator markerIt = markers.begin();
1265
1266     // Give any document markers that touch this run a chance to draw before the text has been drawn.
1267     // Note end() points at the last char, not one past it like endOffset and ranges do.
1268     for ( ; markerIt != markers.end(); ++markerIt) {
1269         DocumentMarker* marker = *markerIt;
1270         
1271         // Paint either the background markers or the foreground markers, but not both
1272         switch (marker->type()) {
1273             case DocumentMarker::Grammar:
1274             case DocumentMarker::Spelling:
1275             case DocumentMarker::CorrectionIndicator:
1276             case DocumentMarker::Replacement:
1277             case DocumentMarker::DictationAlternatives:
1278 #if PLATFORM(IOS)
1279             // FIXME: Remove the PLATFORM(IOS)-guard.
1280             case DocumentMarker::DictationPhraseWithAlternatives:
1281 #endif
1282                 if (background)
1283                     continue;
1284                 break;
1285             case DocumentMarker::TextMatch:
1286 #if ENABLE(TELEPHONE_NUMBER_DETECTION)
1287             case DocumentMarker::TelephoneNumber:
1288 #endif
1289                 if (!background)
1290                     continue;
1291                 break;
1292             default:
1293                 continue;
1294         }
1295
1296         if (marker->endOffset() <= start())
1297             // marker is completely before this run.  This might be a marker that sits before the
1298             // first run we draw, or markers that were within runs we skipped due to truncation.
1299             continue;
1300         
1301         if (marker->startOffset() > end())
1302             // marker is completely after this run, bail.  A later run will paint it.
1303             break;
1304         
1305         // marker intersects this run.  Paint it.
1306         switch (marker->type()) {
1307             case DocumentMarker::Spelling:
1308             case DocumentMarker::CorrectionIndicator:
1309             case DocumentMarker::DictationAlternatives:
1310                 paintDocumentMarker(pt, boxOrigin, marker, style, font, false);
1311                 break;
1312             case DocumentMarker::Grammar:
1313                 paintDocumentMarker(pt, boxOrigin, marker, style, font, true);
1314                 break;
1315 #if PLATFORM(IOS)
1316             // FIXME: See <rdar://problem/8933352>. Also, remove the PLATFORM(IOS)-guard.
1317             case DocumentMarker::DictationPhraseWithAlternatives:
1318                 paintDocumentMarker(pt, boxOrigin, marker, style, font, true);
1319                 break;
1320 #endif
1321             case DocumentMarker::TextMatch:
1322                 paintTextMatchMarker(pt, boxOrigin, marker, style, font);
1323                 break;
1324             case DocumentMarker::Replacement:
1325                 computeRectForReplacementMarker(marker, style, font);
1326                 break;
1327 #if ENABLE(TELEPHONE_NUMBER_DETECTION)
1328             case DocumentMarker::TelephoneNumber:
1329                 break;
1330 #endif
1331             default:
1332                 ASSERT_NOT_REACHED();
1333         }
1334
1335     }
1336 }
1337
1338 void InlineTextBox::paintCompositionUnderline(GraphicsContext* ctx, const FloatPoint& boxOrigin, const CompositionUnderline& underline)
1339 {
1340     if (m_truncation == cFullTruncation)
1341         return;
1342     
1343     float start = 0; // start of line to draw, relative to tx
1344     float width = m_logicalWidth; // how much line to draw
1345     bool useWholeWidth = true;
1346     unsigned paintStart = m_start;
1347     unsigned paintEnd = end() + 1; // end points at the last char, not past it
1348     if (paintStart <= underline.startOffset) {
1349         paintStart = underline.startOffset;
1350         useWholeWidth = false;
1351         start = renderer().width(m_start, paintStart - m_start, textPos(), isFirstLine());
1352     }
1353     if (paintEnd != underline.endOffset) {      // end points at the last char, not past it
1354         paintEnd = std::min(paintEnd, (unsigned)underline.endOffset);
1355         useWholeWidth = false;
1356     }
1357     if (m_truncation != cNoTruncation) {
1358         paintEnd = std::min(paintEnd, (unsigned)m_start + m_truncation);
1359         useWholeWidth = false;
1360     }
1361     if (!useWholeWidth) {
1362         width = renderer().width(paintStart, paintEnd - paintStart, textPos() + start, isFirstLine());
1363     }
1364
1365     // Thick marked text underlines are 2px thick as long as there is room for the 2px line under the baseline.
1366     // All other marked text underlines are 1px thick.
1367     // If there's not enough space the underline will touch or overlap characters.
1368     int lineThickness = 1;
1369     int baseline = lineStyle().fontMetrics().ascent();
1370     if (underline.thick && logicalHeight() - baseline >= 2)
1371         lineThickness = 2;
1372
1373     // We need to have some space between underlines of subsequent clauses, because some input methods do not use different underline styles for those.
1374     // We make each line shorter, which has a harmless side effect of shortening the first and last clauses, too.
1375     start += 1;
1376     width -= 2;
1377
1378     ctx->setStrokeColor(underline.color, renderer().style().colorSpace());
1379     ctx->setStrokeThickness(lineThickness);
1380     ctx->drawLineForText(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + logicalHeight() - lineThickness), width, renderer().document().printing());
1381 }
1382
1383 int InlineTextBox::caretMinOffset() const
1384 {
1385     return m_start;
1386 }
1387
1388 int InlineTextBox::caretMaxOffset() const
1389 {
1390     return m_start + m_len;
1391 }
1392
1393 float InlineTextBox::textPos() const
1394 {
1395     // When computing the width of a text run, RenderBlock::computeInlineDirectionPositionsForLine() doesn't include the actual offset
1396     // from the containing block edge in its measurement. textPos() should be consistent so the text are rendered in the same width.
1397     if (logicalLeft() == 0)
1398         return 0;
1399     return logicalLeft() - root().logicalLeft();
1400 }
1401
1402 int InlineTextBox::offsetForPosition(float lineOffset, bool includePartialGlyphs) const
1403 {
1404     if (isLineBreak())
1405         return 0;
1406
1407     if (lineOffset - logicalLeft() > logicalWidth())
1408         return isLeftToRightDirection() ? len() : 0;
1409     if (lineOffset - logicalLeft() < 0)
1410         return isLeftToRightDirection() ? 0 : len();
1411
1412     FontCachePurgePreventer fontCachePurgePreventer;
1413
1414     const RenderStyle& lineStyle = this->lineStyle();
1415     const Font& font = fontToUse(lineStyle, renderer());
1416     return font.offsetForPosition(constructTextRun(lineStyle, font), lineOffset - logicalLeft(), includePartialGlyphs);
1417 }
1418
1419 float InlineTextBox::positionForOffset(int offset) const
1420 {
1421     ASSERT(offset >= m_start);
1422     ASSERT(offset <= m_start + m_len);
1423
1424     if (isLineBreak())
1425         return logicalLeft();
1426
1427     FontCachePurgePreventer fontCachePurgePreventer;
1428
1429     const RenderStyle& lineStyle = this->lineStyle();
1430     const Font& font = fontToUse(lineStyle, renderer());
1431     int from = !isLeftToRightDirection() ? offset - m_start : 0;
1432     int to = !isLeftToRightDirection() ? m_len : offset - m_start;
1433     // FIXME: Do we need to add rightBearing here?
1434     return font.selectionRectForText(constructTextRun(lineStyle, font), IntPoint(logicalLeft(), 0), 0, from, to).maxX();
1435 }
1436
1437 TextRun InlineTextBox::constructTextRun(const RenderStyle& style, const Font& font, BufferForAppendingHyphen* charactersWithHyphen) const
1438 {
1439     ASSERT(renderer().text());
1440
1441     String string = renderer().text();
1442     unsigned startPos = start();
1443     unsigned length = len();
1444
1445     if (string.length() != length || startPos)
1446         string = string.substringSharingImpl(startPos, length);
1447
1448     return constructTextRun(style, font, string, renderer().textLength() - startPos, charactersWithHyphen);
1449 }
1450
1451 TextRun InlineTextBox::constructTextRun(const RenderStyle& style, const Font& font, String string, int maximumLength, BufferForAppendingHyphen* charactersWithHyphen) const
1452 {
1453     int length = string.length();
1454
1455     if (charactersWithHyphen) {
1456         adjustCharactersAndLengthForHyphen(*charactersWithHyphen, style, string, length);
1457         maximumLength = length;
1458     }
1459
1460     ASSERT(maximumLength >= length);
1461
1462     TextRun run(string, textPos(), expansion(), expansionBehavior(), direction(), dirOverride() || style.rtlOrdering() == VisualOrder, !renderer().canUseSimpleFontCodePath());
1463     run.setTabSize(!style.collapseWhiteSpace(), style.tabSize());
1464     if (font.isSVGFont())
1465         run.setRenderingContext(SVGTextRunRenderingContext::create(renderer()));
1466
1467     // Propagate the maximum length of the characters buffer to the TextRun, even when we're only processing a substring.
1468     run.setCharactersLength(maximumLength);
1469     ASSERT(run.charactersLength() >= run.length());
1470     return run;
1471 }
1472
1473 #ifndef NDEBUG
1474
1475 const char* InlineTextBox::boxName() const
1476 {
1477     return "InlineTextBox";
1478 }
1479
1480 void InlineTextBox::showBox(int printedCharacters) const
1481 {
1482     String value = renderer().text();
1483     value = value.substring(start(), len());
1484     value.replaceWithLiteral('\\', "\\\\");
1485     value.replaceWithLiteral('\n', "\\n");
1486     printedCharacters += fprintf(stderr, "%s\t%p", boxName(), this);
1487     for (; printedCharacters < showTreeCharacterOffset; printedCharacters++)
1488         fputc(' ', stderr);
1489     printedCharacters = fprintf(stderr, "\t%s %p", renderer().renderName(), &renderer());
1490     const int rendererCharacterOffset = 24;
1491     for (; printedCharacters < rendererCharacterOffset; printedCharacters++)
1492         fputc(' ', stderr);
1493     fprintf(stderr, "(%d,%d) \"%s\"\n", start(), start() + len(), value.utf8().data());
1494 }
1495
1496 #endif
1497
1498 } // namespace WebCore