43f7f69474187c31f3eefa9f7793d0c913653cc9
[WebKit-https.git] / Source / WebCore / platform / graphics / mac / SimpleFontDataMac.mm
1 /*
2  * Copyright (C) 2005, 2006 Apple Computer, Inc.  All rights reserved.
3  * Copyright (C) 2006 Alexey Proskuryakov
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer. 
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution. 
14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission. 
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #import "config.h"
31 #import "SimpleFontData.h"
32
33 #import "BlockExceptions.h"
34 #import "Color.h"
35 #import "FloatRect.h"
36 #import "Font.h"
37 #import "FontCache.h"
38 #import "FontDescription.h"
39 #import "SharedBuffer.h"
40 #import "WebCoreSystemInterface.h"
41 #import <AppKit/AppKit.h>
42 #import <ApplicationServices/ApplicationServices.h>
43 #import <float.h>
44 #import <unicode/uchar.h>
45 #import <wtf/Assertions.h>
46 #import <wtf/StdLibExtras.h>
47 #import <wtf/RetainPtr.h>
48 #import <wtf/UnusedParam.h>
49
50 @interface NSFont (WebAppKitSecretAPI)
51 - (BOOL)_isFakeFixedPitch;
52 @end
53
54 using namespace std;
55
56 namespace WebCore {
57   
58 const float smallCapsFontSizeMultiplier = 0.7f;
59
60 static bool fontHasVerticalGlyphs(CTFontRef ctFont)
61 {
62     // The check doesn't look neat but this is what AppKit does for vertical writing...
63     RetainPtr<CFArrayRef> tableTags(AdoptCF, CTFontCopyAvailableTables(ctFont, kCTFontTableOptionExcludeSynthetic));
64     CFIndex numTables = CFArrayGetCount(tableTags.get());
65     for (CFIndex index = 0; index < numTables; ++index) {
66         CTFontTableTag tag = (CTFontTableTag)(uintptr_t)CFArrayGetValueAtIndex(tableTags.get(), index);
67         if (tag == kCTFontTableVhea || tag == kCTFontTableVORG)
68             return true;
69     }
70     return false;
71 }
72
73 static bool initFontData(SimpleFontData* fontData)
74 {
75     if (!fontData->platformData().cgFont())
76         return false;
77
78
79     return true;
80 }
81
82 static NSString *webFallbackFontFamily(void)
83 {
84     DEFINE_STATIC_LOCAL(RetainPtr<NSString>, webFallbackFontFamily, ([[NSFont systemFontOfSize:16.0f] familyName]));
85     return webFallbackFontFamily.get();
86 }
87
88 #if !ERROR_DISABLED
89 #if defined(__LP64__) || (!defined(BUILDING_ON_LEOPARD) && !defined(BUILDING_ON_SNOW_LEOPARD))
90 static NSString* pathFromFont(NSFont*)
91 {
92     // FMGetATSFontRefFromFont is not available. As pathFromFont is only used for debugging purposes,
93     // returning nil is acceptable.
94     return nil;
95 }
96 #else
97 static NSString* pathFromFont(NSFont *font)
98 {
99     ATSFontRef atsFont = FMGetATSFontRefFromFont(CTFontGetPlatformFont(toCTFontRef(font), 0));
100     FSRef fileRef;
101
102     OSStatus status = ATSFontGetFileReference(atsFont, &fileRef);
103     if (status != noErr)
104         return nil;
105
106     UInt8 filePathBuffer[PATH_MAX];
107     status = FSRefMakePath(&fileRef, filePathBuffer, PATH_MAX);
108     if (status == noErr)
109         return [NSString stringWithUTF8String:(const char*)filePathBuffer];
110
111     return nil;
112 }
113 #endif // __LP64__
114 #endif // !ERROR_DISABLED
115
116 void SimpleFontData::platformInit()
117 {
118 #if USE(ATSUI)
119     m_ATSUMirrors = false;
120     m_checkedShapesArabic = false;
121     m_shapesArabic = false;
122 #endif
123
124     m_syntheticBoldOffset = m_platformData.m_syntheticBold ? 1.0f : 0.f;
125
126     bool failedSetup = false;
127     if (!initFontData(this)) {
128         // Ack! Something very bad happened, like a corrupt font.
129         // Try looking for an alternate 'base' font for this renderer.
130
131         // Special case hack to use "Times New Roman" in place of "Times".
132         // "Times RO" is a common font whose family name is "Times".
133         // It overrides the normal "Times" family font.
134         // It also appears to have a corrupt regular variant.
135         NSString *fallbackFontFamily;
136         if ([[m_platformData.font() familyName] isEqual:@"Times"])
137             fallbackFontFamily = @"Times New Roman";
138         else
139             fallbackFontFamily = webFallbackFontFamily();
140         
141         // Try setting up the alternate font.
142         // This is a last ditch effort to use a substitute font when something has gone wrong.
143 #if !ERROR_DISABLED
144         RetainPtr<NSFont> initialFont = m_platformData.font();
145 #endif
146         if (m_platformData.font())
147             m_platformData.setFont([[NSFontManager sharedFontManager] convertFont:m_platformData.font() toFamily:fallbackFontFamily]);
148         else
149             m_platformData.setFont([NSFont fontWithName:fallbackFontFamily size:m_platformData.size()]);
150 #if !ERROR_DISABLED
151         NSString *filePath = pathFromFont(initialFont.get());
152         if (!filePath)
153             filePath = @"not known";
154 #endif
155         if (!initFontData(this)) {
156             if ([fallbackFontFamily isEqual:@"Times New Roman"]) {
157                 // OK, couldn't setup Times New Roman as an alternate to Times, fallback
158                 // on the system font.  If this fails we have no alternative left.
159                 m_platformData.setFont([[NSFontManager sharedFontManager] convertFont:m_platformData.font() toFamily:webFallbackFontFamily()]);
160                 if (!initFontData(this)) {
161                     // We tried, Times, Times New Roman, and the system font. No joy. We have to give up.
162                     LOG_ERROR("unable to initialize with font %@ at %@", initialFont.get(), filePath);
163                     failedSetup = true;
164                 }
165             } else {
166                 // We tried the requested font and the system font. No joy. We have to give up.
167                 LOG_ERROR("unable to initialize with font %@ at %@", initialFont.get(), filePath);
168                 failedSetup = true;
169             }
170         }
171
172         // Report the problem.
173         LOG_ERROR("Corrupt font detected, using %@ in place of %@ located at \"%@\".",
174             [m_platformData.font() familyName], [initialFont.get() familyName], filePath);
175     }
176
177     // If all else fails, try to set up using the system font.
178     // This is probably because Times and Times New Roman are both unavailable.
179     if (failedSetup) {
180         m_platformData.setFont([NSFont systemFontOfSize:[m_platformData.font() pointSize]]);
181         LOG_ERROR("failed to set up font, using system font %s", m_platformData.font());
182         initFontData(this);
183     }
184     
185     int iAscent;
186     int iDescent;
187     int iLineGap;
188     unsigned unitsPerEm;
189     iAscent = CGFontGetAscent(m_platformData.cgFont());
190     // Some fonts erroneously specify a positive descender value. We follow Core Text in assuming that
191     // such fonts meant the same distance, but in the reverse direction.
192     iDescent = -abs(CGFontGetDescent(m_platformData.cgFont()));
193     iLineGap = CGFontGetLeading(m_platformData.cgFont());
194     unitsPerEm = CGFontGetUnitsPerEm(m_platformData.cgFont());
195
196     float pointSize = m_platformData.m_size;
197     float ascent = scaleEmToUnits(iAscent, unitsPerEm) * pointSize;
198     float descent = -scaleEmToUnits(iDescent, unitsPerEm) * pointSize;
199     float lineGap = scaleEmToUnits(iLineGap, unitsPerEm) * pointSize;
200
201     // We need to adjust Times, Helvetica, and Courier to closely match the
202     // vertical metrics of their Microsoft counterparts that are the de facto
203     // web standard. The AppKit adjustment of 20% is too big and is
204     // incorrectly added to line spacing, so we use a 15% adjustment instead
205     // and add it to the ascent.
206     NSString *familyName = [m_platformData.font() familyName];
207     if ([familyName isEqualToString:@"Times"] || [familyName isEqualToString:@"Helvetica"] || [familyName isEqualToString:@"Courier"])
208         ascent += floorf(((ascent + descent) * 0.15f) + 0.5f);
209 #if defined(BUILDING_ON_LEOPARD)
210     else if ([familyName isEqualToString:@"Geeza Pro"]) {
211         // Geeza Pro has glyphs that draw slightly above the ascent or far below the descent. Adjust
212         // those vertical metrics to better match reality, so that diacritics at the bottom of one line
213         // do not overlap diacritics at the top of the next line.
214         ascent *= 1.08f;
215         descent *= 2.f;
216     }
217 #endif
218
219     // Compute and store line spacing, before the line metrics hacks are applied.
220     m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) + lroundf(lineGap));
221
222     // Hack Hiragino line metrics to allow room for marked text underlines.
223     // <rdar://problem/5386183>
224     if (descent < 3 && lineGap >= 3 && [familyName hasPrefix:@"Hiragino"]) {
225         lineGap -= 3 - descent;
226         descent = 3;
227     }
228     
229     if (platformData().orientation() == Vertical && !isTextOrientationFallback())
230         m_hasVerticalGlyphs = fontHasVerticalGlyphs(m_platformData.ctFont());
231
232     float xHeight;
233
234     if (platformData().orientation() == Horizontal) {
235         // Measure the actual character "x", since it's possible for it to extend below the baseline, and we need the
236         // reported x-height to only include the portion of the glyph that is above the baseline.
237         GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
238         NSGlyph xGlyph = glyphPageZero ? glyphPageZero->glyphDataForCharacter('x').glyph : 0;
239         if (xGlyph)
240             xHeight = -CGRectGetMinY(platformBoundsForGlyph(xGlyph));
241         else
242             xHeight = scaleEmToUnits(CGFontGetXHeight(m_platformData.cgFont()), unitsPerEm) * pointSize;
243     } else
244         xHeight = verticalRightOrientationFontData()->fontMetrics().xHeight();
245
246     m_fontMetrics.setUnitsPerEm(unitsPerEm);
247     m_fontMetrics.setAscent(ascent);
248     m_fontMetrics.setDescent(descent);
249     m_fontMetrics.setLineGap(lineGap);
250     m_fontMetrics.setXHeight(xHeight);
251 }
252
253 static CFDataRef copyFontTableForTag(FontPlatformData& platformData, FourCharCode tableName)
254 {
255     return CGFontCopyTableForTag(platformData.cgFont(), tableName);
256 }
257
258 void SimpleFontData::platformCharWidthInit()
259 {
260     m_avgCharWidth = 0;
261     m_maxCharWidth = 0;
262     
263     RetainPtr<CFDataRef> os2Table(AdoptCF, copyFontTableForTag(m_platformData, 'OS/2'));
264     if (os2Table && CFDataGetLength(os2Table.get()) >= 4) {
265         const UInt8* os2 = CFDataGetBytePtr(os2Table.get());
266         SInt16 os2AvgCharWidth = os2[2] * 256 + os2[3];
267         m_avgCharWidth = scaleEmToUnits(os2AvgCharWidth, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
268     }
269
270     RetainPtr<CFDataRef> headTable(AdoptCF, copyFontTableForTag(m_platformData, 'head'));
271     if (headTable && CFDataGetLength(headTable.get()) >= 42) {
272         const UInt8* head = CFDataGetBytePtr(headTable.get());
273         ushort uxMin = head[36] * 256 + head[37];
274         ushort uxMax = head[40] * 256 + head[41];
275         SInt16 xMin = static_cast<SInt16>(uxMin);
276         SInt16 xMax = static_cast<SInt16>(uxMax);
277         float diff = static_cast<float>(xMax - xMin);
278         m_maxCharWidth = scaleEmToUnits(diff, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
279     }
280
281     // Fallback to a cross-platform estimate, which will populate these values if they are non-positive.
282     initCharWidths();
283 }
284
285 void SimpleFontData::platformDestroy()
286 {
287     if (!isCustomFont() && m_derivedFontData) {
288         // These come from the cache.
289         if (m_derivedFontData->smallCaps)
290             fontCache()->releaseFontData(m_derivedFontData->smallCaps.leakPtr());
291
292         if (m_derivedFontData->emphasisMark)
293             fontCache()->releaseFontData(m_derivedFontData->emphasisMark.leakPtr());
294     }
295
296 #if USE(ATSUI)
297     HashMap<unsigned, ATSUStyle>::iterator end = m_ATSUStyleMap.end();
298     for (HashMap<unsigned, ATSUStyle>::iterator it = m_ATSUStyleMap.begin(); it != end; ++it)
299         ATSUDisposeStyle(it->second);
300 #endif
301 }
302
303 PassOwnPtr<SimpleFontData> SimpleFontData::createScaledFontData(const FontDescription& fontDescription, float scaleFactor) const
304 {
305     if (isCustomFont()) {
306         FontPlatformData scaledFontData(m_platformData);
307         scaledFontData.m_size = scaledFontData.m_size * scaleFactor;
308         return adoptPtr(new SimpleFontData(scaledFontData, true, false));
309     }
310
311     BEGIN_BLOCK_OBJC_EXCEPTIONS;
312     float size = m_platformData.size() * scaleFactor;
313     FontPlatformData scaledFontData([[NSFontManager sharedFontManager] convertFont:m_platformData.font() toSize:size], size, false, false, m_platformData.orientation());
314
315     // AppKit resets the type information (screen/printer) when you convert a font to a different size.
316     // We have to fix up the font that we're handed back.
317     scaledFontData.setFont(fontDescription.usePrinterFont() ? [scaledFontData.font() printerFont] : [scaledFontData.font() screenFont]);
318
319     if (scaledFontData.font()) {
320         NSFontManager *fontManager = [NSFontManager sharedFontManager];
321         NSFontTraitMask fontTraits = [fontManager traitsOfFont:m_platformData.font()];
322
323         if (m_platformData.m_syntheticBold)
324             fontTraits |= NSBoldFontMask;
325         if (m_platformData.m_syntheticOblique)
326             fontTraits |= NSItalicFontMask;
327
328         NSFontTraitMask scaledFontTraits = [fontManager traitsOfFont:scaledFontData.font()];
329         scaledFontData.m_syntheticBold = (fontTraits & NSBoldFontMask) && !(scaledFontTraits & NSBoldFontMask);
330         scaledFontData.m_syntheticOblique = (fontTraits & NSItalicFontMask) && !(scaledFontTraits & NSItalicFontMask);
331
332         // SimpleFontData::platformDestroy() takes care of not deleting the cached font data twice.
333         return adoptPtr(fontCache()->getCachedFontData(&scaledFontData));
334     }
335     END_BLOCK_OBJC_EXCEPTIONS;
336
337     return nullptr;
338 }
339
340 SimpleFontData* SimpleFontData::smallCapsFontData(const FontDescription& fontDescription) const
341 {
342     if (!m_derivedFontData)
343         m_derivedFontData = DerivedFontData::create(isCustomFont());
344     if (!m_derivedFontData->smallCaps)
345         m_derivedFontData->smallCaps = createScaledFontData(fontDescription, smallCapsFontSizeMultiplier);
346
347     return m_derivedFontData->smallCaps.get();
348 }
349
350 SimpleFontData* SimpleFontData::emphasisMarkFontData(const FontDescription& fontDescription) const
351 {
352     if (!m_derivedFontData)
353         m_derivedFontData = DerivedFontData::create(isCustomFont());
354     if (!m_derivedFontData->emphasisMark)
355         m_derivedFontData->emphasisMark = createScaledFontData(fontDescription, .5f);
356
357     return m_derivedFontData->emphasisMark.get();
358 }
359
360 bool SimpleFontData::containsCharacters(const UChar* characters, int length) const
361 {
362     NSString *string = [[NSString alloc] initWithCharactersNoCopy:const_cast<unichar*>(characters) length:length freeWhenDone:NO];
363     NSCharacterSet *set = [[m_platformData.font() coveredCharacterSet] invertedSet];
364     bool result = set && [string rangeOfCharacterFromSet:set].location == NSNotFound;
365     [string release];
366     return result;
367 }
368
369 void SimpleFontData::determinePitch()
370 {
371     NSFont* f = m_platformData.font();
372     // Special case Osaka-Mono.
373     // According to <rdar://problem/3999467>, we should treat Osaka-Mono as fixed pitch.
374     // Note that the AppKit does not report Osaka-Mono as fixed pitch.
375
376     // Special case MS-PGothic.
377     // According to <rdar://problem/4032938>, we should not treat MS-PGothic as fixed pitch.
378     // Note that AppKit does report MS-PGothic as fixed pitch.
379
380     // Special case MonotypeCorsiva
381     // According to <rdar://problem/5454704>, we should not treat MonotypeCorsiva as fixed pitch.
382     // Note that AppKit does report MonotypeCorsiva as fixed pitch.
383
384     NSString *name = [f fontName];
385     m_treatAsFixedPitch = ([f isFixedPitch] || [f _isFakeFixedPitch] ||
386            [name caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame) &&
387            [name caseInsensitiveCompare:@"MS-PGothic"] != NSOrderedSame &&
388            [name caseInsensitiveCompare:@"MonotypeCorsiva"] != NSOrderedSame;
389 }
390
391 FloatRect SimpleFontData::platformBoundsForGlyph(Glyph glyph) const
392 {
393     FloatRect boundingBox;
394     boundingBox = CTFontGetBoundingRectsForGlyphs(m_platformData.ctFont(), platformData().orientation() == Vertical ? kCTFontVerticalOrientation : kCTFontHorizontalOrientation, &glyph, 0, 1);
395     boundingBox.setY(-boundingBox.maxY());
396     if (m_syntheticBoldOffset)
397         boundingBox.setWidth(boundingBox.width() + m_syntheticBoldOffset);
398
399     return boundingBox;
400 }
401
402 float SimpleFontData::platformWidthForGlyph(Glyph glyph) const
403 {
404     CGSize advance = CGSizeZero;
405     if (platformData().orientation() == Horizontal || m_isBrokenIdeographFallback) {
406         NSFont* font = platformData().font();
407         float pointSize = platformData().m_size;
408         CGAffineTransform m = CGAffineTransformMakeScale(pointSize, pointSize);
409         if (!wkGetGlyphTransformedAdvances(platformData().cgFont(), font, &m, &glyph, &advance)) {
410             LOG_ERROR("Unable to cache glyph widths for %@ %f", [font displayName], pointSize);
411             advance.width = 0;
412         }
413     } else
414         CTFontGetAdvancesForGlyphs(m_platformData.ctFont(), kCTFontVerticalOrientation, &glyph, &advance, 1);
415
416     return advance.width + m_syntheticBoldOffset;
417 }
418
419 } // namespace WebCore