/third_party/WebKit/Source/platform/fonts/mac/FontFamilyMatcherMac.mm

 /*
 * 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