4159b157b9de5e47553a8d4c0ebd272866895ace
[WebKit-https.git] / Source / WebCore / rendering / TextDecorationPainter.cpp
1 /*
2  * (C) 1999 Lars Knoll (knoll@kde.org)
3  * (C) 2000 Dirk Mueller (mueller@kde.org)
4  * Copyright (C) 2004-2017 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 "TextDecorationPainter.h"
25
26 #include "FontCascade.h"
27 #include "GraphicsContext.h"
28 #include "HTMLAnchorElement.h"
29 #include "HTMLFontElement.h"
30 #include "InlineTextBoxStyle.h"
31 #include "RenderBlock.h"
32 #include "RenderStyle.h"
33 #include "RenderText.h"
34 #include "ShadowData.h"
35 #include "TextRun.h"
36
37 namespace WebCore {
38
39 static void adjustStepToDecorationLength(float& step, float& controlPointDistance, float length)
40 {
41     ASSERT(step > 0);
42
43     if (length <= 0)
44         return;
45
46     unsigned stepCount = static_cast<unsigned>(length / step);
47
48     // Each Bezier curve starts at the same pixel that the previous one
49     // ended. We need to subtract (stepCount - 1) pixels when calculating the
50     // length covered to account for that.
51     float uncoveredLength = length - (stepCount * step - (stepCount - 1));
52     float adjustment = uncoveredLength / stepCount;
53     step += adjustment;
54     controlPointDistance += adjustment;
55 }
56
57 /*
58  * Draw one cubic Bezier curve and repeat the same pattern long the the decoration's axis.
59  * The start point (p1), controlPoint1, controlPoint2 and end point (p2) of the Bezier curve
60  * form a diamond shape:
61  *
62  *                              step
63  *                         |-----------|
64  *
65  *                   controlPoint1
66  *                         +
67  *
68  *
69  *                  . .
70  *                .     .
71  *              .         .
72  * (x1, y1) p1 +           .            + p2 (x2, y2) - <--- Decoration's axis
73  *                          .         .               |
74  *                            .     .                 |
75  *                              . .                   | controlPointDistance
76  *                                                    |
77  *                                                    |
78  *                         +                          -
79  *                   controlPoint2
80  *
81  *             |-----------|
82  *                 step
83  */
84 static void strokeWavyTextDecoration(GraphicsContext& context, const FloatPoint& start, const FloatPoint& end, float strokeThickness, float fontSize)
85 {
86     FloatPoint p1 = start;
87     FloatPoint p2 = end;
88     context.adjustLineToPixelBoundaries(p1, p2, strokeThickness, context.strokeStyle());
89
90     Path path;
91     path.moveTo(p1);
92
93     float controlPointDistance;
94     float step;
95     getWavyStrokeParameters(fontSize, controlPointDistance, step);
96
97     bool isVerticalLine = (p1.x() == p2.x());
98
99     if (isVerticalLine) {
100         ASSERT(p1.x() == p2.x());
101
102         float xAxis = p1.x();
103         float y1;
104         float y2;
105
106         if (p1.y() < p2.y()) {
107             y1 = p1.y();
108             y2 = p2.y();
109         } else {
110             y1 = p2.y();
111             y2 = p1.y();
112         }
113
114         adjustStepToDecorationLength(step, controlPointDistance, y2 - y1);
115         FloatPoint controlPoint1(xAxis + controlPointDistance, 0);
116         FloatPoint controlPoint2(xAxis - controlPointDistance, 0);
117
118         for (float y = y1; y + 2 * step <= y2;) {
119             controlPoint1.setY(y + step);
120             controlPoint2.setY(y + step);
121             y += 2 * step;
122             path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(xAxis, y));
123         }
124     } else {
125         ASSERT(p1.y() == p2.y());
126
127         float yAxis = p1.y();
128         float x1;
129         float x2;
130
131         if (p1.x() < p2.x()) {
132             x1 = p1.x();
133             x2 = p2.x();
134         } else {
135             x1 = p2.x();
136             x2 = p1.x();
137         }
138
139         adjustStepToDecorationLength(step, controlPointDistance, x2 - x1);
140         FloatPoint controlPoint1(0, yAxis + controlPointDistance);
141         FloatPoint controlPoint2(0, yAxis - controlPointDistance);
142
143         for (float x = x1; x + 2 * step <= x2;) {
144             controlPoint1.setX(x + step);
145             controlPoint2.setX(x + step);
146             x += 2 * step;
147             path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(x, yAxis));
148         }
149     }
150
151     context.setShouldAntialias(true);
152     context.strokePath(path);
153 }
154
155 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
156 static bool compareTuples(std::pair<float, float> l, std::pair<float, float> r)
157 {
158     return l.first < r.first;
159 }
160
161 static DashArray translateIntersectionPointsToSkipInkBoundaries(const DashArray& intersections, float dilationAmount, float totalWidth)
162 {
163     ASSERT(!(intersections.size() % 2));
164     
165     // Step 1: Make pairs so we can sort based on range starting-point. We dilate the ranges in this step as well.
166     Vector<std::pair<float, float>> tuples;
167     for (auto i = intersections.begin(); i != intersections.end(); i++, i++)
168         tuples.append(std::make_pair(*i - dilationAmount, *(i + 1) + dilationAmount));
169     std::sort(tuples.begin(), tuples.end(), &compareTuples);
170
171     // Step 2: Deal with intersecting ranges.
172     Vector<std::pair<float, float>> intermediateTuples;
173     if (tuples.size() >= 2) {
174         intermediateTuples.append(*tuples.begin());
175         for (auto i = tuples.begin() + 1; i != tuples.end(); i++) {
176             float& firstEnd = intermediateTuples.last().second;
177             float secondStart = i->first;
178             float secondEnd = i->second;
179             if (secondStart <= firstEnd && secondEnd <= firstEnd) {
180                 // Ignore this range completely
181             } else if (secondStart <= firstEnd)
182                 firstEnd = secondEnd;
183             else
184                 intermediateTuples.append(*i);
185         }
186     } else
187         intermediateTuples = tuples;
188
189     // Step 3: Output the space between the ranges, but only if the space warrants an underline.
190     float previous = 0;
191     DashArray result;
192     for (const auto& tuple : intermediateTuples) {
193         if (tuple.first - previous > dilationAmount) {
194             result.append(previous);
195             result.append(tuple.first);
196         }
197         previous = tuple.second;
198     }
199     if (totalWidth - previous > dilationAmount) {
200         result.append(previous);
201         result.append(totalWidth);
202     }
203     
204     return result;
205 }
206
207 static void drawSkipInkUnderline(GraphicsContext& context, const FontCascade& font, const TextRun& textRun, const FloatPoint& textOrigin, const FloatPoint& localOrigin,
208     float underlineOffset, float width, bool isPrinting, bool doubleLines, StrokeStyle strokeStyle)
209 {
210     FloatPoint adjustedLocalOrigin = localOrigin;
211     adjustedLocalOrigin.move(0, underlineOffset);
212     FloatRect underlineBoundingBox = context.computeUnderlineBoundsForText(adjustedLocalOrigin, width, isPrinting);
213     DashArray intersections = font.dashesForIntersectionsWithRect(textRun, textOrigin, underlineBoundingBox);
214     DashArray a = translateIntersectionPointsToSkipInkBoundaries(intersections, underlineBoundingBox.height(), width);
215     ASSERT(!(a.size() % 2));
216     context.drawLinesForText(adjustedLocalOrigin, a, isPrinting, doubleLines, strokeStyle);
217 }
218 #endif
219
220 static StrokeStyle textDecorationStyleToStrokeStyle(TextDecorationStyle decorationStyle)
221 {
222     StrokeStyle strokeStyle = SolidStroke;
223     switch (decorationStyle) {
224     case TextDecorationStyleSolid:
225         strokeStyle = SolidStroke;
226         break;
227     case TextDecorationStyleDouble:
228         strokeStyle = DoubleStroke;
229         break;
230     case TextDecorationStyleDotted:
231         strokeStyle = DottedStroke;
232         break;
233     case TextDecorationStyleDashed:
234         strokeStyle = DashedStroke;
235         break;
236     case TextDecorationStyleWavy:
237         strokeStyle = WavyStroke;
238         break;
239     }
240
241     return strokeStyle;
242 }
243
244 bool TextDecorationPainter::Styles::operator==(const Styles& other) const
245 {
246     return underlineColor == other.underlineColor && overlineColor == other.overlineColor && linethroughColor == other.linethroughColor
247         && underlineStyle == other.underlineStyle && overlineStyle == other.overlineStyle && linethroughStyle == other.linethroughStyle;
248 }
249
250 TextDecorationPainter::TextDecorationPainter(GraphicsContext& context, unsigned decorations, const RenderText& renderer, bool isFirstLine, std::optional<Styles> styles)
251     : m_context { context }
252     , m_decorations { OptionSet<TextDecoration>::fromRaw(decorations) }
253     , m_wavyOffset { wavyOffsetFromDecoration() }
254     , m_isPrinting { renderer.document().printing() }
255     , m_styles { styles ? *WTFMove(styles) : stylesForRenderer(renderer, decorations, isFirstLine, NOPSEUDO) }
256     , m_lineStyle { isFirstLine ? renderer.firstLineStyle() : renderer.style() }
257 {
258 }
259
260 void TextDecorationPainter::paintTextDecoration(const TextRun& textRun, const FloatPoint& textOrigin, const FloatPoint& boxOrigin)
261 {
262 #if !ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
263     UNUSED_PARAM(textRun);
264     UNUSED_PARAM(textOrigin);
265 #endif
266     ASSERT(m_font);
267     float textDecorationThickness = textDecorationStrokeThickness(m_lineStyle.computedFontPixelSize());
268     m_context.setStrokeThickness(textDecorationThickness);
269     FloatPoint localOrigin = boxOrigin;
270
271     auto paintDecoration = [&] (TextDecoration decoration, TextDecorationStyle style, const Color& color, const FloatPoint& start, const FloatPoint& end, int offset) {
272         m_context.setStrokeColor(color);
273
274         auto strokeStyle = textDecorationStyleToStrokeStyle(style);
275
276         if (style == TextDecorationStyleWavy)
277             strokeWavyTextDecoration(m_context, start, end, textDecorationThickness, m_lineStyle.computedFontPixelSize());
278         else if (decoration == TextDecorationUnderline || decoration == TextDecorationOverline) {
279 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
280             if ((m_lineStyle.textDecorationSkip() == TextDecorationSkipInk || m_lineStyle.textDecorationSkip() == TextDecorationSkipAuto) && m_isHorizontal) {
281                 if (!m_context.paintingDisabled())
282                     drawSkipInkUnderline(m_context, *m_font, textRun, textOrigin, localOrigin, offset, m_width, m_isPrinting, style == TextDecorationStyleDouble, strokeStyle);
283             } else
284                 // FIXME: Need to support text-decoration-skip: none.
285 #endif
286                 m_context.drawLineForText(start, m_width, m_isPrinting, style == TextDecorationStyleDouble, strokeStyle);
287             
288         } else {
289             ASSERT(decoration == TextDecorationLineThrough);
290             m_context.drawLineForText(start, m_width, m_isPrinting, style == TextDecorationStyleDouble, strokeStyle);
291         }
292     };
293
294     bool areLinesOpaque = !m_isPrinting && (!m_decorations.contains(TextDecorationUnderline) || m_styles.underlineColor.isOpaque())
295         && (!m_decorations.contains(TextDecorationOverline) || m_styles.overlineColor.isOpaque())
296         && (!m_decorations.contains(TextDecorationLineThrough) || m_styles.linethroughColor.isOpaque());
297
298     int extraOffset = 0;
299     bool clipping = !areLinesOpaque && m_shadow && m_shadow->next();
300     if (clipping) {
301         FloatRect clipRect(localOrigin, FloatSize(m_width, m_baseline + 2));
302         for (const ShadowData* shadow = m_shadow; shadow; shadow = shadow->next()) {
303             int shadowExtent = shadow->paintingExtent();
304             FloatRect shadowRect(localOrigin, FloatSize(m_width, m_baseline + 2));
305             shadowRect.inflate(shadowExtent);
306             int shadowX = m_isHorizontal ? shadow->x() : shadow->y();
307             int shadowY = m_isHorizontal ? shadow->y() : -shadow->x();
308             shadowRect.move(shadowX, shadowY);
309             clipRect.unite(shadowRect);
310             extraOffset = std::max(extraOffset, std::max(0, shadowY) + shadowExtent);
311         }
312         m_context.save();
313         m_context.clip(clipRect);
314         extraOffset += m_baseline + 2;
315         localOrigin.move(0, extraOffset);
316     }
317
318     const ShadowData* shadow = m_shadow;
319     do {
320         if (shadow) {
321             if (!shadow->next()) {
322                 // The last set of lines paints normally inside the clip.
323                 localOrigin.move(0, -extraOffset);
324                 extraOffset = 0;
325             }
326             int shadowX = m_isHorizontal ? shadow->x() : shadow->y();
327             int shadowY = m_isHorizontal ? shadow->y() : -shadow->x();
328             m_context.setShadow(FloatSize(shadowX, shadowY - extraOffset), shadow->radius(), shadow->color());
329             shadow = shadow->next();
330         }
331
332         // These decorations should match the visual overflows computed in visualOverflowForDecorations().
333         if (m_decorations.contains(TextDecorationUnderline)) {
334             int offset = computeUnderlineOffset(m_lineStyle.textUnderlinePosition(), m_lineStyle.fontMetrics(), m_inlineTextBox, textDecorationThickness);
335             float wavyOffset = m_styles.underlineStyle == TextDecorationStyleWavy ? m_wavyOffset : 0;
336             FloatPoint start = localOrigin + FloatSize(0, offset + wavyOffset);
337             FloatPoint end = localOrigin + FloatSize(m_width, offset + wavyOffset);
338             paintDecoration(TextDecorationUnderline, m_styles.underlineStyle, m_styles.underlineColor, start, end, offset);
339         }
340         if (m_decorations.contains(TextDecorationOverline)) {
341             float wavyOffset = m_styles.overlineStyle == TextDecorationStyleWavy ? m_wavyOffset : 0;
342             FloatPoint start = localOrigin - FloatSize(0, wavyOffset);
343             FloatPoint end = localOrigin + FloatSize(m_width, -wavyOffset);
344             paintDecoration(TextDecorationOverline, m_styles.overlineStyle, m_styles.overlineColor, start, end, 0);
345         }
346         if (m_decorations.contains(TextDecorationLineThrough)) {
347             FloatPoint start = localOrigin + FloatSize(0, 2 * m_baseline / 3);
348             FloatPoint end = localOrigin + FloatSize(m_width, 2 * m_baseline / 3);
349             paintDecoration(TextDecorationLineThrough, m_styles.linethroughStyle, m_styles.linethroughColor, start, end, 0);
350         }
351     } while (shadow);
352
353     if (clipping)
354         m_context.restore();
355     else if (m_shadow)
356         m_context.clearShadow();
357 }
358
359 static Color decorationColor(const RenderStyle& style)
360 {
361     // Check for text decoration color first.
362     Color result = style.visitedDependentColor(CSSPropertyWebkitTextDecorationColor);
363     if (result.isValid())
364         return result;
365     if (style.hasPositiveStrokeWidth()) {
366         // Prefer stroke color if possible but not if it's fully transparent.
367         result = style.computedStrokeColor();
368         if (result.isVisible())
369             return result;
370     }
371     
372     return style.visitedDependentColor(CSSPropertyWebkitTextFillColor);
373 }
374
375 static void collectStylesForRenderer(TextDecorationPainter::Styles& result, const RenderObject& renderer, OptionSet<TextDecoration> remainingDecorations, bool firstLineStyle, PseudoId pseudoId)
376 {
377     auto extractDecorations = [&] (const RenderStyle& style, OptionSet<TextDecoration> decorations) {
378         auto color = decorationColor(style);
379         auto decorationStyle = style.textDecorationStyle();
380
381         if (decorations.contains(TextDecorationUnderline)) {
382             remainingDecorations -= TextDecorationUnderline;
383             result.underlineColor = color;
384             result.underlineStyle = decorationStyle;
385         }
386         if (decorations.contains(TextDecorationOverline)) {
387             remainingDecorations -= TextDecorationOverline;
388             result.overlineColor = color;
389             result.overlineStyle = decorationStyle;
390         }
391         if (decorations.contains(TextDecorationLineThrough)) {
392             remainingDecorations -= TextDecorationLineThrough;
393             result.linethroughColor = color;
394             result.linethroughStyle = decorationStyle;
395         }
396
397     };
398
399     auto styleForRenderer = [&] (const RenderObject& renderer) -> const RenderStyle& {
400         if (pseudoId != NOPSEUDO && renderer.style().hasPseudoStyle(pseudoId)) {
401             if (is<RenderText>(renderer))
402                 return *downcast<RenderText>(renderer).getCachedPseudoStyle(pseudoId);
403             return *downcast<RenderElement>(renderer).getCachedPseudoStyle(pseudoId);
404         }
405         return firstLineStyle ? renderer.firstLineStyle() : renderer.style();
406     };
407
408     auto* current = &renderer;
409     do {
410         const auto& style = styleForRenderer(*current);
411         extractDecorations(style, OptionSet<TextDecoration>::fromRaw(style.textDecoration()));
412
413         if (current->isRubyText())
414             return;
415
416         current = current->parent();
417         if (current && current->isAnonymousBlock() && downcast<RenderBlock>(*current).continuation())
418             current = downcast<RenderBlock>(*current).continuation();
419
420         if (remainingDecorations.isEmpty())
421             break;
422
423     } while (current && !is<HTMLAnchorElement>(current->node()) && !is<HTMLFontElement>(current->node()));
424
425     // If we bailed out, use the element we bailed out at (typically a <font> or <a> element).
426     if (!remainingDecorations.isEmpty() && current)
427         extractDecorations(styleForRenderer(*current), remainingDecorations);
428 }
429
430 auto TextDecorationPainter::stylesForRenderer(const RenderObject& renderer, unsigned requestedDecorations, bool firstLineStyle, PseudoId pseudoId) -> Styles
431 {
432     Styles result;
433     collectStylesForRenderer(result, renderer, OptionSet<TextDecoration>::fromRaw(requestedDecorations), false, pseudoId);
434     if (firstLineStyle)
435         collectStylesForRenderer(result, renderer, OptionSet<TextDecoration>::fromRaw(requestedDecorations), true, pseudoId);
436     return result;
437 }
438
439 } // namespace WebCore