Clean up text decoration drawing code
[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 FloatRect& rect, float fontSize)
85 {
86     FloatPoint p1 = rect.minXMinYCorner();
87     FloatPoint p2 = rect.maxXMinYCorner();
88     context.adjustLineToPixelBoundaries(p1, p2, rect.height(), context.strokeStyle());
89
90     Path path;
91     path.moveTo(p1);
92
93     auto wavyStrokeParameters = getWavyStrokeParameters(fontSize);
94
95     ASSERT(p1.y() == p2.y());
96
97     float yAxis = p1.y();
98     float x1 = std::min(p1.x(), p2.x());
99     float x2 = std::max(p1.x(), p2.x());
100
101     adjustStepToDecorationLength(wavyStrokeParameters.step, wavyStrokeParameters.controlPointDistance, x2 - x1);
102     FloatPoint controlPoint1(0, yAxis + wavyStrokeParameters.controlPointDistance);
103     FloatPoint controlPoint2(0, yAxis - wavyStrokeParameters.controlPointDistance);
104
105     for (float x = x1; x + 2 * wavyStrokeParameters.step <= x2;) {
106         controlPoint1.setX(x + wavyStrokeParameters.step);
107         controlPoint2.setX(x + wavyStrokeParameters.step);
108         x += 2 * wavyStrokeParameters.step;
109         path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(x, yAxis));
110     }
111
112     context.setShouldAntialias(true);
113     auto strokeThickness = context.strokeThickness();
114     context.setStrokeThickness(rect.height());
115     context.strokePath(path);
116     context.setStrokeThickness(strokeThickness);
117 }
118
119 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
120 static bool compareTuples(std::pair<float, float> l, std::pair<float, float> r)
121 {
122     return l.first < r.first;
123 }
124
125 static DashArray translateIntersectionPointsToSkipInkBoundaries(const DashArray& intersections, float dilationAmount, float totalWidth)
126 {
127     ASSERT(!(intersections.size() % 2));
128     
129     // Step 1: Make pairs so we can sort based on range starting-point. We dilate the ranges in this step as well.
130     Vector<std::pair<float, float>> tuples;
131     for (auto i = intersections.begin(); i != intersections.end(); i++, i++)
132         tuples.append(std::make_pair(*i - dilationAmount, *(i + 1) + dilationAmount));
133     std::sort(tuples.begin(), tuples.end(), &compareTuples);
134
135     // Step 2: Deal with intersecting ranges.
136     Vector<std::pair<float, float>> intermediateTuples;
137     if (tuples.size() >= 2) {
138         intermediateTuples.append(*tuples.begin());
139         for (auto i = tuples.begin() + 1; i != tuples.end(); i++) {
140             float& firstEnd = intermediateTuples.last().second;
141             float secondStart = i->first;
142             float secondEnd = i->second;
143             if (secondStart <= firstEnd && secondEnd <= firstEnd) {
144                 // Ignore this range completely
145             } else if (secondStart <= firstEnd)
146                 firstEnd = secondEnd;
147             else
148                 intermediateTuples.append(*i);
149         }
150     } else
151         intermediateTuples = tuples;
152
153     // Step 3: Output the space between the ranges, but only if the space warrants an underline.
154     float previous = 0;
155     DashArray result;
156     for (const auto& tuple : intermediateTuples) {
157         if (tuple.first - previous > dilationAmount) {
158             result.append(previous);
159             result.append(tuple.first);
160         }
161         previous = tuple.second;
162     }
163     if (totalWidth - previous > dilationAmount) {
164         result.append(previous);
165         result.append(totalWidth);
166     }
167     
168     return result;
169 }
170 #endif
171
172 static StrokeStyle textDecorationStyleToStrokeStyle(TextDecorationStyle decorationStyle)
173 {
174     StrokeStyle strokeStyle = SolidStroke;
175     switch (decorationStyle) {
176     case TextDecorationStyle::Solid:
177         strokeStyle = SolidStroke;
178         break;
179     case TextDecorationStyle::Double:
180         strokeStyle = DoubleStroke;
181         break;
182     case TextDecorationStyle::Dotted:
183         strokeStyle = DottedStroke;
184         break;
185     case TextDecorationStyle::Dashed:
186         strokeStyle = DashedStroke;
187         break;
188     case TextDecorationStyle::Wavy:
189         strokeStyle = WavyStroke;
190         break;
191     }
192
193     return strokeStyle;
194 }
195
196 bool TextDecorationPainter::Styles::operator==(const Styles& other) const
197 {
198     return underlineColor == other.underlineColor && overlineColor == other.overlineColor && linethroughColor == other.linethroughColor
199         && underlineStyle == other.underlineStyle && overlineStyle == other.overlineStyle && linethroughStyle == other.linethroughStyle;
200 }
201
202 TextDecorationPainter::TextDecorationPainter(GraphicsContext& context, OptionSet<TextDecoration> decorations, const RenderText& renderer, bool isFirstLine, const FontCascade& font, std::optional<Styles> styles)
203     : m_context { context }
204     , m_decorations { decorations }
205     , m_wavyOffset { wavyOffsetFromDecoration() }
206     , m_isPrinting { renderer.document().printing() }
207     , m_font { font }
208     , m_styles { styles ? *WTFMove(styles) : stylesForRenderer(renderer, decorations, isFirstLine, PseudoId::None) }
209     , m_lineStyle { isFirstLine ? renderer.firstLineStyle() : renderer.style() }
210 {
211 }
212
213 void TextDecorationPainter::paintTextDecoration(const TextRun& textRun, const FloatPoint& textOrigin, const FloatPoint& boxOrigin)
214 {
215 #if !ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
216     UNUSED_PARAM(textRun);
217     UNUSED_PARAM(textOrigin);
218 #endif
219     const auto& fontMetrics = m_lineStyle.fontMetrics();
220     float textDecorationThickness = textDecorationStrokeThickness(m_lineStyle.computedFontPixelSize());
221     FloatPoint localOrigin = boxOrigin;
222
223     auto paintDecoration = [&] (TextDecoration decoration, TextDecorationStyle style, const Color& color, const FloatRect& rect) {
224         m_context.setStrokeColor(color);
225
226         auto strokeStyle = textDecorationStyleToStrokeStyle(style);
227
228         if (style == TextDecorationStyle::Wavy)
229             strokeWavyTextDecoration(m_context, rect, m_lineStyle.computedFontPixelSize());
230         else if (decoration == TextDecoration::Underline || decoration == TextDecoration::Overline) {
231 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
232             if ((m_lineStyle.textDecorationSkip() == TextDecorationSkip::Ink || m_lineStyle.textDecorationSkip() == TextDecorationSkip::Auto) && m_isHorizontal) {
233                 if (!m_context.paintingDisabled()) {
234                     FloatRect underlineBoundingBox = m_context.computeUnderlineBoundsForText(rect, m_isPrinting);
235                     DashArray intersections = m_font.dashesForIntersectionsWithRect(textRun, textOrigin, underlineBoundingBox);
236                     DashArray boundaries = translateIntersectionPointsToSkipInkBoundaries(intersections, underlineBoundingBox.height(), rect.width());
237                     ASSERT(!(boundaries.size() % 2));
238                     // We don't use underlineBoundingBox here because drawLinesForText() will run computeUnderlineBoundsForText() internally.
239                     m_context.drawLinesForText(rect.location(), rect.height(), boundaries, m_isPrinting, style == TextDecorationStyle::Double, strokeStyle);
240                 }
241             } else
242                 // FIXME: Need to support text-decoration-skip: none.
243 #endif
244                 m_context.drawLineForText(rect, m_isPrinting, style == TextDecorationStyle::Double, strokeStyle);
245             
246         } else {
247             ASSERT(decoration == TextDecoration::LineThrough);
248             m_context.drawLineForText(rect, m_isPrinting, style == TextDecorationStyle::Double, strokeStyle);
249         }
250     };
251
252     bool areLinesOpaque = !m_isPrinting && (!m_decorations.contains(TextDecoration::Underline) || m_styles.underlineColor.isOpaque())
253         && (!m_decorations.contains(TextDecoration::Overline) || m_styles.overlineColor.isOpaque())
254         && (!m_decorations.contains(TextDecoration::LineThrough) || m_styles.linethroughColor.isOpaque());
255
256     int extraOffset = 0;
257     bool clipping = !areLinesOpaque && m_shadow && m_shadow->next();
258     if (clipping) {
259         FloatRect clipRect(localOrigin, FloatSize(m_width, fontMetrics.ascent() + 2));
260         for (const ShadowData* shadow = m_shadow; shadow; shadow = shadow->next()) {
261             int shadowExtent = shadow->paintingExtent();
262             FloatRect shadowRect(localOrigin, FloatSize(m_width, fontMetrics.ascent() + 2));
263             shadowRect.inflate(shadowExtent);
264             int shadowX = m_isHorizontal ? shadow->x() : shadow->y();
265             int shadowY = m_isHorizontal ? shadow->y() : -shadow->x();
266             shadowRect.move(shadowX, shadowY);
267             clipRect.unite(shadowRect);
268             extraOffset = std::max(extraOffset, std::max(0, shadowY) + shadowExtent);
269         }
270         m_context.save();
271         m_context.clip(clipRect);
272         extraOffset += fontMetrics.ascent() + 2;
273         localOrigin.move(0, extraOffset);
274     }
275
276     const ShadowData* shadow = m_shadow;
277     do {
278         if (shadow) {
279             if (!shadow->next()) {
280                 // The last set of lines paints normally inside the clip.
281                 localOrigin.move(0, -extraOffset);
282                 extraOffset = 0;
283             }
284             int shadowX = m_isHorizontal ? shadow->x() : shadow->y();
285             int shadowY = m_isHorizontal ? shadow->y() : -shadow->x();
286             
287             Color shadowColor = shadow->color();
288             if (m_shadowColorFilter)
289                 m_shadowColorFilter->transformColor(shadowColor);
290             m_context.setShadow(FloatSize(shadowX, shadowY - extraOffset), shadow->radius(), shadowColor);
291             shadow = shadow->next();
292         }
293
294         // These decorations should match the visual overflows computed in visualOverflowForDecorations().
295         if (m_decorations.contains(TextDecoration::Underline)) {
296             int offset = computeUnderlineOffset(m_lineStyle.textUnderlinePosition(), m_lineStyle.fontMetrics(), m_inlineTextBox, textDecorationThickness);
297             float wavyOffset = m_styles.underlineStyle == TextDecorationStyle::Wavy ? m_wavyOffset : 0;
298             FloatRect rect(localOrigin, FloatSize(m_width, textDecorationThickness));
299             rect.move(0, offset + wavyOffset);
300             paintDecoration(TextDecoration::Underline, m_styles.underlineStyle, m_styles.underlineColor, rect);
301         }
302         if (m_decorations.contains(TextDecoration::Overline)) {
303             float wavyOffset = m_styles.overlineStyle == TextDecorationStyle::Wavy ? m_wavyOffset : 0;
304             FloatRect rect(localOrigin, FloatSize(m_width, textDecorationThickness));
305             rect.move(0, -wavyOffset);
306             paintDecoration(TextDecoration::Overline, m_styles.overlineStyle, m_styles.overlineColor, rect);
307         }
308         if (m_decorations.contains(TextDecoration::LineThrough)) {
309             FloatRect rect(localOrigin, FloatSize(m_width, textDecorationThickness));
310             rect.move(0, 2 * fontMetrics.floatAscent() / 3);
311             paintDecoration(TextDecoration::LineThrough, m_styles.linethroughStyle, m_styles.linethroughColor, rect);
312         }
313     } while (shadow);
314
315     if (clipping)
316         m_context.restore();
317     else if (m_shadow)
318         m_context.clearShadow();
319 }
320
321 static Color decorationColor(const RenderStyle& style)
322 {
323     // Check for text decoration color first.
324     Color result = style.visitedDependentColorWithColorFilter(CSSPropertyWebkitTextDecorationColor);
325     if (result.isValid())
326         return result;
327     if (style.hasPositiveStrokeWidth()) {
328         // Prefer stroke color if possible but not if it's fully transparent.
329         result = style.computedStrokeColor();
330         if (result.isVisible())
331             return result;
332     }
333     
334     return style.visitedDependentColorWithColorFilter(CSSPropertyWebkitTextFillColor);
335 }
336
337 static void collectStylesForRenderer(TextDecorationPainter::Styles& result, const RenderObject& renderer, OptionSet<TextDecoration> remainingDecorations, bool firstLineStyle, PseudoId pseudoId)
338 {
339     auto extractDecorations = [&] (const RenderStyle& style, OptionSet<TextDecoration> decorations) {
340         auto color = decorationColor(style);
341         auto decorationStyle = style.textDecorationStyle();
342
343         if (decorations.contains(TextDecoration::Underline)) {
344             remainingDecorations.remove(TextDecoration::Underline);
345             result.underlineColor = color;
346             result.underlineStyle = decorationStyle;
347         }
348         if (decorations.contains(TextDecoration::Overline)) {
349             remainingDecorations.remove(TextDecoration::Overline);
350             result.overlineColor = color;
351             result.overlineStyle = decorationStyle;
352         }
353         if (decorations.contains(TextDecoration::LineThrough)) {
354             remainingDecorations.remove(TextDecoration::LineThrough);
355             result.linethroughColor = color;
356             result.linethroughStyle = decorationStyle;
357         }
358
359     };
360
361     auto styleForRenderer = [&] (const RenderObject& renderer) -> const RenderStyle& {
362         if (pseudoId != PseudoId::None && renderer.style().hasPseudoStyle(pseudoId)) {
363             if (is<RenderText>(renderer))
364                 return *downcast<RenderText>(renderer).getCachedPseudoStyle(pseudoId);
365             return *downcast<RenderElement>(renderer).getCachedPseudoStyle(pseudoId);
366         }
367         return firstLineStyle ? renderer.firstLineStyle() : renderer.style();
368     };
369
370     auto* current = &renderer;
371     do {
372         const auto& style = styleForRenderer(*current);
373         extractDecorations(style, style.textDecoration());
374
375         if (current->isRubyText())
376             return;
377
378         current = current->parent();
379         if (current && current->isAnonymousBlock() && downcast<RenderBlock>(*current).continuation())
380             current = downcast<RenderBlock>(*current).continuation();
381
382         if (remainingDecorations.isEmpty())
383             break;
384
385     } while (current && !is<HTMLAnchorElement>(current->node()) && !is<HTMLFontElement>(current->node()));
386
387     // If we bailed out, use the element we bailed out at (typically a <font> or <a> element).
388     if (!remainingDecorations.isEmpty() && current)
389         extractDecorations(styleForRenderer(*current), remainingDecorations);
390 }
391
392 auto TextDecorationPainter::stylesForRenderer(const RenderObject& renderer, OptionSet<TextDecoration> requestedDecorations, bool firstLineStyle, PseudoId pseudoId) -> Styles
393 {
394     Styles result;
395     collectStylesForRenderer(result, renderer, requestedDecorations, false, pseudoId);
396     if (firstLineStyle)
397         collectStylesForRenderer(result, renderer, requestedDecorations, true, pseudoId);
398     return result;
399 }
400
401 } // namespace WebCore