af6287f662dfa153f15482601b74ea446c84b258
[WebKit-https.git] / Source / WebCore / platform / graphics / mac / FontMac.mm
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2000 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #import "config.h"
24 #import "Font.h"
25
26 #import "DashArray.h"
27 #import "GlyphBuffer.h"
28 #import "GraphicsContext.h"
29 #import "Logging.h"
30 #import "SimpleFontData.h"
31 #import "WebCoreSystemInterface.h"
32 #if USE(APPKIT)
33 #import <AppKit/AppKit.h>
34 #endif
35 #import <wtf/MathExtras.h>
36
37 #if ENABLE(LETTERPRESS)
38 #import "SoftLinking.h"
39 #if __has_include(<CoreGraphics/CoreGraphicsPrivate.h>)
40 #import <CoreGraphics/CoreGraphicsPrivate.h>
41 #else
42 extern CGColorRef CGContextGetFillColorAsColor(CGContextRef);
43 #endif
44 #import <CoreUI/CUICatalog.h>
45 #import <CoreUI/CUIStyleEffectConfiguration.h>
46
47 SOFT_LINK_PRIVATE_FRAMEWORK(CoreUI)
48 SOFT_LINK_CLASS(CoreUI, CUICatalog)
49 SOFT_LINK_CLASS(CoreUI, CUIStyleEffectConfiguration)
50
51 SOFT_LINK_FRAMEWORK(UIKit)
52 SOFT_LINK(UIKit, _UIKitGetTextEffectsCatalog, CUICatalog *, (void), ())
53 #endif
54
55 #define SYNTHETIC_OBLIQUE_ANGLE 14
56
57 #ifdef __LP64__
58 #define URefCon void*
59 #else
60 #define URefCon UInt32
61 #endif
62
63 namespace WebCore {
64
65 bool Font::canReturnFallbackFontsForComplexText()
66 {
67     return true;
68 }
69
70 bool Font::canExpandAroundIdeographsInComplexText()
71 {
72     return true;
73 }
74
75 static inline void fillVectorWithHorizontalGlyphPositions(Vector<CGPoint, 256>& positions, CGContextRef context, const CGSize* advances, size_t count)
76 {
77     CGAffineTransform matrix = CGAffineTransformInvert(CGContextGetTextMatrix(context));
78     positions[0] = CGPointZero;
79     for (size_t i = 1; i < count; ++i) {
80         CGSize advance = CGSizeApplyAffineTransform(advances[i - 1], matrix);
81         positions[i].x = positions[i - 1].x + advance.width;
82         positions[i].y = positions[i - 1].y + advance.height;
83     }
84 }
85
86 static inline bool shouldUseLetterpressEffect(const GraphicsContext& context)
87 {
88 #if ENABLE(LETTERPRESS)
89     return context.textDrawingMode() & TextModeLetterpress;
90 #else
91     UNUSED_PARAM(context);
92     return false;
93 #endif
94 }
95
96 static void showLetterpressedGlyphsWithAdvances(const FloatPoint& point, const SimpleFontData* font, CGContextRef context, const CGGlyph* glyphs, const CGSize* advances, size_t count)
97 {
98 #if ENABLE(LETTERPRESS)
99     if (!count)
100         return;
101
102     const FontPlatformData& platformData = font->platformData();
103     if (platformData.orientation() == Vertical) {
104         // FIXME: Implement support for vertical text. See <rdar://problem/13737298>.
105         return;
106     }
107
108     CGContextSetTextPosition(context, point.x(), point.y());
109     Vector<CGPoint, 256> positions(count);
110     fillVectorWithHorizontalGlyphPositions(positions, context, advances, count);
111
112     CTFontRef ctFont = platformData.ctFont();
113     CGContextSetFontSize(context, CTFontGetSize(ctFont));
114
115     static CUICatalog *catalog = _UIKitGetTextEffectsCatalog();
116     if (!catalog)
117         return;
118
119     static CUIStyleEffectConfiguration *styleConfiguration;
120     if (!styleConfiguration) {
121         styleConfiguration = [[getCUIStyleEffectConfigurationClass() alloc] init];
122         styleConfiguration.useSimplifiedEffect = YES;
123     }
124
125     [catalog drawGlyphs:glyphs atPositions:positions.data() inContext:context withFont:ctFont count:count stylePresetName:@"_UIKitNewLetterpressStyle" styleConfiguration:styleConfiguration foregroundColor:CGContextGetFillColorAsColor(context)];
126 #else
127     UNUSED_PARAM(point);
128     UNUSED_PARAM(font);
129     UNUSED_PARAM(context);
130     UNUSED_PARAM(glyphs);
131     UNUSED_PARAM(advances);
132     UNUSED_PARAM(count);
133 #endif
134 }
135
136 static void showGlyphsWithAdvances(const FloatPoint& point, const SimpleFontData* font, CGContextRef context, const CGGlyph* glyphs, const CGSize* advances, size_t count)
137 {
138     if (!count)
139         return;
140
141     CGContextSetTextPosition(context, point.x(), point.y());
142
143     const FontPlatformData& platformData = font->platformData();
144     Vector<CGPoint, 256> positions(count);
145     if (platformData.isColorBitmapFont())
146         fillVectorWithHorizontalGlyphPositions(positions, context, advances, count);
147     if (platformData.orientation() == Vertical) {
148         CGAffineTransform savedMatrix;
149         CGAffineTransform rotateLeftTransform = CGAffineTransformMake(0, -1, 1, 0, 0, 0);
150         savedMatrix = CGContextGetTextMatrix(context);
151         CGAffineTransform runMatrix = CGAffineTransformConcat(savedMatrix, rotateLeftTransform);
152         CGContextSetTextMatrix(context, runMatrix);
153
154         Vector<CGSize, 256> translations(count);
155         CTFontGetVerticalTranslationsForGlyphs(platformData.ctFont(), glyphs, translations.data(), count);
156
157         CGAffineTransform transform = CGAffineTransformInvert(CGContextGetTextMatrix(context));
158
159         CGPoint position = FloatPoint(point.x(), point.y() + font->fontMetrics().floatAscent(IdeographicBaseline) - font->fontMetrics().floatAscent());
160         for (size_t i = 0; i < count; ++i) {
161             CGSize translation = CGSizeApplyAffineTransform(translations[i], rotateLeftTransform);
162             positions[i] = CGPointApplyAffineTransform(CGPointMake(position.x - translation.width, position.y + translation.height), transform);
163             position.x += advances[i].width;
164             position.y += advances[i].height;
165         }
166         if (!platformData.isColorBitmapFont())
167             CGContextShowGlyphsAtPositions(context, glyphs, positions.data(), count);
168         else
169             CTFontDrawGlyphs(platformData.ctFont(), glyphs, positions.data(), count, context);
170         CGContextSetTextMatrix(context, savedMatrix);
171     } else {
172         if (!platformData.isColorBitmapFont())
173 #pragma clang diagnostic push
174 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
175             CGContextShowGlyphsWithAdvances(context, glyphs, advances, count);
176 #pragma clang diagnostic pop
177         else
178             CTFontDrawGlyphs(platformData.ctFont(), glyphs, positions.data(), count, context);
179     }
180 }
181
182 void Font::drawGlyphs(GraphicsContext* context, const SimpleFontData* font, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& anchorPoint) const
183 {
184     const FontPlatformData& platformData = font->platformData();
185     if (!platformData.size())
186         return;
187
188     CGContextRef cgContext = context->platformContext();
189
190     bool shouldSmoothFonts;
191     bool changeFontSmoothing;
192     
193     switch(fontDescription().fontSmoothing()) {
194     case Antialiased: {
195         context->setShouldAntialias(true);
196         shouldSmoothFonts = false;
197         changeFontSmoothing = true;
198         break;
199     }
200     case SubpixelAntialiased: {
201         context->setShouldAntialias(true);
202         shouldSmoothFonts = true;
203         changeFontSmoothing = true;
204         break;
205     }
206     case NoSmoothing: {
207         context->setShouldAntialias(false);
208         shouldSmoothFonts = false;
209         changeFontSmoothing = true;
210         break;
211     }
212     case AutoSmoothing: {
213         shouldSmoothFonts = true;
214         changeFontSmoothing = false;
215         break;
216     }
217     }
218     
219     if (!shouldUseSmoothing()) {
220         shouldSmoothFonts = false;
221         changeFontSmoothing = true;
222     }
223
224 #if !PLATFORM(IOS)
225     bool originalShouldUseFontSmoothing = false;
226     if (changeFontSmoothing) {
227         originalShouldUseFontSmoothing = wkCGContextGetShouldSmoothFonts(cgContext);
228         CGContextSetShouldSmoothFonts(cgContext, shouldSmoothFonts);
229     }
230 #endif
231
232 #if !PLATFORM(IOS)
233     NSFont* drawFont;
234     if (!isPrinterFont()) {
235         drawFont = [platformData.font() screenFont];
236         if (drawFont != platformData.font())
237             // We are getting this in too many places (3406411); use ERROR so it only prints on debug versions for now. (We should debug this also, eventually).
238             LOG_ERROR("Attempting to set non-screen font (%@) when drawing to screen.  Using screen font anyway, may result in incorrect metrics.",
239                 [[[platformData.font() fontDescriptor] fontAttributes] objectForKey:NSFontNameAttribute]);
240     } else {
241         drawFont = [platformData.font() printerFont];
242         if (drawFont != platformData.font())
243             NSLog(@"Attempting to set non-printer font (%@) when printing.  Using printer font anyway, may result in incorrect metrics.",
244                 [[[platformData.font() fontDescriptor] fontAttributes] objectForKey:NSFontNameAttribute]);
245     }
246 #endif
247     
248     CGContextSetFont(cgContext, platformData.cgFont());
249
250     bool useLetterpressEffect = shouldUseLetterpressEffect(*context);
251     FloatPoint point = anchorPoint;
252 #if PLATFORM(IOS)
253     float fontSize = platformData.size();
254     CGAffineTransform matrix = useLetterpressEffect || platformData.isColorBitmapFont() ? CGAffineTransformIdentity : CGAffineTransformMakeScale(fontSize, fontSize);
255     if (platformData.m_isEmoji) {
256         if (!context->emojiDrawingEnabled())
257             return;
258
259         // Mimic the positioining of non-bitmap glyphs, which are not subpixel-positioned.
260         point.setY(ceilf(point.y()));
261
262         // Emoji glyphs snap to the CSS pixel grid.
263         point.setX(floorf(point.x()));
264
265         // Emoji glyphs are offset one CSS pixel to the right.
266         point.move(1, 0);
267
268         // Emoji glyphs are offset vertically based on font size.
269         float y = point.y();
270         if (fontSize <= 15) {
271             // Undo Core Text's y adjustment.
272             static float yAdjustmentFactor = iosExecutableWasLinkedOnOrAfterVersion(wkIOSSystemVersion_6_0) ? .19 : .1;
273             point.setY(floorf(y - yAdjustmentFactor * (fontSize + 2) + 2));
274         } else {
275             if (fontSize < 26)
276                 y -= .35f * fontSize - 10;
277
278             // Undo Core Text's y adjustment.
279             static float yAdjustment = iosExecutableWasLinkedOnOrAfterVersion(wkIOSSystemVersion_6_0) ? 3.8 : 2;
280             point.setY(floorf(y - yAdjustment));
281         }
282     }
283 #else
284     CGAffineTransform matrix = CGAffineTransformIdentity;
285     if (drawFont && !platformData.isColorBitmapFont())
286         memcpy(&matrix, [drawFont matrix], sizeof(matrix));
287 #endif
288     matrix.b = -matrix.b;
289     matrix.d = -matrix.d;
290     if (platformData.m_syntheticOblique && !useLetterpressEffect) {
291         static float obliqueSkew = tanf(SYNTHETIC_OBLIQUE_ANGLE * piFloat / 180);
292         if (platformData.orientation() == Vertical)
293             matrix = CGAffineTransformConcat(matrix, CGAffineTransformMake(1, obliqueSkew, 0, 1, 0, 0));
294         else
295             matrix = CGAffineTransformConcat(matrix, CGAffineTransformMake(1, 0, -obliqueSkew, 1, 0, 0));
296     }
297     CGContextSetTextMatrix(cgContext, matrix);
298
299 #if PLATFORM(IOS)
300     CGContextSetFontSize(cgContext, 1);
301 #else
302     wkSetCGFontRenderingMode(cgContext, drawFont, context->shouldSubpixelQuantizeFonts());
303     if (drawFont)
304         CGContextSetFontSize(cgContext, 1);
305     else
306         CGContextSetFontSize(cgContext, platformData.m_size);
307 #endif
308
309
310     FloatSize shadowOffset;
311     float shadowBlur;
312     Color shadowColor;
313     ColorSpace shadowColorSpace;
314     ColorSpace fillColorSpace = context->fillColorSpace();
315     context->getShadow(shadowOffset, shadowBlur, shadowColor, shadowColorSpace);
316
317     AffineTransform contextCTM = context->getCTM();
318     float syntheticBoldOffset = font->syntheticBoldOffset();
319     if (syntheticBoldOffset && !contextCTM.isIdentityOrTranslationOrFlipped()) {
320         FloatSize horizontalUnitSizeInDevicePixels = contextCTM.mapSize(FloatSize(1, 0));
321         float horizontalUnitLengthInDevicePixels = sqrtf(horizontalUnitSizeInDevicePixels.width() * horizontalUnitSizeInDevicePixels.width() + horizontalUnitSizeInDevicePixels.height() * horizontalUnitSizeInDevicePixels.height());
322         if (horizontalUnitLengthInDevicePixels)
323             syntheticBoldOffset /= horizontalUnitLengthInDevicePixels;
324     };
325
326     bool hasSimpleShadow = context->textDrawingMode() == TextModeFill && shadowColor.isValid() && !shadowBlur && !platformData.isColorBitmapFont() && (!context->shadowsIgnoreTransforms() || contextCTM.isIdentityOrTranslationOrFlipped()) && !context->isInTransparencyLayer();
327     if (hasSimpleShadow) {
328         // Paint simple shadows ourselves instead of relying on CG shadows, to avoid losing subpixel antialiasing.
329         context->clearShadow();
330         Color fillColor = context->fillColor();
331         Color shadowFillColor(shadowColor.red(), shadowColor.green(), shadowColor.blue(), shadowColor.alpha() * fillColor.alpha() / 255);
332         context->setFillColor(shadowFillColor, shadowColorSpace);
333         float shadowTextX = point.x() + shadowOffset.width();
334         // If shadows are ignoring transforms, then we haven't applied the Y coordinate flip yet, so down is negative.
335         float shadowTextY = point.y() + shadowOffset.height() * (context->shadowsIgnoreTransforms() ? -1 : 1);
336         showGlyphsWithAdvances(FloatPoint(shadowTextX, shadowTextY), font, cgContext, glyphBuffer.glyphs(from), static_cast<const CGSize*>(glyphBuffer.advances(from)), numGlyphs);
337 #if !PLATFORM(IOS)
338         if (syntheticBoldOffset)
339 #else
340         if (syntheticBoldOffset && !platformData.m_isEmoji)
341 #endif
342             showGlyphsWithAdvances(FloatPoint(shadowTextX + syntheticBoldOffset, shadowTextY), font, cgContext, glyphBuffer.glyphs(from), static_cast<const CGSize*>(glyphBuffer.advances(from)), numGlyphs);
343         context->setFillColor(fillColor, fillColorSpace);
344     }
345
346     if (useLetterpressEffect)
347         showLetterpressedGlyphsWithAdvances(point, font, cgContext, glyphBuffer.glyphs(from), static_cast<const CGSize*>(glyphBuffer.advances(from)), numGlyphs);
348     else
349         showGlyphsWithAdvances(point, font, cgContext, glyphBuffer.glyphs(from), static_cast<const CGSize*>(glyphBuffer.advances(from)), numGlyphs);
350 #if !PLATFORM(IOS)
351     if (syntheticBoldOffset)
352 #else
353     if (syntheticBoldOffset && !platformData.m_isEmoji)
354 #endif
355         showGlyphsWithAdvances(FloatPoint(point.x() + syntheticBoldOffset, point.y()), font, cgContext, glyphBuffer.glyphs(from), static_cast<const CGSize*>(glyphBuffer.advances(from)), numGlyphs);
356
357     if (hasSimpleShadow)
358         context->setShadow(shadowOffset, shadowBlur, shadowColor, shadowColorSpace);
359
360 #if !PLATFORM(IOS)
361     if (changeFontSmoothing)
362         CGContextSetShouldSmoothFonts(cgContext, originalShouldUseFontSmoothing);
363 #endif
364 }
365
366 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
367 struct GlyphIterationState {
368     GlyphIterationState(CGPoint startingPoint, CGPoint currentPoint, CGFloat y1, CGFloat y2, CGFloat minX, CGFloat maxX)
369         : startingPoint(startingPoint)
370         , currentPoint(currentPoint)
371         , y1(y1)
372         , y2(y2)
373         , minX(minX)
374         , maxX(maxX)
375     {
376     }
377     CGPoint startingPoint;
378     CGPoint currentPoint;
379     CGFloat y1;
380     CGFloat y2;
381     CGFloat minX;
382     CGFloat maxX;
383 };
384
385 static bool findIntersectionPoint(float y, CGPoint p1, CGPoint p2, CGFloat& x)
386 {
387     x = p1.x + (y - p1.y) * (p2.x - p1.x) / (p2.y - p1.y);
388     return (p1.y < y && p2.y > y) || (p1.y > y && p2.y < y);
389 }
390
391 // This function is called by CGPathApply and is therefore invoked for each
392 // contour in a glyph. This function models each contours as a straight line
393 // and calculates the intersections between each pseudo-contour and
394 // two horizontal lines (the upper and lower bounds of an underline) found in
395 // GlyphIterationState::y1 and GlyphIterationState::y2. It keeps track of the
396 // leftmost and rightmost intersection in GlyphIterationState::minX and
397 // GlyphIterationState::maxX.
398 static void findPathIntersections(void* stateAsVoidPointer, const CGPathElement* e)
399 {
400     auto& state = *static_cast<GlyphIterationState*>(stateAsVoidPointer);
401     bool doIntersection = false;
402     CGPoint point = CGPointZero;
403     switch (e->type) {
404     case kCGPathElementMoveToPoint:
405         state.startingPoint = e->points[0];
406         state.currentPoint = e->points[0];
407         break;
408     case kCGPathElementAddLineToPoint:
409         doIntersection = true;
410         point = e->points[0];
411         break;
412     case kCGPathElementAddQuadCurveToPoint:
413         doIntersection = true;
414         point = e->points[1];
415         break;
416     case kCGPathElementAddCurveToPoint:
417         doIntersection = true;
418         point = e->points[2];
419         break;
420     case kCGPathElementCloseSubpath:
421         doIntersection = true;
422         point = state.startingPoint;
423         break;
424     }
425     if (!doIntersection)
426         return;
427     CGFloat x;
428     if (findIntersectionPoint(state.y1, state.currentPoint, point, x)) {
429         state.minX = std::min(state.minX, x);
430         state.maxX = std::max(state.maxX, x);
431     }
432     if (findIntersectionPoint(state.y2, state.currentPoint, point, x)) {
433         state.minX = std::min(state.minX, x);
434         state.maxX = std::max(state.maxX, x);
435     }
436     state.currentPoint = point;
437 }
438
439 DashArray Font::dashesForIntersectionsWithRect(const TextRun& run, const FloatPoint& textOrigin, int textRunStartIndex, int textRunEndIndex, const FloatRect& lineExtents) const
440 {
441     float deltaX;
442     GlyphBuffer glyphBuffer;
443     if (codePath(run) != Complex)
444         deltaX = getGlyphsAndAdvancesForSimpleText(run, textRunStartIndex, textRunEndIndex, glyphBuffer);
445     else
446         deltaX = getGlyphsAndAdvancesForComplexText(run, textRunStartIndex, textRunEndIndex, glyphBuffer);
447     CGAffineTransform translation = CGAffineTransformMakeTranslation(textOrigin.x() + deltaX, textOrigin.y());
448     translation = CGAffineTransformScale(translation, 1, -1);
449     DashArray result;
450     for (int i = 0; i < glyphBuffer.size(); ++i) {
451         GlyphIterationState info = GlyphIterationState(CGPointMake(0, 0), CGPointMake(0, 0), lineExtents.y(), lineExtents.y() + lineExtents.height(), lineExtents.x() + lineExtents.width(), lineExtents.x());
452         RetainPtr<CGPathRef> path = adoptCF(CTFontCreatePathForGlyph(glyphBuffer.fontDataAt(i)->platformData().ctFont(), glyphBuffer.glyphAt(i), &translation));
453         CGPathApply(path.get(), &info, &findPathIntersections);
454         if (info.minX < info.maxX) {
455             result.append(info.minX - lineExtents.x());
456             result.append(info.maxX - lineExtents.x());
457         }
458         GlyphBufferAdvance advance = glyphBuffer.advanceAt(i);
459         translation = CGAffineTransformTranslate(translation, advance.width(), advance.height());
460     }
461     return result;
462 }
463 #endif
464
465 }