[Mac] Use Fast enumeration consistently in WebFontCache.mm
[WebKit-https.git] / Source / WebCore / platform / mac / WebFontCache.mm
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
3  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
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 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 "WebFontCache.h"
32
33 #import "FontTraitsMask.h"
34 #import "WebCoreNSStringExtras.h"
35 #import <AppKit/AppKit.h>
36 #import <Foundation/Foundation.h>
37 #import <math.h>
38 #import <wtf/MainThread.h>
39
40 using namespace WebCore;
41
42 #define SYNTHESIZED_FONT_TRAITS (NSBoldFontMask | NSItalicFontMask)
43
44 #define IMPORTANT_FONT_TRAITS (0 \
45     | NSCompressedFontMask \
46     | NSCondensedFontMask \
47     | NSExpandedFontMask \
48     | NSItalicFontMask \
49     | NSNarrowFontMask \
50     | NSPosterFontMask \
51     | NSSmallCapsFontMask \
52 )
53
54 static BOOL acceptableChoice(NSFontTraitMask desiredTraits, NSFontTraitMask candidateTraits)
55 {
56     desiredTraits &= ~SYNTHESIZED_FONT_TRAITS;
57     return (candidateTraits & desiredTraits) == desiredTraits;
58 }
59
60 static BOOL betterChoice(NSFontTraitMask desiredTraits, int desiredWeight,
61     NSFontTraitMask chosenTraits, int chosenWeight,
62     NSFontTraitMask candidateTraits, int candidateWeight)
63 {
64     if (!acceptableChoice(desiredTraits, candidateTraits))
65         return NO;
66
67     // A list of the traits we care about.
68     // The top item in the list is the worst trait to mismatch; if a font has this
69     // and we didn't ask for it, we'd prefer any other font in the family.
70     const NSFontTraitMask masks[] = {
71         NSPosterFontMask,
72         NSSmallCapsFontMask,
73         NSItalicFontMask,
74         NSCompressedFontMask,
75         NSCondensedFontMask,
76         NSExpandedFontMask,
77         NSNarrowFontMask,
78         0
79     };
80
81     int i = 0;
82     NSFontTraitMask mask;
83     while ((mask = masks[i++])) {
84         BOOL desired = (desiredTraits & mask) != 0;
85         BOOL chosenHasUnwantedTrait = desired != ((chosenTraits & mask) != 0);
86         BOOL candidateHasUnwantedTrait = desired != ((candidateTraits & mask) != 0);
87         if (!candidateHasUnwantedTrait && chosenHasUnwantedTrait)
88             return YES;
89         if (!chosenHasUnwantedTrait && candidateHasUnwantedTrait)
90             return NO;
91     }
92
93     int chosenWeightDeltaMagnitude = abs(chosenWeight - desiredWeight);
94     int candidateWeightDeltaMagnitude = abs(candidateWeight - desiredWeight);
95
96     // If both are the same distance from the desired weight, prefer the candidate if it is further from medium.
97     if (chosenWeightDeltaMagnitude == candidateWeightDeltaMagnitude)
98         return abs(candidateWeight - 6) > abs(chosenWeight - 6);
99
100     // Otherwise, prefer the one closer to the desired weight.
101     return candidateWeightDeltaMagnitude < chosenWeightDeltaMagnitude;
102 }
103
104 static inline FontTraitsMask toTraitsMask(NSFontTraitMask appKitTraits, NSInteger appKitWeight)
105 {
106     return static_cast<FontTraitsMask>(((appKitTraits & NSFontItalicTrait) ? FontStyleItalicMask : FontStyleNormalMask)
107         | FontVariantNormalMask
108         | (appKitWeight == 1 ? FontWeight100Mask :
109               appKitWeight == 2 ? FontWeight200Mask :
110               appKitWeight <= 4 ? FontWeight300Mask :
111               appKitWeight == 5 ? FontWeight400Mask :
112               appKitWeight == 6 ? FontWeight500Mask :
113               appKitWeight <= 8 ? FontWeight600Mask :
114               appKitWeight == 9 ? FontWeight700Mask :
115               appKitWeight <= 11 ? FontWeight800Mask :
116                                    FontWeight900Mask));
117 }
118
119 // Keep a cache for mapping desired font families to font families actually
120 // available on the system for performance.
121 static NSMutableDictionary* desiredFamilyToAvailableFamilyDictionary()
122 {
123     ASSERT(isMainThread());
124     static NSMutableDictionary *dictionary = [[NSMutableDictionary alloc] init];
125     return dictionary;
126 }
127
128 static inline void rememberDesiredFamilyToAvailableFamilyMapping(NSString* desiredFamily, NSString* availableFamily)
129 {
130     static const NSUInteger maxCacheSize = 128;
131     NSMutableDictionary *familyMapping = desiredFamilyToAvailableFamilyDictionary();
132     ASSERT([familyMapping count] <= maxCacheSize);
133     if ([familyMapping count] == maxCacheSize) {
134         for (NSString *key in familyMapping) {
135             [familyMapping removeObjectForKey:key];
136             break;
137         }
138     }
139     id value = availableFamily ? availableFamily : [NSNull null];
140     [familyMapping setObject:value forKey:desiredFamily];
141 }
142
143 @implementation WebFontCache
144
145 + (void)getTraits:(Vector<unsigned>&)traitsMasks inFamily:(NSString *)desiredFamily
146 {
147     NSFontManager *fontManager = [NSFontManager sharedFontManager];
148
149     NSString *availableFamily;
150     for (availableFamily in [fontManager availableFontFamilies]) {
151         if ([desiredFamily caseInsensitiveCompare:availableFamily] == NSOrderedSame)
152             break;
153     }
154
155     if (!availableFamily) {
156         // Match by PostScript name.
157         for (NSString *availableFont in [fontManager availableFonts]) {
158             if ([desiredFamily caseInsensitiveCompare:availableFont] == NSOrderedSame) {
159                 NSFont *font = [NSFont fontWithName:availableFont size:10];
160                 NSInteger weight = [fontManager weightOfFont:font];
161                 traitsMasks.append(toTraitsMask([fontManager traitsOfFont:font], weight));
162                 break;
163             }
164         }
165         return;
166     }
167
168     NSArray *fonts = [fontManager availableMembersOfFontFamily:availableFamily];
169     traitsMasks.reserveCapacity([fonts count]);
170     for (NSArray *fontInfo in fonts) {
171         // Array indices must be hard coded because of lame AppKit API.
172         NSInteger fontWeight = [[fontInfo objectAtIndex:2] intValue];
173         NSFontTraitMask fontTraits = [[fontInfo objectAtIndex:3] unsignedIntValue];
174         traitsMasks.uncheckedAppend(toTraitsMask(fontTraits, fontWeight));
175     }
176 }
177
178 // Family name is somewhat of a misnomer here.  We first attempt to find an exact match
179 // comparing the desiredFamily to the PostScript name of the installed fonts.  If that fails
180 // we then do a search based on the family names of the installed fonts.
181 + (NSFont *)internalFontWithFamily:(NSString *)desiredFamily traits:(NSFontTraitMask)desiredTraits weight:(int)desiredWeight size:(float)size
182 {
183     if (stringIsCaseInsensitiveEqualToString(desiredFamily, @"-webkit-system-font")
184         || stringIsCaseInsensitiveEqualToString(desiredFamily, @"-apple-system-font")) {
185         // We ignore italic for system font.
186         return (desiredWeight >= 7) ? [NSFont boldSystemFontOfSize:size] : [NSFont systemFontOfSize:size];
187     }
188
189     id cachedAvailableFamily = [desiredFamilyToAvailableFamilyDictionary() objectForKey:desiredFamily];
190     if (cachedAvailableFamily == [NSNull null]) {
191         // We already know this font is not available.
192         return nil;
193     }
194
195     NSFontManager *fontManager = [NSFontManager sharedFontManager];
196     NSString *availableFamily = cachedAvailableFamily;
197     if (!availableFamily) {
198         // Do a simple case insensitive search for a matching font family.
199         // NSFontManager requires exact name matches.
200         // This addresses the problem of matching arial to Arial, etc., but perhaps not all the issues.
201         for (availableFamily in [fontManager availableFontFamilies]) {
202             if ([desiredFamily caseInsensitiveCompare:availableFamily] == NSOrderedSame)
203                 break;
204         }
205
206         if (!availableFamily) {
207             // Match by PostScript name.
208             NSFont *nameMatchedFont = nil;
209             NSFontTraitMask desiredTraitsForNameMatch = desiredTraits | (desiredWeight >= 7 ? NSBoldFontMask : 0);
210             for (NSString *availableFont in [fontManager availableFonts]) {
211                 if ([desiredFamily caseInsensitiveCompare:availableFont] == NSOrderedSame) {
212                     nameMatchedFont = [NSFont fontWithName:availableFont size:size];
213
214                     // Special case Osaka-Mono. According to <rdar://problem/3999467>, we need to
215                     // treat Osaka-Mono as fixed pitch.
216                     if ([desiredFamily caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame && !desiredTraitsForNameMatch)
217                         return nameMatchedFont;
218
219                     NSFontTraitMask traits = [fontManager traitsOfFont:nameMatchedFont];
220                     if ((traits & desiredTraitsForNameMatch) == desiredTraitsForNameMatch)
221                         return [fontManager convertFont:nameMatchedFont toHaveTrait:desiredTraitsForNameMatch];
222
223                     availableFamily = [nameMatchedFont familyName];
224                     break;
225                 }
226             }
227         }
228
229         rememberDesiredFamilyToAvailableFamilyMapping(desiredFamily, availableFamily);
230         if (!availableFamily)
231             return nil;
232     }
233
234     // Found a family, now figure out what weight and traits to use.
235     BOOL choseFont = false;
236     int chosenWeight = 0;
237     NSFontTraitMask chosenTraits = 0;
238     NSString *chosenFullName = 0;
239
240     NSArray *fonts = [fontManager availableMembersOfFontFamily:availableFamily];
241     for (NSArray *fontInfo in fonts) {
242         // Array indices must be hard coded because of lame AppKit API.
243         NSString *fontFullName = [fontInfo objectAtIndex:0];
244         NSInteger fontWeight = [[fontInfo objectAtIndex:2] intValue];
245         NSFontTraitMask fontTraits = [[fontInfo objectAtIndex:3] unsignedIntValue];
246
247         BOOL newWinner;
248         if (!choseFont)
249             newWinner = acceptableChoice(desiredTraits, fontTraits);
250         else
251             newWinner = betterChoice(desiredTraits, desiredWeight, chosenTraits, chosenWeight, fontTraits, fontWeight);
252
253         if (newWinner) {
254             choseFont = YES;
255             chosenWeight = fontWeight;
256             chosenTraits = fontTraits;
257             chosenFullName = fontFullName;
258
259             if (chosenWeight == desiredWeight && (chosenTraits & IMPORTANT_FONT_TRAITS) == (desiredTraits & IMPORTANT_FONT_TRAITS))
260                 break;
261         }
262     }
263
264     if (!choseFont)
265         return nil;
266
267     NSFont *font = [NSFont fontWithName:chosenFullName size:size];
268
269     if (!font)
270         return nil;
271
272     NSFontTraitMask actualTraits = 0;
273     if (desiredTraits & NSFontItalicTrait)
274         actualTraits = [fontManager traitsOfFont:font];
275     int actualWeight = [fontManager weightOfFont:font];
276
277     bool syntheticBold = desiredWeight >= 7 && actualWeight < 7;
278     bool syntheticOblique = (desiredTraits & NSFontItalicTrait) && !(actualTraits & NSFontItalicTrait);
279
280     // There are some malformed fonts that will be correctly returned by -fontWithFamily:traits:weight:size: as a match for a particular trait,
281     // though -[NSFontManager traitsOfFont:] incorrectly claims the font does not have the specified trait. This could result in applying 
282     // 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
283     // 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 
284     // the same family without those traits (to apply the synthetic traits to later).
285     NSFontTraitMask nonSyntheticTraits = desiredTraits;
286
287     if (syntheticBold)
288         nonSyntheticTraits &= ~NSBoldFontMask;
289
290     if (syntheticOblique)
291         nonSyntheticTraits &= ~NSItalicFontMask;
292
293     if (nonSyntheticTraits != desiredTraits) {
294         NSFont *fontWithoutSyntheticTraits = [fontManager fontWithFamily:availableFamily traits:nonSyntheticTraits weight:chosenWeight size:size];
295         if (fontWithoutSyntheticTraits)
296             font = fontWithoutSyntheticTraits;
297     }
298
299     return font;
300 }
301
302 + (NSFont *)fontWithFamily:(NSString *)desiredFamily traits:(NSFontTraitMask)desiredTraits weight:(int)desiredWeight size:(float)size shouldAutoActivateIfNeeded:(BOOL)shouldAutoActivateIfNeeded
303 {
304     NSFont *font = [self internalFontWithFamily:desiredFamily traits:desiredTraits weight:desiredWeight size:size];
305     if (font || !shouldAutoActivateIfNeeded)
306         return font;
307
308     // Auto activate the font before looking for it a second time.
309     // Ignore the result because we want to use our own algorithm to actually find the font.
310     [NSFont fontWithName:desiredFamily size:size];
311
312     return [self internalFontWithFamily:desiredFamily traits:desiredTraits weight:desiredWeight size:size];
313 }
314
315 + (NSFont *)fontWithFamily:(NSString *)desiredFamily traits:(NSFontTraitMask)desiredTraits weight:(int)desiredWeight size:(float)size
316 {
317     return [self fontWithFamily:desiredFamily traits:desiredTraits weight:desiredWeight size:size shouldAutoActivateIfNeeded:YES];
318 }
319
320 + (NSFont *)fontWithFamily:(NSString *)desiredFamily traits:(NSFontTraitMask)desiredTraits size:(float)size
321 {
322     int desiredWeight = (desiredTraits & NSBoldFontMask) ? 9 : 5;
323     return [self fontWithFamily:desiredFamily traits:desiredTraits weight:desiredWeight size:size shouldAutoActivateIfNeeded:YES];
324 }
325
326 + (void)invalidate
327 {
328     [desiredFamilyToAvailableFamilyDictionary() removeAllObjects];
329 }
330 @end