/third_party/WebKit/Source/platform/fonts/mac/FontFamilyMatcherMac.mm
Objective C++ | 293 lines | 192 code | 43 blank | 58 comment | 53 complexity | da5dc13e3a2f0dd86f087048c7c03263 MD5 | raw file
- /*
- * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
- * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
- * its contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
- #import "platform/fonts/mac/FontFamilyMatcherMac.h"
- #import <AppKit/AppKit.h>
- #import <Foundation/Foundation.h>
- #import <math.h>
- #include "platform/fonts/FontTraits.h"
- #include "platform/LayoutTestSupport.h"
- #include "platform/mac/VersionUtilMac.h"
- #import "wtf/HashSet.h"
- #import "wtf/text/AtomicStringHash.h"
- @interface NSFont (YosemiteAdditions)
- + (NSFont*)systemFontOfSize:(CGFloat)size weight:(CGFloat)weight;
- @end
- namespace {
- static CGFloat toYosemiteFontWeight(blink::FontWeight fontWeight)
- {
- static uint64_t nsFontWeights[] = {
- 0xbfe99999a0000000, // NSFontWeightUltraLight
- 0xbfe3333340000000, // NSFontWeightThin
- 0xbfd99999a0000000, // NSFontWeightLight
- 0x0000000000000000, // NSFontWeightRegular
- 0x3fcd70a3e0000000, // NSFontWeightMedium
- 0x3fd3333340000000, // NSFontWeightSemibold
- 0x3fd99999a0000000, // NSFontWeightBold
- 0x3fe1eb8520000000, // NSFontWeightHeavy
- 0x3fe3d70a40000000, // NSFontWeightBlack
- };
- ASSERT(fontWeight >= 0 && fontWeight <= 8);
- CGFloat* weight = reinterpret_cast<CGFloat*>(&nsFontWeights[fontWeight]);
- return *weight;
- }
- }
- namespace blink {
- const NSFontTraitMask SYNTHESIZED_FONT_TRAITS = (NSBoldFontMask | NSItalicFontMask);
- const NSFontTraitMask IMPORTANT_FONT_TRAITS = (NSCompressedFontMask
- | NSCondensedFontMask
- | NSExpandedFontMask
- | NSItalicFontMask
- | NSNarrowFontMask
- | NSPosterFontMask
- | NSSmallCapsFontMask );
- static BOOL acceptableChoice(NSFontTraitMask desiredTraits, NSFontTraitMask candidateTraits)
- {
- desiredTraits &= ~SYNTHESIZED_FONT_TRAITS;
- return (candidateTraits & desiredTraits) == desiredTraits;
- }
- static BOOL betterChoice(NSFontTraitMask desiredTraits, int desiredWeight,
- NSFontTraitMask chosenTraits, int chosenWeight,
- NSFontTraitMask candidateTraits, int candidateWeight)
- {
- if (!acceptableChoice(desiredTraits, candidateTraits))
- return NO;
- // A list of the traits we care about.
- // The top item in the list is the worst trait to mismatch; if a font has this
- // and we didn't ask for it, we'd prefer any other font in the family.
- const NSFontTraitMask masks[] = {
- NSPosterFontMask,
- NSSmallCapsFontMask,
- NSItalicFontMask,
- NSCompressedFontMask,
- NSCondensedFontMask,
- NSExpandedFontMask,
- NSNarrowFontMask,
- 0
- };
- int i = 0;
- NSFontTraitMask mask;
- while ((mask = masks[i++])) {
- BOOL desired = (desiredTraits & mask) != 0;
- BOOL chosenHasUnwantedTrait = desired != ((chosenTraits & mask) != 0);
- BOOL candidateHasUnwantedTrait = desired != ((candidateTraits & mask) != 0);
- if (!candidateHasUnwantedTrait && chosenHasUnwantedTrait)
- return YES;
- if (!chosenHasUnwantedTrait && candidateHasUnwantedTrait)
- return NO;
- }
- int chosenWeightDeltaMagnitude = abs(chosenWeight - desiredWeight);
- int candidateWeightDeltaMagnitude = abs(candidateWeight - desiredWeight);
- // If both are the same distance from the desired weight, prefer the candidate if it is further from medium.
- if (chosenWeightDeltaMagnitude == candidateWeightDeltaMagnitude)
- return abs(candidateWeight - 6) > abs(chosenWeight - 6);
- // Otherwise, prefer the one closer to the desired weight.
- return candidateWeightDeltaMagnitude < chosenWeightDeltaMagnitude;
- }
- // Family name is somewhat of a misnomer here. We first attempt to find an exact match
- // comparing the desiredFamily to the PostScript name of the installed fonts. If that fails
- // we then do a search based on the family names of the installed fonts.
- NSFont* MatchNSFontFamily(NSString* desiredFamily, NSFontTraitMask desiredTraits, FontWeight desiredWeight, float size)
- {
- if ([desiredFamily isEqualToString:@"BlinkMacSystemFont"]) {
- // On OSX 10.9, the default system font depends on the SDK version. When
- // compiled against the OSX 10.10 SDK, the font is .LucidaGrandeUI. When
- // compiled against the OSX 10.6 SDK, the font is Lucida Grande. Layout
- // tests don't support different expectations based on the SDK version,
- // so force layout tests to use "Lucida Grande". Once the 10.10 SDK
- // switch is made, this should be changed to return .LucidaGrandeUI and
- // the Layout Expectations should be updated. http://crbug.com/515836.
- if (LayoutTestSupport::isRunningLayoutTest() && IsOSMavericks()) {
- if (desiredWeight >= blink::FontWeightBold)
- return [NSFont fontWithName:@"Lucida Grande Bold" size:size];
- else
- return [NSFont fontWithName:@"Lucida Grande" size:size];
- }
- NSFont* font = nil;
- if (IsOSMavericksOrEarlier()) {
- // On older OSX versions, only bold and regular are available.
- if (desiredWeight >= blink::FontWeightBold)
- font = [NSFont boldSystemFontOfSize:size];
- else
- font = [NSFont systemFontOfSize:size];
- }
- else {
- // On OSX 10.10+, the default system font has more weights.
- font = [NSFont systemFontOfSize:size weight:toYosemiteFontWeight(desiredWeight)];
- }
- if (desiredTraits & IMPORTANT_FONT_TRAITS)
- font = [[NSFontManager sharedFontManager] convertFont:font toHaveTrait:desiredTraits];
- return font;
- }
- NSFontManager *fontManager = [NSFontManager sharedFontManager];
- // Do a simple case insensitive search for a matching font family.
- // NSFontManager requires exact name matches.
- // This addresses the problem of matching arial to Arial, etc., but perhaps not all the issues.
- NSEnumerator *e = [[fontManager availableFontFamilies] objectEnumerator];
- NSString *availableFamily;
- while ((availableFamily = [e nextObject])) {
- if ([desiredFamily caseInsensitiveCompare:availableFamily] == NSOrderedSame)
- break;
- }
- int appKitFontWeight = toAppKitFontWeight(desiredWeight);
- if (!availableFamily) {
- // Match by PostScript name.
- NSEnumerator *availableFonts = [[fontManager availableFonts] objectEnumerator];
- NSString *availableFont;
- NSFont *nameMatchedFont = nil;
- NSFontTraitMask desiredTraitsForNameMatch = desiredTraits | (appKitFontWeight >= 7 ? NSBoldFontMask : 0);
- while ((availableFont = [availableFonts nextObject])) {
- if ([desiredFamily caseInsensitiveCompare:availableFont] == NSOrderedSame) {
- nameMatchedFont = [NSFont fontWithName:availableFont size:size];
- // Special case Osaka-Mono. According to <rdar://problem/3999467>, we need to
- // treat Osaka-Mono as fixed pitch.
- if ([desiredFamily caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame && desiredTraitsForNameMatch == 0)
- return nameMatchedFont;
- NSFontTraitMask traits = [fontManager traitsOfFont:nameMatchedFont];
- if ((traits & desiredTraitsForNameMatch) == desiredTraitsForNameMatch)
- return [fontManager convertFont:nameMatchedFont toHaveTrait:desiredTraitsForNameMatch];
- availableFamily = [nameMatchedFont familyName];
- break;
- }
- }
- }
- // Found a family, now figure out what weight and traits to use.
- BOOL choseFont = false;
- int chosenWeight = 0;
- NSFontTraitMask chosenTraits = 0;
- NSString *chosenFullName = 0;
- NSArray *fonts = [fontManager availableMembersOfFontFamily:availableFamily];
- unsigned n = [fonts count];
- unsigned i;
- for (i = 0; i < n; i++) {
- NSArray *fontInfo = [fonts objectAtIndex:i];
- // Array indices must be hard coded because of lame AppKit API.
- NSString *fontFullName = [fontInfo objectAtIndex:0];
- NSInteger fontWeight = [[fontInfo objectAtIndex:2] intValue];
- NSFontTraitMask fontTraits = [[fontInfo objectAtIndex:3] unsignedIntValue];
- BOOL newWinner;
- if (!choseFont)
- newWinner = acceptableChoice(desiredTraits, fontTraits);
- else
- newWinner = betterChoice(desiredTraits, appKitFontWeight, chosenTraits, chosenWeight, fontTraits, fontWeight);
- if (newWinner) {
- choseFont = YES;
- chosenWeight = fontWeight;
- chosenTraits = fontTraits;
- chosenFullName = fontFullName;
- if (chosenWeight == appKitFontWeight && (chosenTraits & IMPORTANT_FONT_TRAITS) == (desiredTraits & IMPORTANT_FONT_TRAITS))
- break;
- }
- }
- if (!choseFont)
- return nil;
- NSFont *font = [NSFont fontWithName:chosenFullName size:size];
- if (!font)
- return nil;
- NSFontTraitMask actualTraits = 0;
- if (desiredTraits & NSFontItalicTrait)
- actualTraits = [fontManager traitsOfFont:font];
- int actualWeight = [fontManager weightOfFont:font];
- bool syntheticBold = appKitFontWeight >= 7 && actualWeight < 7;
- bool syntheticItalic = (desiredTraits & NSFontItalicTrait) && !(actualTraits & NSFontItalicTrait);
- // There are some malformed fonts that will be correctly returned by -fontWithFamily:traits:weight:size: as a match for a particular trait,
- // though -[NSFontManager traitsOfFont:] incorrectly claims the font does not have the specified trait. This could result in applying
- // synthetic bold on top of an already-bold font, as reported in <http://bugs.webkit.org/show_bug.cgi?id=6146>. To work around this
- // problem, if we got an apparent exact match, but the requested traits aren't present in the matched font, we'll try to get a font from
- // the same family without those traits (to apply the synthetic traits to later).
- NSFontTraitMask nonSyntheticTraits = desiredTraits;
- if (syntheticBold)
- nonSyntheticTraits &= ~NSBoldFontMask;
- if (syntheticItalic)
- nonSyntheticTraits &= ~NSItalicFontMask;
- if (nonSyntheticTraits != desiredTraits) {
- NSFont *fontWithoutSyntheticTraits = [fontManager fontWithFamily:availableFamily traits:nonSyntheticTraits weight:chosenWeight size:size];
- if (fontWithoutSyntheticTraits)
- font = fontWithoutSyntheticTraits;
- }
- return font;
- }
- int toAppKitFontWeight(FontWeight fontWeight)
- {
- static int appKitFontWeights[] = {
- 2, // FontWeight100
- 3, // FontWeight200
- 4, // FontWeight300
- 5, // FontWeight400
- 6, // FontWeight500
- 8, // FontWeight600
- 9, // FontWeight700
- 10, // FontWeight800
- 12, // FontWeight900
- };
- return appKitFontWeights[fontWeight];
- }
- } // namespace blink