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 #if defined(BUILDING_ON_LEOPARD)
 245     else if ([familyName isEqualToString:@"Geeza Pro"]) {
 246         // Geeza Pro has glyphs that draw slightly above the ascent or far below the descent. Adjust
 247         // those vertical metrics to better match reality, so that diacritics at the bottom of one line
 248         // do not overlap diacritics at the top of the next line.
 249         ascent *= 1.08f;
 250         descent *= 2.f;
 251     }
 252 #endif
 253
 254     // Compute and store line spacing, before the line metrics hacks are applied.
 255     m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) + lroundf(lineGap));
 256
 257     // Hack Hiragino line metrics to allow room for marked text underlines.
 258     // <rdar://problem/5386183>
 259     if (descent < 3 && lineGap >= 3 && [familyName hasPrefix:@"Hiragino"]) {
 260         lineGap -= 3 - descent;
 261         descent = 3;
 262     }
 263
 264     if (platformData().orientation() == Vertical && !isTextOrientationFallback()) {
 265         // The check doesn't look neat but this is what AppKit does for vertical writing...
 266         RetainPtr<CFArrayRef> tableTags(AdoptCF, CTFontCopyAvailableTables(m_platformData.ctFont(), kCTFontTableOptionExcludeSynthetic));
 267         CFIndex numTables = CFArrayGetCount(tableTags.get());
 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                 m_hasVerticalGlyphs = true;
 272                 break;
 273             }
 274         }
 275     }
 276
 277     float xHeight;
 278
 279     if (platformData().orientation() == Horizontal) {
 280         // Measure the actual character "x", since it's possible for it to extend below the baseline, and we need the
 281         // reported x-height to only include the portion of the glyph that is above the baseline.
 282         GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
 283         NSGlyph xGlyph = glyphPageZero ? glyphPageZero->glyphDataForCharacter('x').glyph : 0;
 284         if (xGlyph)
 285             xHeight = -CGRectGetMinY(platformBoundsForGlyph(xGlyph));
 286         else
 287             xHeight = scaleEmToUnits(CGFontGetXHeight(m_platformData.cgFont()), unitsPerEm) * pointSize;
 288     } else
 289         xHeight = verticalRightOrientationFontData()->fontMetrics().xHeight();
 290
 291     m_fontMetrics.setUnitsPerEm(unitsPerEm);
 292     m_fontMetrics.setAscent(ascent);
 293     m_fontMetrics.setDescent(descent);
 294     m_fontMetrics.setLineGap(lineGap);
 295     m_fontMetrics.setXHeight(xHeight);
 296 }
 297
 298 static CFDataRef copyFontTableForTag(FontPlatformData& platformData, FourCharCode tableName)
 299 {
 300 #ifdef BUILDING_ON_TIGER
 301     ATSFontRef atsFont = FMGetATSFontRefFromFont(platformData.m_atsuFontID);
 302
 303     ByteCount tableSize;
 304     if (ATSFontGetTable(atsFont, tableName, 0, 0, NULL, &tableSize) != noErr)
 305         return 0;
 306
 307     CFMutableDataRef data = CFDataCreateMutable(kCFAllocatorDefault, tableSize);
 308     if (!data)
 309         return 0;
 310
 311     CFDataIncreaseLength(data, tableSize);
 312     if (ATSFontGetTable(atsFont, tableName, 0, tableSize, CFDataGetMutableBytePtr(data), &tableSize) != noErr) {
 313         CFRelease(data);
 314         return 0;
 315     }
 316
 317     return data;
 318 #else
 319     return CGFontCopyTableForTag(platformData.cgFont(), tableName);
 320 #endif
 321 }
 322
 323 void SimpleFontData::platformCharWidthInit()
 324 {
 325     m_avgCharWidth = 0;
 326     m_maxCharWidth = 0;
 327
 328     RetainPtr<CFDataRef> os2Table(AdoptCF, copyFontTableForTag(m_platformData, 'OS/2'));
 329     if (os2Table && CFDataGetLength(os2Table.get()) >= 4) {
 330         const UInt8* os2 = CFDataGetBytePtr(os2Table.get());
 331         SInt16 os2AvgCharWidth = os2[2] * 256 + os2[3];
 332         m_avgCharWidth = scaleEmToUnits(os2AvgCharWidth, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
 333     }
 334
 335     RetainPtr<CFDataRef> headTable(AdoptCF, copyFontTableForTag(m_platformData, 'head'));
 336     if (headTable && CFDataGetLength(headTable.get()) >= 42) {
 337         const UInt8* head = CFDataGetBytePtr(headTable.get());
 338         ushort uxMin = head[36] * 256 + head[37];
 339         ushort uxMax = head[40] * 256 + head[41];
 340         SInt16 xMin = static_cast<SInt16>(uxMin);
 341         SInt16 xMax = static_cast<SInt16>(uxMax);
 342         float diff = static_cast<float>(xMax - xMin);
 343         m_maxCharWidth = scaleEmToUnits(diff, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
 344     }
 345
 346     // Fallback to a cross-platform estimate, which will populate these values if they are non-positive.
 347     initCharWidths();
 348 }
 349
 350 void SimpleFontData::platformDestroy()
 351 {
 352     if (!isCustomFont() && m_derivedFontData) {
 353         // These come from the cache.
 354         if (m_derivedFontData->smallCaps)
 355             fontCache()->releaseFontData(m_derivedFontData->smallCaps.leakPtr());
 356
 357         if (m_derivedFontData->emphasisMark)
 358             fontCache()->releaseFontData(m_derivedFontData->emphasisMark.leakPtr());
 359     }
 360
 361 #ifdef BUILDING_ON_TIGER
 362     if (m_styleGroup)
 363         wkReleaseStyleGroup(m_styleGroup);
 364 #endif
 365 #if USE(ATSUI)
 366     HashMap<unsigned, ATSUStyle>::iterator end = m_ATSUStyleMap.end();
 367     for (HashMap<unsigned, ATSUStyle>::iterator it = m_ATSUStyleMap.begin(); it != end; ++it)
 368         ATSUDisposeStyle(it->second);
 369 #endif
 370 }
 371
 372 SimpleFontData* SimpleFontData::scaledFontData(const FontDescription& fontDescription, float scaleFactor) const
 373 {
 374     if (isCustomFont()) {
 375         FontPlatformData scaledFontData(m_platformData);
 376         scaledFontData.m_size = scaledFontData.m_size * scaleFactor;
 377         return new SimpleFontData(scaledFontData, true, false);
 378     }
 379
 380     BEGIN_BLOCK_OBJC_EXCEPTIONS;
 381     float size = m_platformData.size() * scaleFactor;
 382     FontPlatformData scaledFontData([[NSFontManager sharedFontManager] convertFont:m_platformData.font() toSize:size], size, false, false, m_platformData.orientation());
 383
 384     // AppKit resets the type information (screen/printer) when you convert a font to a different size.
 385     // We have to fix up the font that we're handed back.
 386     scaledFontData.setFont(fontDescription.usePrinterFont() ? [scaledFontData.font() printerFont] : [scaledFontData.font() screenFont]);
 387
 388     if (scaledFontData.font()) {
 389         NSFontManager *fontManager = [NSFontManager sharedFontManager];
 390         NSFontTraitMask fontTraits = [fontManager traitsOfFont:m_platformData.font()];
 391
 392         if (m_platformData.m_syntheticBold)
 393             fontTraits |= NSBoldFontMask;
 394         if (m_platformData.m_syntheticOblique)
 395             fontTraits |= NSItalicFontMask;
 396
 397         NSFontTraitMask scaledFontTraits = [fontManager traitsOfFont:scaledFontData.font()];
 398         scaledFontData.m_syntheticBold = (fontTraits & NSBoldFontMask) && !(scaledFontTraits & NSBoldFontMask);
 399         scaledFontData.m_syntheticOblique = (fontTraits & NSItalicFontMask) && !(scaledFontTraits & NSItalicFontMask);
 400
 401         return fontCache()->getCachedFontData(&scaledFontData);
 402     }
 403     END_BLOCK_OBJC_EXCEPTIONS;
 404
 405     return 0;
 406 }
 407
 408 SimpleFontData* SimpleFontData::smallCapsFontData(const FontDescription& fontDescription) const
 409 {
 410     if (!m_derivedFontData)
 411         m_derivedFontData = DerivedFontData::create(isCustomFont());
 412     if (!m_derivedFontData->smallCaps)
 413         m_derivedFontData->smallCaps = scaledFontData(fontDescription, smallCapsFontSizeMultiplier);
 414
 415     return m_derivedFontData->smallCaps.get();
 416 }
 417
 418 SimpleFontData* SimpleFontData::emphasisMarkFontData(const FontDescription& fontDescription) const
 419 {
 420     if (!m_derivedFontData)
 421         m_derivedFontData = DerivedFontData::create(isCustomFont());
 422     if (!m_derivedFontData->emphasisMark)
 423         m_derivedFontData->emphasisMark = scaledFontData(fontDescription, .5f);
 424
 425     return m_derivedFontData->emphasisMark.get();
 426 }
 427
 428 bool SimpleFontData::containsCharacters(const UChar* characters, int length) const
 429 {
 430     NSString *string = [[NSString alloc] initWithCharactersNoCopy:const_cast<unichar*>(characters) length:length freeWhenDone:NO];
 431     NSCharacterSet *set = [[m_platformData.font() coveredCharacterSet] invertedSet];
 432     bool result = set && [string rangeOfCharacterFromSet:set].location == NSNotFound;
 433     [string release];
 434     return result;
 435 }
 436
 437 void SimpleFontData::determinePitch()
 438 {
 439     NSFont* f = m_platformData.font();
 440     // Special case Osaka-Mono.
 441     // According to <rdar://problem/3999467>, we should treat Osaka-Mono as fixed pitch.
 442     // Note that the AppKit does not report Osaka-Mono as fixed pitch.
 443
 444     // Special case MS-PGothic.
 445     // According to <rdar://problem/4032938>, we should not treat MS-PGothic as fixed pitch.
 446     // Note that AppKit does report MS-PGothic as fixed pitch.
 447
 448     // Special case MonotypeCorsiva
 449     // According to <rdar://problem/5454704>, we should not treat MonotypeCorsiva as fixed pitch.
 450     // Note that AppKit does report MonotypeCorsiva as fixed pitch.
 451
 452     NSString *name = [f fontName];
 453     m_treatAsFixedPitch = ([f isFixedPitch] || [f _isFakeFixedPitch] ||
 454            [name caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame) &&
 455            [name caseInsensitiveCompare:@"MS-PGothic"] != NSOrderedSame &&
 456            [name caseInsensitiveCompare:@"MonotypeCorsiva"] != NSOrderedSame;
 457 }
 458
 459 FloatRect SimpleFontData::platformBoundsForGlyph(Glyph glyph) const
 460 {
 461     FloatRect boundingBox;
 462     boundingBox = CTFontGetBoundingRectsForGlyphs(m_platformData.ctFont(), platformData().orientation() == Vertical ? kCTFontVerticalOrientation : kCTFontHorizontalOrientation, &glyph, 0, 1);
 463     boundingBox.setY(-boundingBox.maxY());
 464     if (m_syntheticBoldOffset)
 465         boundingBox.setWidth(boundingBox.width() + m_syntheticBoldOffset);
 466
 467     return boundingBox;
 468 }
 469
 470 float SimpleFontData::platformWidthForGlyph(Glyph glyph) const
 471 {
 472     CGSize advance;
 473     if (platformData().orientation() == Horizontal || m_isBrokenIdeographFallback) {
 474         NSFont* font = platformData().font();
 475         float pointSize = platformData().m_size;
 476         CGAffineTransform m = CGAffineTransformMakeScale(pointSize, pointSize);
 477         if (!wkGetGlyphTransformedAdvances(platformData().cgFont(), font, &m, &glyph, &advance)) {
 478             LOG_ERROR("Unable to cache glyph widths for %@ %f", [font displayName], pointSize);
 479             advance.width = 0;
 480         }
 481     } else
 482         CTFontGetAdvancesForGlyphs(m_platformData.ctFont(), kCTFontVerticalOrientation, &glyph, &advance, 1);
 483
 484     return advance.width + m_syntheticBoldOffset;
 485 }
 486
 487 } // namespace WebCore