3094498e57258ee5c97156bea427a64d5eb5e6d0
[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 static inline float scaleEmToUnits(float x, unsigned unitsPerEm) { return x / unitsPerEm; }
60
61 static bool initFontData(SimpleFontData* fontData)
62 {
63     if (!fontData->platformData().cgFont())
64         return false;
65
66 #ifdef BUILDING_ON_TIGER
67     ATSUStyle fontStyle;
68     if (ATSUCreateStyle(&fontStyle) != noErr)
69         return false;
70
71     ATSUFontID fontId = fontData->platformData().m_atsuFontID;
72     if (!fontId) {
73         ATSUDisposeStyle(fontStyle);
74         return false;
75     }
76
77     ATSUAttributeTag tag = kATSUFontTag;
78     ByteCount size = sizeof(ATSUFontID);
79     ATSUFontID *valueArray[1] = {&fontId};
80     OSStatus status = ATSUSetAttributes(fontStyle, 1, &tag, &size, (void* const*)valueArray);
81     if (status != noErr) {
82         ATSUDisposeStyle(fontStyle);
83         return false;
84     }
85
86     if (wkGetATSStyleGroup(fontStyle, &fontData->m_styleGroup) != noErr) {
87         ATSUDisposeStyle(fontStyle);
88         return false;
89     }
90
91     ATSUDisposeStyle(fontStyle);
92 #endif
93
94     return true;
95 }
96
97 static NSString *webFallbackFontFamily(void)
98 {
99     DEFINE_STATIC_LOCAL(RetainPtr<NSString>, webFallbackFontFamily, ([[NSFont systemFontOfSize:16.0f] familyName]));
100     return webFallbackFontFamily.get();
101 }
102
103 #if !ERROR_DISABLED
104 #if defined(__LP64__) || (!defined(BUILDING_ON_TIGER) && !defined(BUILDING_ON_LEOPARD) && !defined(BUILDING_ON_SNOW_LEOPARD))
105 static NSString* pathFromFont(NSFont*)
106 {
107     // FMGetATSFontRefFromFont is not available. As pathFromFont is only used for debugging purposes,
108     // returning nil is acceptable.
109     return nil;
110 }
111 #else
112 static NSString* pathFromFont(NSFont *font)
113 {
114 #ifndef BUILDING_ON_TIGER
115     ATSFontRef atsFont = FMGetATSFontRefFromFont(CTFontGetPlatformFont(toCTFontRef(font), 0));
116 #else
117     ATSFontRef atsFont = FMGetATSFontRefFromFont(wkGetNSFontATSUFontId(font));
118 #endif
119     FSRef fileRef;
120
121 #ifndef BUILDING_ON_TIGER
122     OSStatus status = ATSFontGetFileReference(atsFont, &fileRef);
123     if (status != noErr)
124         return nil;
125 #else
126     FSSpec oFile;
127     OSStatus status = ATSFontGetFileSpecification(atsFont, &oFile);
128     if (status != noErr)
129         return nil;
130
131     status = FSpMakeFSRef(&oFile, &fileRef);
132     if (status != noErr)
133         return nil;
134 #endif
135
136     UInt8 filePathBuffer[PATH_MAX];
137     status = FSRefMakePath(&fileRef, filePathBuffer, PATH_MAX);
138     if (status == noErr)
139         return [NSString stringWithUTF8String:(const char*)filePathBuffer];
140
141     return nil;
142 }
143 #endif // __LP64__
144 #endif // !ERROR_DISABLED
145
146 void SimpleFontData::platformInit()
147 {
148 #ifdef BUILDING_ON_TIGER
149     m_styleGroup = 0;
150 #endif
151 #if USE(ATSUI)
152     m_ATSUMirrors = false;
153     m_checkedShapesArabic = false;
154     m_shapesArabic = false;
155 #endif
156
157     m_syntheticBoldOffset = m_platformData.m_syntheticBold ? 1.0f : 0.f;
158
159     bool failedSetup = false;
160     if (!initFontData(this)) {
161         // Ack! Something very bad happened, like a corrupt font.
162         // Try looking for an alternate 'base' font for this renderer.
163
164         // Special case hack to use "Times New Roman" in place of "Times".
165         // "Times RO" is a common font whose family name is "Times".
166         // It overrides the normal "Times" family font.
167         // It also appears to have a corrupt regular variant.
168         NSString *fallbackFontFamily;
169         if ([[m_platformData.font() familyName] isEqual:@"Times"])
170             fallbackFontFamily = @"Times New Roman";
171         else
172             fallbackFontFamily = webFallbackFontFamily();
173         
174         // Try setting up the alternate font.
175         // This is a last ditch effort to use a substitute font when something has gone wrong.
176 #if !ERROR_DISABLED
177         RetainPtr<NSFont> initialFont = m_platformData.font();
178 #endif
179         if (m_platformData.font())
180             m_platformData.setFont([[NSFontManager sharedFontManager] convertFont:m_platformData.font() toFamily:fallbackFontFamily]);
181         else
182             m_platformData.setFont([NSFont fontWithName:fallbackFontFamily size:m_platformData.size()]);
183 #if !ERROR_DISABLED
184         NSString *filePath = pathFromFont(initialFont.get());
185         if (!filePath)
186             filePath = @"not known";
187 #endif
188         if (!initFontData(this)) {
189             if ([fallbackFontFamily isEqual:@"Times New Roman"]) {
190                 // OK, couldn't setup Times New Roman as an alternate to Times, fallback
191                 // on the system font.  If this fails we have no alternative left.
192                 m_platformData.setFont([[NSFontManager sharedFontManager] convertFont:m_platformData.font() toFamily:webFallbackFontFamily()]);
193                 if (!initFontData(this)) {
194                     // We tried, Times, Times New Roman, and the system font. No joy. We have to give up.
195                     LOG_ERROR("unable to initialize with font %@ at %@", initialFont.get(), filePath);
196                     failedSetup = true;
197                 }
198             } else {
199                 // We tried the requested font and the system font. No joy. We have to give up.
200                 LOG_ERROR("unable to initialize with font %@ at %@", initialFont.get(), filePath);
201                 failedSetup = true;
202             }
203         }
204
205         // Report the problem.
206         LOG_ERROR("Corrupt font detected, using %@ in place of %@ located at \"%@\".",
207             [m_platformData.font() familyName], [initialFont.get() familyName], filePath);
208     }
209
210     // If all else fails, try to set up using the system font.
211     // This is probably because Times and Times New Roman are both unavailable.
212     if (failedSetup) {
213         m_platformData.setFont([NSFont systemFontOfSize:[m_platformData.font() pointSize]]);
214         LOG_ERROR("failed to set up font, using system font %s", m_platformData.font());
215         initFontData(this);
216     }
217     
218     int iAscent;
219     int iDescent;
220     int iLineGap;
221     unsigned unitsPerEm;
222 #ifdef BUILDING_ON_TIGER
223     wkGetFontMetrics(m_platformData.cgFont(), &iAscent, &iDescent, &iLineGap, &unitsPerEm);
224 #else
225     iAscent = CGFontGetAscent(m_platformData.cgFont());
226     iDescent = CGFontGetDescent(m_platformData.cgFont());
227     iLineGap = CGFontGetLeading(m_platformData.cgFont());
228     unitsPerEm = CGFontGetUnitsPerEm(m_platformData.cgFont());
229 #endif
230
231     float pointSize = m_platformData.m_size;
232     float ascent = scaleEmToUnits(iAscent, unitsPerEm) * pointSize;
233     float descent = -scaleEmToUnits(iDescent, unitsPerEm) * pointSize;
234     float lineGap = scaleEmToUnits(iLineGap, unitsPerEm) * pointSize;
235
236     // We need to adjust Times, Helvetica, and Courier to closely match the
237     // vertical metrics of their Microsoft counterparts that are the de facto
238     // web standard. The AppKit adjustment of 20% is too big and is
239     // incorrectly added to line spacing, so we use a 15% adjustment instead
240     // and add it to the ascent.
241     NSString *familyName = [m_platformData.font() familyName];
242     if ([familyName isEqualToString:@"Times"] || [familyName isEqualToString:@"Helvetica"] || [familyName isEqualToString:@"Courier"])
243         ascent += floorf(((ascent + descent) * 0.15f) + 0.5f);
244     else if ([familyName isEqualToString:@"Geeza Pro"]) {
245         // Geeza Pro has glyphs that draw slightly above the ascent or far below the descent. Adjust
246         // those vertical metrics to better match reality, so that diacritics at the bottom of one line
247         // do not overlap diacritics at the top of the next line.
248         ascent *= 1.08f;
249         descent *= 2.f;
250     }
251
252     // Compute and store line spacing, before the line metrics hacks are applied.
253     m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) + lroundf(lineGap));
254
255     // Hack Hiragino line metrics to allow room for marked text underlines.
256     // <rdar://problem/5386183>
257     if (descent < 3 && lineGap >= 3 && [familyName hasPrefix:@"Hiragino"]) {
258         lineGap -= 3 - descent;
259         descent = 3;
260     }
261     
262     if (m_orientation == Vertical) {
263         // Ignore vertical orientation when the font doesn't support vertical metrics.
264         // The check doesn't look neat but this is what AppKit does for vertical writing...
265         RetainPtr<CFArrayRef> tableTags(AdoptCF, CTFontCopyAvailableTables(m_platformData.ctFont(), kCTFontTableOptionExcludeSynthetic));
266         CFIndex numTables = CFArrayGetCount(tableTags.get());
267         bool found = false;
268         for (CFIndex index = 0; index < numTables; ++index) {
269             CTFontTableTag tag = (CTFontTableTag)(uintptr_t)CFArrayGetValueAtIndex(tableTags.get(), index);
270             if (tag == kCTFontTableVhea || tag == kCTFontTableVORG) {
271                 found = true;
272                 break;
273             }
274         }
275
276         if (found == false)
277             m_orientation = Horizontal;
278     }
279
280     float xHeight;
281
282     // Measure the actual character "x", because AppKit synthesizes X height rather than getting it from the font.
283     // Unfortunately, NSFont will round this for us so we don't quite get the right value.
284     GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
285     NSGlyph xGlyph = glyphPageZero ? glyphPageZero->glyphDataForCharacter('x').glyph : 0;
286     if (xGlyph) {
287         CGRect xBox = platformBoundsForGlyph(xGlyph);
288         // Use the maximum of either width or height because "x" is nearly square
289         // and web pages that foolishly use this metric for width will be laid out
290         // poorly if we return an accurate height. Classic case is Times 13 point,
291         // which has an "x" that is 7x6 pixels.
292         xHeight = static_cast<float>(max(CGRectGetMaxX(xBox), -CGRectGetMinY(xBox)));
293     } else {
294 #ifndef BUILDING_ON_TIGER
295         xHeight = static_cast<float>(CGFontGetXHeight(m_platformData.cgFont())) / unitsPerEm;
296 #else
297         xHeight = m_platformData.font() ? [m_platformData.font() xHeight] : 0;
298 #endif
299         // CGFontGetXHeight() returns a wrong value for "Apple Symbols" font (a float close to 0, but not strictly 0).
300         // The following code makes a guess for xHeight in that case.
301         // The int cast is a workaround for the "almost" zero value returned by CGFontGetXHeight().
302         if (!static_cast<int>(xHeight) && ascent)
303             xHeight = 2 * ascent / 3;
304     }
305
306     m_fontMetrics.setUnitsPerEm(unitsPerEm);
307     m_fontMetrics.setAscent(ascent);
308     m_fontMetrics.setDescent(descent);
309     m_fontMetrics.setLineGap(lineGap);
310     m_fontMetrics.setXHeight(xHeight);
311 }
312
313 static CFDataRef copyFontTableForTag(FontPlatformData& platformData, FourCharCode tableName)
314 {
315 #ifdef BUILDING_ON_TIGER
316     ATSFontRef atsFont = FMGetATSFontRefFromFont(platformData.m_atsuFontID);
317
318     ByteCount tableSize;
319     if (ATSFontGetTable(atsFont, tableName, 0, 0, NULL, &tableSize) != noErr)
320         return 0;
321     
322     CFMutableDataRef data = CFDataCreateMutable(kCFAllocatorDefault, tableSize);
323     if (!data)
324         return 0;
325     
326     CFDataIncreaseLength(data, tableSize);
327     if (ATSFontGetTable(atsFont, tableName, 0, tableSize, CFDataGetMutableBytePtr(data), &tableSize) != noErr) {
328         CFRelease(data);
329         return 0;
330     }
331     
332     return data;
333 #else
334     return CGFontCopyTableForTag(platformData.cgFont(), tableName);
335 #endif
336 }
337
338 void SimpleFontData::platformCharWidthInit()
339 {
340     m_avgCharWidth = 0;
341     m_maxCharWidth = 0;
342     
343     RetainPtr<CFDataRef> os2Table(AdoptCF, copyFontTableForTag(m_platformData, 'OS/2'));
344     if (os2Table && CFDataGetLength(os2Table.get()) >= 4) {
345         const UInt8* os2 = CFDataGetBytePtr(os2Table.get());
346         SInt16 os2AvgCharWidth = os2[2] * 256 + os2[3];
347         m_avgCharWidth = scaleEmToUnits(os2AvgCharWidth, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
348     }
349
350     RetainPtr<CFDataRef> headTable(AdoptCF, copyFontTableForTag(m_platformData, 'head'));
351     if (headTable && CFDataGetLength(headTable.get()) >= 42) {
352         const UInt8* head = CFDataGetBytePtr(headTable.get());
353         ushort uxMin = head[36] * 256 + head[37];
354         ushort uxMax = head[40] * 256 + head[41];
355         SInt16 xMin = static_cast<SInt16>(uxMin);
356         SInt16 xMax = static_cast<SInt16>(uxMax);
357         float diff = static_cast<float>(xMax - xMin);
358         m_maxCharWidth = scaleEmToUnits(diff, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
359     }
360
361     // Fallback to a cross-platform estimate, which will populate these values if they are non-positive.
362     initCharWidths();
363 }
364
365 void SimpleFontData::platformDestroy()
366 {
367     if (!isCustomFont() && m_derivedFontData) {
368         // These come from the cache.
369         if (m_derivedFontData->smallCaps)
370             fontCache()->releaseFontData(m_derivedFontData->smallCaps.leakPtr());
371
372         if (m_derivedFontData->emphasisMark)
373             fontCache()->releaseFontData(m_derivedFontData->emphasisMark.leakPtr());
374     }
375
376 #ifdef BUILDING_ON_TIGER
377     if (m_styleGroup)
378         wkReleaseStyleGroup(m_styleGroup);
379 #endif
380 #if USE(ATSUI)
381     HashMap<unsigned, ATSUStyle>::iterator end = m_ATSUStyleMap.end();
382     for (HashMap<unsigned, ATSUStyle>::iterator it = m_ATSUStyleMap.begin(); it != end; ++it)
383         ATSUDisposeStyle(it->second);
384 #endif
385 }
386
387 SimpleFontData* SimpleFontData::scaledFontData(const FontDescription& fontDescription, float scaleFactor) const
388 {
389     if (isCustomFont()) {
390         FontPlatformData scaledFontData(m_platformData);
391         scaledFontData.m_size = scaledFontData.m_size * scaleFactor;
392         return new SimpleFontData(scaledFontData, true, false);
393     }
394
395     BEGIN_BLOCK_OBJC_EXCEPTIONS;
396     float size = m_platformData.size() * scaleFactor;
397     FontPlatformData scaledFontData([[NSFontManager sharedFontManager] convertFont:m_platformData.font() toSize:size], size, false, false, m_platformData.orientation());
398
399     // AppKit resets the type information (screen/printer) when you convert a font to a different size.
400     // We have to fix up the font that we're handed back.
401     scaledFontData.setFont(fontDescription.usePrinterFont() ? [scaledFontData.font() printerFont] : [scaledFontData.font() screenFont]);
402
403     if (scaledFontData.font()) {
404         NSFontManager *fontManager = [NSFontManager sharedFontManager];
405         NSFontTraitMask fontTraits = [fontManager traitsOfFont:m_platformData.font()];
406
407         if (m_platformData.m_syntheticBold)
408             fontTraits |= NSBoldFontMask;
409         if (m_platformData.m_syntheticOblique)
410             fontTraits |= NSItalicFontMask;
411
412         NSFontTraitMask scaledFontTraits = [fontManager traitsOfFont:scaledFontData.font()];
413         scaledFontData.m_syntheticBold = (fontTraits & NSBoldFontMask) && !(scaledFontTraits & NSBoldFontMask);
414         scaledFontData.m_syntheticOblique = (fontTraits & NSItalicFontMask) && !(scaledFontTraits & NSItalicFontMask);
415
416         return fontCache()->getCachedFontData(&scaledFontData);
417     }
418     END_BLOCK_OBJC_EXCEPTIONS;
419
420     return 0;
421 }
422
423 SimpleFontData* SimpleFontData::smallCapsFontData(const FontDescription& fontDescription) const
424 {
425     if (!m_derivedFontData)
426         m_derivedFontData = DerivedFontData::create(isCustomFont());
427     if (!m_derivedFontData->smallCaps)
428         m_derivedFontData->smallCaps = scaledFontData(fontDescription, smallCapsFontSizeMultiplier);
429
430     return m_derivedFontData->smallCaps.get();
431 }
432
433 SimpleFontData* SimpleFontData::emphasisMarkFontData(const FontDescription& fontDescription) const
434 {
435     if (!m_derivedFontData)
436         m_derivedFontData = DerivedFontData::create(isCustomFont());
437     if (!m_derivedFontData->emphasisMark)
438         m_derivedFontData->emphasisMark = scaledFontData(fontDescription, .5f);
439
440     return m_derivedFontData->emphasisMark.get();
441 }
442
443 bool SimpleFontData::containsCharacters(const UChar* characters, int length) const
444 {
445     NSString *string = [[NSString alloc] initWithCharactersNoCopy:const_cast<unichar*>(characters) length:length freeWhenDone:NO];
446     NSCharacterSet *set = [[m_platformData.font() coveredCharacterSet] invertedSet];
447     bool result = set && [string rangeOfCharacterFromSet:set].location == NSNotFound;
448     [string release];
449     return result;
450 }
451
452 void SimpleFontData::determinePitch()
453 {
454     NSFont* f = m_platformData.font();
455     // Special case Osaka-Mono.
456     // According to <rdar://problem/3999467>, we should treat Osaka-Mono as fixed pitch.
457     // Note that the AppKit does not report Osaka-Mono as fixed pitch.
458
459     // Special case MS-PGothic.
460     // According to <rdar://problem/4032938>, we should not treat MS-PGothic as fixed pitch.
461     // Note that AppKit does report MS-PGothic as fixed pitch.
462
463     // Special case MonotypeCorsiva
464     // According to <rdar://problem/5454704>, we should not treat MonotypeCorsiva as fixed pitch.
465     // Note that AppKit does report MonotypeCorsiva as fixed pitch.
466
467     NSString *name = [f fontName];
468     m_treatAsFixedPitch = ([f isFixedPitch] || [f _isFakeFixedPitch] ||
469            [name caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame) &&
470            [name caseInsensitiveCompare:@"MS-PGothic"] != NSOrderedSame &&
471            [name caseInsensitiveCompare:@"MonotypeCorsiva"] != NSOrderedSame;
472 }
473
474 FloatRect SimpleFontData::platformBoundsForGlyph(Glyph glyph) const
475 {
476     FloatRect boundingBox;
477 #ifndef BUILDING_ON_TIGER
478     boundingBox = CTFontGetBoundingRectsForGlyphs(m_platformData.ctFont(),
479                     orientation() == Vertical ? kCTFontVerticalOrientation : kCTFontHorizontalOrientation, &glyph, 0, 1);
480     boundingBox.setY(-boundingBox.maxY());
481 #else
482     // FIXME: Custom fonts don't have NSFonts, so this function doesn't compute correct bounds for these on Tiger.
483     if (!m_platformData.font())
484         return boundingBox;
485     boundingBox = [m_platformData.font() boundingRectForGlyph:glyph];
486     boundingBox.setY(-boundingBox.maxY());
487 #endif
488     if (m_syntheticBoldOffset)
489         boundingBox.setWidth(boundingBox.width() + m_syntheticBoldOffset);
490
491     return boundingBox;
492 }
493
494 float SimpleFontData::platformWidthForGlyph(Glyph glyph) const
495 {
496     CGSize advance;
497     if (orientation() == Horizontal || m_isBrokenIdeographFont) {
498         NSFont* font = platformData().font();
499         float pointSize = platformData().m_size;
500         CGAffineTransform m = CGAffineTransformMakeScale(pointSize, pointSize);
501         if (!wkGetGlyphTransformedAdvances(platformData().cgFont(), font, &m, &glyph, &advance)) {
502             LOG_ERROR("Unable to cache glyph widths for %@ %f", [font displayName], pointSize);
503             advance.width = 0;
504         }
505     } else
506         CTFontGetAdvancesForGlyphs(m_platformData.ctFont(), kCTFontVerticalOrientation, &glyph, &advance, 1);
507
508     return advance.width + m_syntheticBoldOffset;
509 }
510
511 } // namespace WebCore