aff87563f36753dfcd20a54cb5af87780cc59b1b
[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 alignSelectionRectToDevicePixels(FloatRect& rect)
716 {
717     float maxX = floorf(rect.maxX());
718     rect.setX(floorf(rect.x()));
719     rect.setWidth(roundf(maxX - rect.x()));
720 }
721
722 void InlineTextBox::paintSelection(GraphicsContext* context, const FloatPoint& boxOrigin, const RenderStyle& style, const Font& font, Color textColor)
723 {
724 #if ENABLE(TEXT_SELECTION)
725     if (context->paintingDisabled())
726         return;
727
728     // See if we have a selection to paint at all.
729     int sPos, ePos;
730     selectionStartEnd(sPos, ePos);
731     if (sPos >= ePos)
732         return;
733
734     Color c = renderer().selectionBackgroundColor();
735     if (!c.isValid() || c.alpha() == 0)
736         return;
737
738     // If the text color ends up being the same as the selection background, invert the selection
739     // background.
740     if (textColor == c)
741         c = Color(0xff - c.red(), 0xff - c.green(), 0xff - c.blue());
742
743     GraphicsContextStateSaver stateSaver(*context);
744     updateGraphicsContext(*context, TextPaintStyle(c, style.colorSpace())); // Don't draw text at all!
745     
746     // If the text is truncated, let the thing being painted in the truncation
747     // draw its own highlight.
748     int length = m_truncation != cNoTruncation ? m_truncation : m_len;
749     String string = renderer().text();
750
751     if (string.length() != static_cast<unsigned>(length) || m_start) {
752         ASSERT_WITH_SECURITY_IMPLICATION(static_cast<unsigned>(m_start + length) <= string.length());
753         string = string.substringSharingImpl(m_start, length);
754     }
755
756     BufferForAppendingHyphen charactersWithHyphen;
757     bool respectHyphen = ePos == length && hasHyphen();
758     TextRun textRun = constructTextRun(style, font, string, renderer().textLength() - m_start, respectHyphen ? &charactersWithHyphen : 0);
759     if (respectHyphen)
760         ePos = textRun.length();
761
762     const RootInlineBox& rootBox = root();
763     LayoutUnit selectionBottom = rootBox.selectionBottom();
764     LayoutUnit selectionTop = rootBox.selectionTopAdjustedForPrecedingBlock();
765
766     int deltaY = roundToInt(renderer().style().isFlippedLinesWritingMode() ? selectionBottom - logicalBottom() : logicalTop() - selectionTop);
767     int selHeight = std::max(0, roundToInt(selectionBottom - selectionTop));
768
769     FloatPoint localOrigin(boxOrigin.x(), boxOrigin.y() - deltaY);
770     FloatRect clipRect(localOrigin, FloatSize(m_logicalWidth, selHeight));
771     alignSelectionRectToDevicePixels(clipRect);
772
773     context->clip(clipRect);
774
775     context->drawHighlightForText(font, textRun, localOrigin, selHeight, c, style.colorSpace(), sPos, ePos);
776 #else
777     UNUSED_PARAM(context);
778     UNUSED_PARAM(boxOrigin);
779     UNUSED_PARAM(style);
780     UNUSED_PARAM(font);
781     UNUSED_PARAM(textColor);
782 #endif
783 }
784
785 void InlineTextBox::paintCompositionBackground(GraphicsContext* context, const FloatPoint& boxOrigin, const RenderStyle& style, const Font& font, int startPos, int endPos)
786 {
787     int offset = m_start;
788     int sPos = std::max(startPos - offset, 0);
789     int ePos = std::min(endPos - offset, (int)m_len);
790
791     if (sPos >= ePos)
792         return;
793
794     GraphicsContextStateSaver stateSaver(*context);
795
796 #if !PLATFORM(IOS)
797     // FIXME: Is this color still applicable as of Mavericks? for non-Mac ports? We should
798     // be able to move this color information to RenderStyle.
799     Color c = Color(225, 221, 85);
800 #else
801     Color c = style.compositionFillColor();
802 #endif
803     
804     updateGraphicsContext(*context, TextPaintStyle(c, style.colorSpace())); // Don't draw text at all!
805
806     int deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom() - logicalBottom() : logicalTop() - selectionTop();
807     int selHeight = selectionHeight();
808     FloatPoint localOrigin(boxOrigin.x(), boxOrigin.y() - deltaY);
809     context->drawHighlightForText(font, constructTextRun(style, font), localOrigin, selHeight, c, style.colorSpace(), sPos, ePos);
810 }
811
812 static StrokeStyle textDecorationStyleToStrokeStyle(TextDecorationStyle decorationStyle)
813 {
814     StrokeStyle strokeStyle = SolidStroke;
815     switch (decorationStyle) {
816     case TextDecorationStyleSolid:
817         strokeStyle = SolidStroke;
818         break;
819     case TextDecorationStyleDouble:
820         strokeStyle = DoubleStroke;
821         break;
822     case TextDecorationStyleDotted:
823         strokeStyle = DottedStroke;
824         break;
825     case TextDecorationStyleDashed:
826         strokeStyle = DashedStroke;
827         break;
828     case TextDecorationStyleWavy:
829         strokeStyle = WavyStroke;
830         break;
831     }
832
833     return strokeStyle;
834 }
835
836 static int computeUnderlineOffset(const TextUnderlinePosition underlinePosition, const FontMetrics& fontMetrics, const InlineTextBox* inlineTextBox, const int textDecorationThickness)
837 {
838     // Compute the gap between the font and the underline. Use at least one
839     // pixel gap, if underline is thick then use a bigger gap.
840     const int gap = std::max<int>(1, ceilf(textDecorationThickness / 2.0));
841
842     // According to the specification TextUnderlinePositionAuto should default to 'alphabetic' for horizontal text
843     // and to 'under Left' for vertical text (e.g. japanese). We support only horizontal text for now.
844     switch (underlinePosition) {
845     case TextUnderlinePositionAlphabetic:
846     case TextUnderlinePositionAuto:
847         return fontMetrics.ascent() + gap; // Position underline near the alphabetic baseline.
848     case TextUnderlinePositionUnder: {
849         // Position underline relative to the under edge of the lowest element's content box.
850         const float offset = inlineTextBox->root().maxLogicalTop() - inlineTextBox->logicalTop();
851         return inlineTextBox->logicalHeight() + gap + std::max<float>(offset, 0);
852     }
853     }
854
855     ASSERT_NOT_REACHED();
856     return fontMetrics.ascent() + gap;
857 }
858
859 static void adjustStepToDecorationLength(float& step, float& controlPointDistance, float length)
860 {
861     ASSERT(step > 0);
862
863     if (length <= 0)
864         return;
865
866     unsigned stepCount = static_cast<unsigned>(length / step);
867
868     // Each Bezier curve starts at the same pixel that the previous one
869     // ended. We need to subtract (stepCount - 1) pixels when calculating the
870     // length covered to account for that.
871     float uncoveredLength = length - (stepCount * step - (stepCount - 1));
872     float adjustment = uncoveredLength / stepCount;
873     step += adjustment;
874     controlPointDistance += adjustment;
875 }
876
877 static void getWavyStrokeParameters(float strokeThickness, float& controlPointDistance, float& step)
878 {
879     // Distance between decoration's axis and Bezier curve's control points.
880     // The height of the curve is based on this distance. Use a minimum of 6 pixels distance since
881     // the actual curve passes approximately at half of that distance, that is 3 pixels.
882     // The minimum height of the curve is also approximately 3 pixels. Increases the curve's height
883     // as strockThickness increases to make the curve looks better.
884     controlPointDistance = 3 * std::max<float>(2, strokeThickness);
885
886     // Increment used to form the diamond shape between start point (p1), control
887     // points and end point (p2) along the axis of the decoration. Makes the
888     // curve wider as strockThickness increases to make the curve looks better.
889     step = 2 * std::max<float>(2, strokeThickness);
890 }
891
892 /*
893  * Draw one cubic Bezier curve and repeat the same pattern long the the decoration's axis.
894  * The start point (p1), controlPoint1, controlPoint2 and end point (p2) of the Bezier curve
895  * form a diamond shape:
896  *
897  *                              step
898  *                         |-----------|
899  *
900  *                   controlPoint1
901  *                         +
902  *
903  *
904  *                  . .
905  *                .     .
906  *              .         .
907  * (x1, y1) p1 +           .            + p2 (x2, y2) - <--- Decoration's axis
908  *                          .         .               |
909  *                            .     .                 |
910  *                              . .                   | controlPointDistance
911  *                                                    |
912  *                                                    |
913  *                         +                          -
914  *                   controlPoint2
915  *
916  *             |-----------|
917  *                 step
918  */
919 static void strokeWavyTextDecoration(GraphicsContext& context, FloatPoint& p1, FloatPoint& p2, float strokeThickness)
920 {
921     context.adjustLineToPixelBoundaries(p1, p2, strokeThickness, context.strokeStyle());
922
923     Path path;
924     path.moveTo(p1);
925
926     float controlPointDistance;
927     float step;
928     getWavyStrokeParameters(strokeThickness, controlPointDistance, step);
929
930     bool isVerticalLine = (p1.x() == p2.x());
931
932     if (isVerticalLine) {
933         ASSERT(p1.x() == p2.x());
934
935         float xAxis = p1.x();
936         float y1;
937         float y2;
938
939         if (p1.y() < p2.y()) {
940             y1 = p1.y();
941             y2 = p2.y();
942         } else {
943             y1 = p2.y();
944             y2 = p1.y();
945         }
946
947         adjustStepToDecorationLength(step, controlPointDistance, y2 - y1);
948         FloatPoint controlPoint1(xAxis + controlPointDistance, 0);
949         FloatPoint controlPoint2(xAxis - controlPointDistance, 0);
950
951         for (float y = y1; y + 2 * step <= y2;) {
952             controlPoint1.setY(y + step);
953             controlPoint2.setY(y + step);
954             y += 2 * step;
955             path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(xAxis, y));
956         }
957     } else {
958         ASSERT(p1.y() == p2.y());
959
960         float yAxis = p1.y();
961         float x1;
962         float x2;
963
964         if (p1.x() < p2.x()) {
965             x1 = p1.x();
966             x2 = p2.x();
967         } else {
968             x1 = p2.x();
969             x2 = p1.x();
970         }
971
972         adjustStepToDecorationLength(step, controlPointDistance, x2 - x1);
973         FloatPoint controlPoint1(0, yAxis + controlPointDistance);
974         FloatPoint controlPoint2(0, yAxis - controlPointDistance);
975
976         for (float x = x1; x + 2 * step <= x2;) {
977             controlPoint1.setX(x + step);
978             controlPoint2.setX(x + step);
979             x += 2 * step;
980             path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(x, yAxis));
981         }
982     }
983
984     context.setShouldAntialias(true);
985     context.strokePath(path);
986 }
987
988 void InlineTextBox::paintDecoration(GraphicsContext& context, const FloatPoint& boxOrigin, TextDecoration decoration, TextDecorationStyle decorationStyle, const ShadowData* shadow, TextPainter& textPainter)
989 {
990 #if !ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
991     UNUSED_PARAM(textPainter);
992 #endif
993
994     // FIXME: We should improve this rule and not always just assume 1.
995     const float textDecorationThickness = 1.f;
996
997     if (m_truncation == cFullTruncation)
998         return;
999
1000     FloatPoint localOrigin = boxOrigin;
1001
1002     float width = m_logicalWidth;
1003     if (m_truncation != cNoTruncation) {
1004         width = renderer().width(m_start, m_truncation, textPos(), isFirstLine());
1005         if (!isLeftToRightDirection())
1006             localOrigin.move(m_logicalWidth - width, 0);
1007     }
1008     
1009     // Get the text decoration colors.
1010     Color underline, overline, linethrough;
1011     renderer().getTextDecorationColors(decoration, underline, overline, linethrough, true);
1012     if (isFirstLine())
1013         renderer().getTextDecorationColors(decoration, underline, overline, linethrough, true, true);
1014     
1015     // Use a special function for underlines to get the positioning exactly right.
1016     bool isPrinting = renderer().document().printing();
1017
1018     const float textDecorationBaseFontSize = 16;
1019     float fontSizeScaling = renderer().style().fontSize() / textDecorationBaseFontSize;
1020     float strokeThickness = roundf(textDecorationThickness * fontSizeScaling);
1021     context.setStrokeThickness(strokeThickness);
1022
1023     bool linesAreOpaque = !isPrinting && (!(decoration & TextDecorationUnderline) || underline.alpha() == 255) && (!(decoration & TextDecorationOverline) || overline.alpha() == 255) && (!(decoration & TextDecorationLineThrough) || linethrough.alpha() == 255);
1024
1025     const RenderStyle& lineStyle = this->lineStyle();
1026     int baseline = lineStyle.fontMetrics().ascent();
1027
1028     bool setClip = false;
1029     int extraOffset = 0;
1030     if (!linesAreOpaque && shadow && shadow->next()) {
1031         FloatRect clipRect(localOrigin, FloatSize(width, baseline + 2));
1032         for (const ShadowData* s = shadow; s; s = s->next()) {
1033             int shadowExtent = s->paintingExtent();
1034             FloatRect shadowRect(localOrigin, FloatSize(width, baseline + 2));
1035             shadowRect.inflate(shadowExtent);
1036             int shadowX = isHorizontal() ? s->x() : s->y();
1037             int shadowY = isHorizontal() ? s->y() : -s->x();
1038             shadowRect.move(shadowX, shadowY);
1039             clipRect.unite(shadowRect);
1040             extraOffset = std::max(extraOffset, std::max(0, shadowY) + shadowExtent);
1041         }
1042         context.save();
1043         context.clip(clipRect);
1044         extraOffset += baseline + 2;
1045         localOrigin.move(0, extraOffset);
1046         setClip = true;
1047     }
1048
1049     ColorSpace colorSpace = renderer().style().colorSpace();
1050     bool setShadow = false;
1051
1052     do {
1053         if (shadow) {
1054             if (!shadow->next()) {
1055                 // The last set of lines paints normally inside the clip.
1056                 localOrigin.move(0, -extraOffset);
1057                 extraOffset = 0;
1058             }
1059             int shadowX = isHorizontal() ? shadow->x() : shadow->y();
1060             int shadowY = isHorizontal() ? shadow->y() : -shadow->x();
1061             context.setShadow(FloatSize(shadowX, shadowY - extraOffset), shadow->radius(), shadow->color(), colorSpace);
1062             setShadow = true;
1063             shadow = shadow->next();
1064         }
1065         
1066         float wavyOffset = 2.f;
1067
1068         context.setStrokeStyle(textDecorationStyleToStrokeStyle(decorationStyle));
1069         if (decoration & TextDecorationUnderline) {
1070             context.setStrokeColor(underline, colorSpace);
1071             TextUnderlinePosition underlinePosition = lineStyle.textUnderlinePosition();
1072             const int underlineOffset = computeUnderlineOffset(underlinePosition, lineStyle.fontMetrics(), this, textDecorationThickness);
1073
1074             switch (decorationStyle) {
1075             case TextDecorationStyleWavy: {
1076                 FloatPoint start(localOrigin.x(), localOrigin.y() + underlineOffset + wavyOffset);
1077                 FloatPoint end(localOrigin.x() + width, localOrigin.y() + underlineOffset + wavyOffset);
1078                 strokeWavyTextDecoration(context, start, end, textDecorationThickness);
1079                 break;
1080             }
1081             default:
1082 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
1083                 if ((lineStyle.textDecorationSkip() == TextDecorationSkipInk || lineStyle.textDecorationSkip() == TextDecorationSkipAuto) && isHorizontal()) {
1084                     if (!context.paintingDisabled()) {
1085                         drawSkipInkUnderline(textPainter, context, localOrigin, underlineOffset, width, isPrinting, decorationStyle == TextDecorationStyleDouble);
1086                     }
1087                 } else
1088                     // FIXME: Need to support text-decoration-skip: none.
1089 #endif // CSS3_TEXT_DECORATION_SKIP_INK
1090                     context.drawLineForText(FloatPoint(localOrigin.x(), localOrigin.y() + underlineOffset), width, isPrinting, decorationStyle == TextDecorationStyleDouble);
1091             }
1092         }
1093         if (decoration & TextDecorationOverline) {
1094             context.setStrokeColor(overline, colorSpace);
1095             switch (decorationStyle) {
1096             case TextDecorationStyleWavy: {
1097                 FloatPoint start(localOrigin.x(), localOrigin.y() - wavyOffset);
1098                 FloatPoint end(localOrigin.x() + width, localOrigin.y() - wavyOffset);
1099                 strokeWavyTextDecoration(context, start, end, textDecorationThickness);
1100                 break;
1101             }
1102             default:
1103 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
1104                 if ((lineStyle.textDecorationSkip() == TextDecorationSkipInk || lineStyle.textDecorationSkip() == TextDecorationSkipAuto) && isHorizontal()) {
1105                     if (!context.paintingDisabled())
1106                         drawSkipInkUnderline(textPainter, context, localOrigin, 0, width, isPrinting, decorationStyle == TextDecorationStyleDouble);
1107                 } else
1108                     // FIXME: Need to support text-decoration-skip: none.
1109 #endif // CSS3_TEXT_DECORATION_SKIP_INK
1110                     context.drawLineForText(localOrigin, width, isPrinting, decorationStyle == TextDecorationStyleDouble);
1111             }
1112         }
1113         if (decoration & TextDecorationLineThrough) {
1114             context.setStrokeColor(linethrough, colorSpace);
1115             switch (decorationStyle) {
1116             case TextDecorationStyleWavy: {
1117                 FloatPoint start(localOrigin.x(), localOrigin.y() + 2 * baseline / 3);
1118                 FloatPoint end(localOrigin.x() + width, localOrigin.y() + 2 * baseline / 3);
1119                 strokeWavyTextDecoration(context, start, end, textDecorationThickness);
1120                 break;
1121             }
1122             default:
1123                 context.drawLineForText(FloatPoint(localOrigin.x(), localOrigin.y() + 2 * baseline / 3), width, isPrinting, decorationStyle == TextDecorationStyleDouble);
1124             }
1125         }
1126     } while (shadow);
1127
1128     if (setClip)
1129         context.restore();
1130     else if (setShadow)
1131         context.clearShadow();
1132 }
1133
1134 static GraphicsContext::DocumentMarkerLineStyle lineStyleForMarkerType(DocumentMarker::MarkerType markerType)
1135 {
1136     switch (markerType) {
1137     case DocumentMarker::Spelling:
1138         return GraphicsContext::DocumentMarkerSpellingLineStyle;
1139     case DocumentMarker::Grammar:
1140         return GraphicsContext::DocumentMarkerGrammarLineStyle;
1141     case DocumentMarker::CorrectionIndicator:
1142         return GraphicsContext::DocumentMarkerAutocorrectionReplacementLineStyle;
1143     case DocumentMarker::DictationAlternatives:
1144         return GraphicsContext::DocumentMarkerDictationAlternativesLineStyle;
1145 #if PLATFORM(IOS)
1146     case DocumentMarker::DictationPhraseWithAlternatives:
1147         // FIXME: Rename TextCheckingDictationPhraseWithAlternativesLineStyle and remove the PLATFORM(IOS)-guard.
1148         return GraphicsContext::TextCheckingDictationPhraseWithAlternativesLineStyle;
1149 #endif
1150     default:
1151         ASSERT_NOT_REACHED();
1152         return GraphicsContext::DocumentMarkerSpellingLineStyle;
1153     }
1154 }
1155
1156 void InlineTextBox::paintDocumentMarker(GraphicsContext* pt, const FloatPoint& boxOrigin, DocumentMarker* marker, const RenderStyle& style, const Font& font, bool grammar)
1157 {
1158     // Never print spelling/grammar markers (5327887)
1159     if (renderer().document().printing())
1160         return;
1161
1162     if (m_truncation == cFullTruncation)
1163         return;
1164
1165     float start = 0; // start of line to draw, relative to tx
1166     float width = m_logicalWidth; // how much line to draw
1167
1168     // Determine whether we need to measure text
1169     bool markerSpansWholeBox = true;
1170     if (m_start <= (int)marker->startOffset())
1171         markerSpansWholeBox = false;
1172     if ((end() + 1) != marker->endOffset()) // end points at the last char, not past it
1173         markerSpansWholeBox = false;
1174     if (m_truncation != cNoTruncation)
1175         markerSpansWholeBox = false;
1176
1177     bool isDictationMarker = marker->type() == DocumentMarker::DictationAlternatives;
1178     if (!markerSpansWholeBox || grammar || isDictationMarker) {
1179         int startPosition = std::max<int>(marker->startOffset() - m_start, 0);
1180         int endPosition = std::min<int>(marker->endOffset() - m_start, m_len);
1181         
1182         if (m_truncation != cNoTruncation)
1183             endPosition = std::min<int>(endPosition, m_truncation);
1184
1185         // Calculate start & width
1186         int deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom() - logicalBottom() : logicalTop() - selectionTop();
1187         int selHeight = selectionHeight();
1188         FloatPoint startPoint(boxOrigin.x(), boxOrigin.y() - deltaY);
1189         TextRun run = constructTextRun(style, font);
1190
1191         // FIXME: Convert the document markers to float rects.
1192         IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, startPoint, selHeight, startPosition, endPosition));
1193         start = markerRect.x() - startPoint.x();
1194         width = markerRect.width();
1195         
1196         // Store rendered rects for bad grammar markers, so we can hit-test against it elsewhere in order to
1197         // display a toolTip. We don't do this for misspelling markers.
1198         if (grammar || isDictationMarker) {
1199             markerRect.move(-boxOrigin.x(), -boxOrigin.y());
1200             markerRect = renderer().localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
1201             toRenderedDocumentMarker(marker)->setRenderedRect(markerRect);
1202         }
1203     }
1204     
1205     // IMPORTANT: The misspelling underline is not considered when calculating the text bounds, so we have to
1206     // make sure to fit within those bounds.  This means the top pixel(s) of the underline will overlap the
1207     // bottom pixel(s) of the glyphs in smaller font sizes.  The alternatives are to increase the line spacing (bad!!)
1208     // or decrease the underline thickness.  The overlap is actually the most useful, and matches what AppKit does.
1209     // So, we generally place the underline at the bottom of the text, but in larger fonts that's not so good so
1210     // we pin to two pixels under the baseline.
1211     int lineThickness = cMisspellingLineThickness;
1212     int baseline = lineStyle().fontMetrics().ascent();
1213     int descent = logicalHeight() - baseline;
1214     int underlineOffset;
1215     if (descent <= (2 + lineThickness)) {
1216         // Place the underline at the very bottom of the text in small/medium fonts.
1217         underlineOffset = logicalHeight() - lineThickness;
1218     } else {
1219         // In larger fonts, though, place the underline up near the baseline to prevent a big gap.
1220         underlineOffset = baseline + 2;
1221     }
1222     pt->drawLineForDocumentMarker(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + underlineOffset), width, lineStyleForMarkerType(marker->type()));
1223 }
1224
1225 void InlineTextBox::paintTextMatchMarker(GraphicsContext* pt, const FloatPoint& boxOrigin, DocumentMarker* marker, const RenderStyle& style, const Font& font)
1226 {
1227     // Use same y positioning and height as for selection, so that when the selection and this highlight are on
1228     // the same word there are no pieces sticking out.
1229     int deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom() - logicalBottom() : logicalTop() - selectionTop();
1230     int selHeight = selectionHeight();
1231
1232     int sPos = std::max(marker->startOffset() - m_start, (unsigned)0);
1233     int ePos = std::min(marker->endOffset() - m_start, (unsigned)m_len);
1234     TextRun run = constructTextRun(style, font);
1235
1236     // Always compute and store the rect associated with this marker. The computed rect is in absolute coordinates.
1237     IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, IntPoint(x(), selectionTop()), selHeight, sPos, ePos));
1238     markerRect = renderer().localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
1239     toRenderedDocumentMarker(marker)->setRenderedRect(markerRect);
1240     
1241     // Optionally highlight the text
1242     if (renderer().frame().editor().markedTextMatchesAreHighlighted()) {
1243         Color color = marker->activeMatch() ? renderer().theme().platformActiveTextSearchHighlightColor() : renderer().theme().platformInactiveTextSearchHighlightColor();
1244         GraphicsContextStateSaver stateSaver(*pt);
1245         updateGraphicsContext(*pt, TextPaintStyle(color, style.colorSpace())); // Don't draw text at all!
1246         pt->clip(FloatRect(boxOrigin.x(), boxOrigin.y() - deltaY, m_logicalWidth, selHeight));
1247         pt->drawHighlightForText(font, run, FloatPoint(boxOrigin.x(), boxOrigin.y() - deltaY), selHeight, color, style.colorSpace(), sPos, ePos);
1248     }
1249 }
1250
1251 void InlineTextBox::computeRectForReplacementMarker(DocumentMarker* marker, const RenderStyle& style, const Font& font)
1252 {
1253     // Replacement markers are not actually drawn, but their rects need to be computed for hit testing.
1254     int top = selectionTop();
1255     int h = selectionHeight();
1256     
1257     int sPos = std::max(marker->startOffset() - m_start, (unsigned)0);
1258     int ePos = std::min(marker->endOffset() - m_start, (unsigned)m_len);
1259     TextRun run = constructTextRun(style, font);
1260     IntPoint startPoint = IntPoint(x(), top);
1261     
1262     // Compute and store the rect associated with this marker.
1263     IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, startPoint, h, sPos, ePos));
1264     markerRect = renderer().localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
1265     toRenderedDocumentMarker(marker)->setRenderedRect(markerRect);
1266 }
1267     
1268 void InlineTextBox::paintDocumentMarkers(GraphicsContext* pt, const FloatPoint& boxOrigin, const RenderStyle& style, const Font& font, bool background)
1269 {
1270     if (!renderer().textNode())
1271         return;
1272
1273     Vector<DocumentMarker*> markers = renderer().document().markers().markersFor(renderer().textNode());
1274     Vector<DocumentMarker*>::const_iterator markerIt = markers.begin();
1275
1276     // Give any document markers that touch this run a chance to draw before the text has been drawn.
1277     // Note end() points at the last char, not one past it like endOffset and ranges do.
1278     for ( ; markerIt != markers.end(); ++markerIt) {
1279         DocumentMarker* marker = *markerIt;
1280         
1281         // Paint either the background markers or the foreground markers, but not both
1282         switch (marker->type()) {
1283             case DocumentMarker::Grammar:
1284             case DocumentMarker::Spelling:
1285             case DocumentMarker::CorrectionIndicator:
1286             case DocumentMarker::Replacement:
1287             case DocumentMarker::DictationAlternatives:
1288 #if PLATFORM(IOS)
1289             // FIXME: Remove the PLATFORM(IOS)-guard.
1290             case DocumentMarker::DictationPhraseWithAlternatives:
1291 #endif
1292                 if (background)
1293                     continue;
1294                 break;
1295             case DocumentMarker::TextMatch:
1296 #if ENABLE(TELEPHONE_NUMBER_DETECTION)
1297             case DocumentMarker::TelephoneNumber:
1298 #endif
1299                 if (!background)
1300                     continue;
1301                 break;
1302             default:
1303                 continue;
1304         }
1305
1306         if (marker->endOffset() <= start())
1307             // marker is completely before this run.  This might be a marker that sits before the
1308             // first run we draw, or markers that were within runs we skipped due to truncation.
1309             continue;
1310         
1311         if (marker->startOffset() > end())
1312             // marker is completely after this run, bail.  A later run will paint it.
1313             break;
1314         
1315         // marker intersects this run.  Paint it.
1316         switch (marker->type()) {
1317             case DocumentMarker::Spelling:
1318             case DocumentMarker::CorrectionIndicator:
1319             case DocumentMarker::DictationAlternatives:
1320                 paintDocumentMarker(pt, boxOrigin, marker, style, font, false);
1321                 break;
1322             case DocumentMarker::Grammar:
1323                 paintDocumentMarker(pt, boxOrigin, marker, style, font, true);
1324                 break;
1325 #if PLATFORM(IOS)
1326             // FIXME: See <rdar://problem/8933352>. Also, remove the PLATFORM(IOS)-guard.
1327             case DocumentMarker::DictationPhraseWithAlternatives:
1328                 paintDocumentMarker(pt, boxOrigin, marker, style, font, true);
1329                 break;
1330 #endif
1331             case DocumentMarker::TextMatch:
1332                 paintTextMatchMarker(pt, boxOrigin, marker, style, font);
1333                 break;
1334             case DocumentMarker::Replacement:
1335                 computeRectForReplacementMarker(marker, style, font);
1336                 break;
1337 #if ENABLE(TELEPHONE_NUMBER_DETECTION)
1338             case DocumentMarker::TelephoneNumber:
1339                 break;
1340 #endif
1341             default:
1342                 ASSERT_NOT_REACHED();
1343         }
1344
1345     }
1346 }
1347
1348 void InlineTextBox::paintCompositionUnderline(GraphicsContext* ctx, const FloatPoint& boxOrigin, const CompositionUnderline& underline)
1349 {
1350     if (m_truncation == cFullTruncation)
1351         return;
1352     
1353     float start = 0; // start of line to draw, relative to tx
1354     float width = m_logicalWidth; // how much line to draw
1355     bool useWholeWidth = true;
1356     unsigned paintStart = m_start;
1357     unsigned paintEnd = end() + 1; // end points at the last char, not past it
1358     if (paintStart <= underline.startOffset) {
1359         paintStart = underline.startOffset;
1360         useWholeWidth = false;
1361         start = renderer().width(m_start, paintStart - m_start, textPos(), isFirstLine());
1362     }
1363     if (paintEnd != underline.endOffset) {      // end points at the last char, not past it
1364         paintEnd = std::min(paintEnd, (unsigned)underline.endOffset);
1365         useWholeWidth = false;
1366     }
1367     if (m_truncation != cNoTruncation) {
1368         paintEnd = std::min(paintEnd, (unsigned)m_start + m_truncation);
1369         useWholeWidth = false;
1370     }
1371     if (!useWholeWidth) {
1372         width = renderer().width(paintStart, paintEnd - paintStart, textPos() + start, isFirstLine());
1373     }
1374
1375     // Thick marked text underlines are 2px thick as long as there is room for the 2px line under the baseline.
1376     // All other marked text underlines are 1px thick.
1377     // If there's not enough space the underline will touch or overlap characters.
1378     int lineThickness = 1;
1379     int baseline = lineStyle().fontMetrics().ascent();
1380     if (underline.thick && logicalHeight() - baseline >= 2)
1381         lineThickness = 2;
1382
1383     // We need to have some space between underlines of subsequent clauses, because some input methods do not use different underline styles for those.
1384     // We make each line shorter, which has a harmless side effect of shortening the first and last clauses, too.
1385     start += 1;
1386     width -= 2;
1387
1388     ctx->setStrokeColor(underline.color, renderer().style().colorSpace());
1389     ctx->setStrokeThickness(lineThickness);
1390     ctx->drawLineForText(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + logicalHeight() - lineThickness), width, renderer().document().printing());
1391 }
1392
1393 int InlineTextBox::caretMinOffset() const
1394 {
1395     return m_start;
1396 }
1397
1398 int InlineTextBox::caretMaxOffset() const
1399 {
1400     return m_start + m_len;
1401 }
1402
1403 float InlineTextBox::textPos() const
1404 {
1405     // When computing the width of a text run, RenderBlock::computeInlineDirectionPositionsForLine() doesn't include the actual offset
1406     // from the containing block edge in its measurement. textPos() should be consistent so the text are rendered in the same width.
1407     if (logicalLeft() == 0)
1408         return 0;
1409     return logicalLeft() - root().logicalLeft();
1410 }
1411
1412 int InlineTextBox::offsetForPosition(float lineOffset, bool includePartialGlyphs) const
1413 {
1414     if (isLineBreak())
1415         return 0;
1416
1417     if (lineOffset - logicalLeft() > logicalWidth())
1418         return isLeftToRightDirection() ? len() : 0;
1419     if (lineOffset - logicalLeft() < 0)
1420         return isLeftToRightDirection() ? 0 : len();
1421
1422     FontCachePurgePreventer fontCachePurgePreventer;
1423
1424     const RenderStyle& lineStyle = this->lineStyle();
1425     const Font& font = fontToUse(lineStyle, renderer());
1426     return font.offsetForPosition(constructTextRun(lineStyle, font), lineOffset - logicalLeft(), includePartialGlyphs);
1427 }
1428
1429 float InlineTextBox::positionForOffset(int offset) const
1430 {
1431     ASSERT(offset >= m_start);
1432     ASSERT(offset <= m_start + m_len);
1433
1434     if (isLineBreak())
1435         return logicalLeft();
1436
1437     FontCachePurgePreventer fontCachePurgePreventer;
1438
1439     const RenderStyle& lineStyle = this->lineStyle();
1440     const Font& font = fontToUse(lineStyle, renderer());
1441     int from = !isLeftToRightDirection() ? offset - m_start : 0;
1442     int to = !isLeftToRightDirection() ? m_len : offset - m_start;
1443     // FIXME: Do we need to add rightBearing here?
1444     return font.selectionRectForText(constructTextRun(lineStyle, font), IntPoint(logicalLeft(), 0), 0, from, to).maxX();
1445 }
1446
1447 TextRun InlineTextBox::constructTextRun(const RenderStyle& style, const Font& font, BufferForAppendingHyphen* charactersWithHyphen) const
1448 {
1449     ASSERT(renderer().text());
1450
1451     String string = renderer().text();
1452     unsigned startPos = start();
1453     unsigned length = len();
1454
1455     if (string.length() != length || startPos)
1456         string = string.substringSharingImpl(startPos, length);
1457
1458     return constructTextRun(style, font, string, renderer().textLength() - startPos, charactersWithHyphen);
1459 }
1460
1461 TextRun InlineTextBox::constructTextRun(const RenderStyle& style, const Font& font, String string, int maximumLength, BufferForAppendingHyphen* charactersWithHyphen) const
1462 {
1463     int length = string.length();
1464
1465     if (charactersWithHyphen) {
1466         adjustCharactersAndLengthForHyphen(*charactersWithHyphen, style, string, length);
1467         maximumLength = length;
1468     }
1469
1470     ASSERT(maximumLength >= length);
1471
1472     TextRun run(string, textPos(), expansion(), expansionBehavior(), direction(), dirOverride() || style.rtlOrdering() == VisualOrder, !renderer().canUseSimpleFontCodePath());
1473     run.setTabSize(!style.collapseWhiteSpace(), style.tabSize());
1474     if (font.isSVGFont())
1475         run.setRenderingContext(SVGTextRunRenderingContext::create(renderer()));
1476
1477     // Propagate the maximum length of the characters buffer to the TextRun, even when we're only processing a substring.
1478     run.setCharactersLength(maximumLength);
1479     ASSERT(run.charactersLength() >= run.length());
1480     return run;
1481 }
1482
1483 #ifndef NDEBUG
1484
1485 const char* InlineTextBox::boxName() const
1486 {
1487     return "InlineTextBox";
1488 }
1489
1490 void InlineTextBox::showBox(int printedCharacters) const
1491 {
1492     String value = renderer().text();
1493     value = value.substring(start(), len());
1494     value.replaceWithLiteral('\\', "\\\\");
1495     value.replaceWithLiteral('\n', "\\n");
1496     printedCharacters += fprintf(stderr, "%s\t%p", boxName(), this);
1497     for (; printedCharacters < showTreeCharacterOffset; printedCharacters++)
1498         fputc(' ', stderr);
1499     printedCharacters = fprintf(stderr, "\t%s %p", renderer().renderName(), &renderer());
1500     const int rendererCharacterOffset = 24;
1501     for (; printedCharacters < rendererCharacterOffset; printedCharacters++)
1502         fputc(' ', stderr);
1503     fprintf(stderr, "(%d,%d) \"%s\"\n", start(), start() + len(), value.utf8().data());
1504 }
1505
1506 #endif
1507
1508 } // namespace WebCore