FontCache should only deal with SimpleFontData
[WebKit-https.git] / Source / WebCore / platform / graphics / cairo / FontCairo.cpp
1 /*
2  * Copyright (C) 2006 Apple Inc.  All rights reserved.
3  * Copyright (C) 2006 Michael Emmel mike.emmel@gmail.com
4  * Copyright (C) 2007, 2008 Alp Toker <alp@atoker.com>
5  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
6  * Copyright (C) 2010 Holger Hans Peter Freyther
7  * Copyright (C) 2014 Igalia S.L.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
22  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
26  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #include "Font.h"
33
34 #include "AffineTransform.h"
35 #include "CairoUtilities.h"
36 #include "GlyphBuffer.h"
37 #include "Gradient.h"
38 #include "GraphicsContext.h"
39 #include "ImageBuffer.h"
40 #include "Pattern.h"
41 #include "PlatformContextCairo.h"
42 #include "PlatformPathCairo.h"
43 #include "ShadowBlur.h"
44 #include "SimpleFontData.h"
45
46 namespace WebCore {
47
48 static void drawGlyphsToContext(cairo_t* context, const SimpleFontData* font, GlyphBufferGlyph* glyphs, int numGlyphs)
49 {
50     cairo_matrix_t originalTransform;
51     float syntheticBoldOffset = font->syntheticBoldOffset();
52     if (syntheticBoldOffset)
53         cairo_get_matrix(context, &originalTransform);
54
55     cairo_set_scaled_font(context, font->platformData().scaledFont());
56     cairo_show_glyphs(context, glyphs, numGlyphs);
57
58     if (syntheticBoldOffset) {
59         cairo_translate(context, syntheticBoldOffset, 0);
60         cairo_show_glyphs(context, glyphs, numGlyphs);
61     }
62
63     if (syntheticBoldOffset)
64         cairo_set_matrix(context, &originalTransform);
65 }
66
67 static void drawGlyphsShadow(GraphicsContext* graphicsContext, const FloatPoint& point, const SimpleFontData* font, GlyphBufferGlyph* glyphs, int numGlyphs)
68 {
69     ShadowBlur& shadow = graphicsContext->platformContext()->shadowBlur();
70
71     if (!(graphicsContext->textDrawingMode() & TextModeFill) || shadow.type() == ShadowBlur::NoShadow)
72         return;
73
74     if (!graphicsContext->mustUseShadowBlur()) {
75         // Optimize non-blurry shadows, by just drawing text without the ShadowBlur.
76         cairo_t* context = graphicsContext->platformContext()->cr();
77         cairo_save(context);
78
79         FloatSize shadowOffset(graphicsContext->state().shadowOffset);
80         cairo_translate(context, shadowOffset.width(), shadowOffset.height());
81         setSourceRGBAFromColor(context, graphicsContext->state().shadowColor);
82         drawGlyphsToContext(context, font, glyphs, numGlyphs);
83
84         cairo_restore(context);
85         return;
86     }
87
88     cairo_text_extents_t extents;
89     cairo_scaled_font_glyph_extents(font->platformData().scaledFont(), glyphs, numGlyphs, &extents);
90     FloatRect fontExtentsRect(point.x() + extents.x_bearing, point.y() + extents.y_bearing, extents.width, extents.height);
91
92     if (GraphicsContext* shadowContext = shadow.beginShadowLayer(graphicsContext, fontExtentsRect)) {
93         drawGlyphsToContext(shadowContext->platformContext()->cr(), font, glyphs, numGlyphs);
94         shadow.endShadowLayer(graphicsContext);
95     }
96 }
97
98 void Font::drawGlyphs(GraphicsContext* context, const SimpleFontData* font, const GlyphBuffer& glyphBuffer,
99     int from, int numGlyphs, const FloatPoint& point) const
100 {
101     if (!font->platformData().size())
102         return;
103
104     GlyphBufferGlyph* glyphs = const_cast<GlyphBufferGlyph*>(glyphBuffer.glyphs(from));
105
106     float offset = point.x();
107     for (int i = 0; i < numGlyphs; i++) {
108         glyphs[i].x = offset;
109         glyphs[i].y = point.y();
110         offset += glyphBuffer.advanceAt(from + i).width();
111     }
112
113     PlatformContextCairo* platformContext = context->platformContext();
114     drawGlyphsShadow(context, point, font, glyphs, numGlyphs);
115
116     cairo_t* cr = platformContext->cr();
117     cairo_save(cr);
118
119     if (context->textDrawingMode() & TextModeFill) {
120         platformContext->prepareForFilling(context->state(), PlatformContextCairo::AdjustPatternForGlobalAlpha);
121         drawGlyphsToContext(cr, font, glyphs, numGlyphs);
122     }
123
124     // Prevent running into a long computation within cairo. If the stroke width is
125     // twice the size of the width of the text we will not ask cairo to stroke
126     // the text as even one single stroke would cover the full wdth of the text.
127     //  See https://bugs.webkit.org/show_bug.cgi?id=33759.
128     if (context->textDrawingMode() & TextModeStroke && context->strokeThickness() < 2 * offset) {
129         platformContext->prepareForStroking(context->state());
130         cairo_set_line_width(cr, context->strokeThickness());
131
132         // This may disturb the CTM, but we are going to call cairo_restore soon after.
133         cairo_set_scaled_font(cr, font->platformData().scaledFont());
134         cairo_glyph_path(cr, glyphs, numGlyphs);
135         cairo_stroke(cr);
136     }
137
138     cairo_restore(cr);
139 }
140
141 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
142 struct GlyphIterationState {
143     GlyphIterationState(FloatPoint startingPoint, FloatPoint currentPoint, float centerOfLine, float minX, float maxX)
144         : startingPoint(startingPoint)
145         , currentPoint(currentPoint)
146         , centerOfLine(centerOfLine)
147         , minX(minX)
148         , maxX(maxX)
149     {
150     }
151     FloatPoint startingPoint;
152     FloatPoint currentPoint;
153     float centerOfLine;
154     float minX;
155     float maxX;
156 };
157
158 static bool findIntersectionPoint(float y, FloatPoint p1, FloatPoint p2, float& x)
159 {
160     x = p1.x() + (y - p1.y()) * (p2.x() - p1.x()) / (p2.y() - p1.y());
161     return (p1.y() < y && p2.y() > y) || (p1.y() > y && p2.y() < y);
162 }
163
164 static void updateX(GlyphIterationState& state, float x)
165 {
166     state.minX = std::min(state.minX, x);
167     state.maxX = std::max(state.maxX, x);
168 }
169
170 // This function is called by Path::apply and is therefore invoked for each contour in a glyph. This
171 // function models each contours as a straight line and calculates the intersections between each
172 // pseudo-contour and the vertical center of the underline found in GlyphIterationState::centerOfLine.
173 // It keeps track of the leftmost and rightmost intersection in  GlyphIterationState::minX and 
174 // GlyphIterationState::maxX.
175 static void findPathIntersections(void* stateAsVoidPointer, const PathElement* element)
176 {
177     auto& state = *static_cast<GlyphIterationState*>(stateAsVoidPointer);
178     bool doIntersection = false;
179     FloatPoint point = FloatPoint();
180     switch (element->type) {
181     case PathElementMoveToPoint:
182         state.startingPoint = element->points[0];
183         state.currentPoint = element->points[0];
184         break;
185     case PathElementAddLineToPoint:
186         doIntersection = true;
187         point = element->points[0];
188         break;
189     case PathElementAddQuadCurveToPoint:
190         doIntersection = true;
191         point = element->points[1];
192         break;
193     case PathElementAddCurveToPoint:
194         doIntersection = true;
195         point = element->points[2];
196         break;
197     case PathElementCloseSubpath:
198         doIntersection = true;
199         point = state.startingPoint;
200         break;
201     }
202
203     if (!doIntersection)
204         return;
205
206     float x;
207     if (findIntersectionPoint(state.centerOfLine, state.currentPoint, point, x))
208         updateX(state, x);
209
210     state.currentPoint = point;
211 }
212
213 class CairoGlyphToPathTranslator final : public GlyphToPathTranslator {
214 public:
215     CairoGlyphToPathTranslator(const TextRun& textRun, const GlyphBuffer& glyphBuffer, const FloatPoint& textOrigin)
216         : m_index(0)
217         , m_textRun(textRun)
218         , m_glyphBuffer(glyphBuffer)
219         , m_fontData(glyphBuffer.fontDataAt(m_index))
220         , m_translation(AffineTransform().translate(textOrigin.x(), textOrigin.y()))
221     {
222         moveToNextValidGlyph();
223     }
224 private:
225     virtual bool containsMorePaths() override
226     {
227         return m_index != m_glyphBuffer.size();
228     }
229     virtual Path path() override;
230     virtual std::pair<float, float> extents() override;
231     virtual GlyphUnderlineType underlineType() override;
232     virtual void advance() override;
233     void moveToNextValidGlyph();
234
235     int m_index;
236     const TextRun& m_textRun;
237     const GlyphBuffer& m_glyphBuffer;
238     const SimpleFontData* m_fontData;
239     AffineTransform m_translation;
240 };
241
242 Path CairoGlyphToPathTranslator::path()
243 {
244     Path path;
245     path.ensurePlatformPath();
246
247     cairo_glyph_t cairoGlyph;
248     cairoGlyph.index = m_glyphBuffer.glyphAt(m_index);
249     cairo_set_scaled_font(path.platformPath()->context(), m_fontData->platformData().scaledFont());
250     cairo_glyph_path(path.platformPath()->context(), &cairoGlyph, 1);
251
252     float syntheticBoldOffset = m_fontData->syntheticBoldOffset();
253     if (syntheticBoldOffset) {
254         cairo_translate(path.platformPath()->context(), syntheticBoldOffset, 0);
255         cairo_show_glyphs(path.platformPath()->context(), &cairoGlyph, 1);
256     }
257
258     path.transform(m_translation);
259     return path;
260 }
261
262 std::pair<float, float> CairoGlyphToPathTranslator::extents()
263 {
264     FloatPoint beginning = m_translation.mapPoint(FloatPoint());
265     FloatSize end = m_translation.mapSize(m_glyphBuffer.advanceAt(m_index));
266     return std::make_pair(static_cast<float>(beginning.x()), static_cast<float>(beginning.x() + end.width()));
267 }
268
269 GlyphToPathTranslator::GlyphUnderlineType CairoGlyphToPathTranslator::underlineType()
270 {
271     return computeUnderlineType(m_textRun, m_glyphBuffer, m_index);
272 }
273
274 void CairoGlyphToPathTranslator::moveToNextValidGlyph()
275 {
276     if (!m_fontData->isSVGFont())
277         return;
278     advance();
279 }
280
281 void CairoGlyphToPathTranslator::advance()
282 {
283     do {
284         GlyphBufferAdvance advance = m_glyphBuffer.advanceAt(m_index);
285         m_translation = m_translation.translate(advance.width(), advance.height());
286         ++m_index;
287         if (m_index >= m_glyphBuffer.size())
288             break;
289         m_fontData = m_glyphBuffer.fontDataAt(m_index);
290     } while (m_fontData->isSVGFont() && m_index < m_glyphBuffer.size());
291 }
292
293 DashArray Font::dashesForIntersectionsWithRect(const TextRun& run, const FloatPoint& textOrigin, const FloatRect& lineExtents) const
294 {
295     if (isLoadingCustomFonts())
296         return DashArray();
297
298     GlyphBuffer glyphBuffer;
299     glyphBuffer.saveOffsetsInString();
300     float deltaX;
301     if (codePath(run) != Font::Complex)
302         deltaX = getGlyphsAndAdvancesForSimpleText(run, 0, run.length(), glyphBuffer);
303     else
304         deltaX = getGlyphsAndAdvancesForComplexText(run, 0, run.length(), glyphBuffer);
305
306     if (!glyphBuffer.size())
307         return DashArray();
308
309     // FIXME: Handle SVG + non-SVG interleaved runs. https://bugs.webkit.org/show_bug.cgi?id=133778
310     const SimpleFontData* fontData = glyphBuffer.fontDataAt(0);
311     std::unique_ptr<GlyphToPathTranslator> translator;
312     bool isSVG = false;
313     FloatPoint origin = FloatPoint(textOrigin.x() + deltaX, textOrigin.y());
314     if (!fontData->isSVGFont())
315         translator = std::make_unique<CairoGlyphToPathTranslator>(run, glyphBuffer, origin);
316 #if ENABLE(SVG_FONTS)
317     else {
318         TextRun::RenderingContext* renderingContext = run.renderingContext();
319         if (!renderingContext)
320             return DashArray();
321         translator = renderingContext->createGlyphToPathTranslator(*fontData, &run, glyphBuffer, 0, glyphBuffer.size(), origin);
322         isSVG = true;
323     }
324 #endif
325     DashArray result;
326     for (int index = 0; translator->containsMorePaths(); ++index, translator->advance()) {
327         float centerOfLine = lineExtents.y() + (lineExtents.height() / 2);
328         GlyphIterationState info = GlyphIterationState(FloatPoint(), FloatPoint(), centerOfLine, lineExtents.x() + lineExtents.width(), lineExtents.x());
329         const SimpleFontData* localFontData = glyphBuffer.fontDataAt(index);
330         if (!localFontData || (!isSVG && localFontData->isSVGFont()) || (isSVG && localFontData != fontData)) {
331             // The advances will get all messed up if we do anything other than bail here.
332             result.clear();
333             break;
334         }
335         switch (translator->underlineType()) {
336         case GlyphToPathTranslator::GlyphUnderlineType::SkipDescenders: {
337             Path path = translator->path();
338             path.apply(&info, &findPathIntersections);
339             if (info.minX < info.maxX) {
340                 result.append(info.minX - lineExtents.x());
341                 result.append(info.maxX - lineExtents.x());
342             }
343             break;
344         }
345         case GlyphToPathTranslator::GlyphUnderlineType::SkipGlyph: {
346             std::pair<float, float> extents = translator->extents();
347             result.append(extents.first - lineExtents.x());
348             result.append(extents.second - lineExtents.x());
349             break;
350         }
351         case GlyphToPathTranslator::GlyphUnderlineType::DrawOverGlyph:
352             // Nothing to do
353             break;
354         }
355     }
356     return result;
357 }
358 #endif
359
360 }