WebKit/WebCoreSupport.subproj/WebTextRendererFactory.m

   1 /*
   2  * Copyright (C) 2005 Apple Computer, Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #import <WebKit/WebAssertions.h>
  30 #import <WebKit/WebBridge.h>
  31 #import <WebKit/WebKitLogging.h>
  32 #import <WebKit/WebKitSystemBits.h>
  33 #import <WebKit/WebPreferences.h>
  34 #import <WebKit/WebTextRendererFactory.h>
  35 #import <WebKit/WebTextRenderer.h>
  36 #import <WebKitSystemInterface.h>
  37
  38 #import <mach-o/dyld.h>
  39
  40 #define IMPORTANT_FONT_TRAITS (0 \
  41     | NSBoldFontMask \
  42     | NSCompressedFontMask \
  43     | NSCondensedFontMask \
  44     | NSExpandedFontMask \
  45     | NSItalicFontMask \
  46     | NSNarrowFontMask \
  47     | NSPosterFontMask \
  48     | NSSmallCapsFontMask \
  49 )
  50
  51 #define DESIRED_WEIGHT 5
  52
  53 @interface NSFont (WebPrivate)
  54 - (ATSUFontID)_atsFontID;
  55 @end
  56
  57 @interface NSFont (WebAppKitSecretAPI)
  58 - (BOOL)_isFakeFixedPitch;
  59 @end
  60
  61 @implementation WebTextRendererFactory
  62
  63 - (BOOL)coalesceTextDrawing
  64 {
  65     return [viewStack objectAtIndex: [viewStack count]-1] == [NSView focusView] ? YES : NO;
  66 }
  67
  68 - (void)startCoalesceTextDrawing
  69 {
  70     if (!viewStack)
  71         viewStack = [[NSMutableArray alloc] init];
  72     if (!viewBuffers)
  73         viewBuffers = [[NSMutableDictionary alloc] init];
  74     [viewStack addObject: [NSView focusView]];
  75 }
  76
  77 - (void)endCoalesceTextDrawing
  78 {
  79     ASSERT([self coalesceTextDrawing]);
  80
  81     NSView *targetView = [viewStack objectAtIndex: [viewStack count]-1];
  82     [viewStack removeLastObject];
  83     NSValue *viewKey = [NSValue valueWithNonretainedObject: targetView];
  84     NSMutableSet *glyphBuffers = [viewBuffers objectForKey:viewKey];
  85
  86     [glyphBuffers makeObjectsPerformSelector: @selector(drawInView:) withObject: targetView];
  87     [glyphBuffers makeObjectsPerformSelector: @selector(reset)];
  88     [viewBuffers removeObjectForKey: viewKey];
  89 }
  90
  91 - (WebGlyphBuffer *)glyphBufferForFont: (NSFont *)font andColor: (NSColor *)color
  92 {
  93     ASSERT([self coalesceTextDrawing]);
  94
  95     NSMutableSet *glyphBuffers;
  96     WebGlyphBuffer *glyphBuffer = nil;
  97     NSValue *viewKey = [NSValue valueWithNonretainedObject: [NSView focusView]];
  98
  99     glyphBuffers = [viewBuffers objectForKey:viewKey];
 100     if (glyphBuffers == nil){
 101         glyphBuffers = [[NSMutableSet alloc] init];
 102         [viewBuffers setObject: glyphBuffers forKey: viewKey];
 103         [glyphBuffers release];
 104     }
 105
 106     NSEnumerator *enumerator = [glyphBuffers objectEnumerator];
 107     id value;
 108
 109     // Could use a dictionary w/ font/color key for faster lookup.
 110     while ((value = [enumerator nextObject])) {
 111         if ([value font] == font && [[value color] isEqual: color])
 112             glyphBuffer = value;
 113     }
 114     if (glyphBuffer == nil){
 115         glyphBuffer = [[WebGlyphBuffer alloc] initWithFont: font color: color];
 116         [glyphBuffers addObject: glyphBuffer];
 117         [glyphBuffer release];
 118     }
 119
 120     return glyphBuffer;
 121 }
 122
 123 static bool
 124 getAppDefaultValue(CFStringRef key, int *v)
 125 {
 126     CFPropertyListRef value;
 127
 128     value = CFPreferencesCopyValue(key, kCFPreferencesCurrentApplication,
 129                                    kCFPreferencesAnyUser,
 130                                    kCFPreferencesAnyHost);
 131     if (value == NULL) {
 132         value = CFPreferencesCopyValue(key, kCFPreferencesCurrentApplication,
 133                                        kCFPreferencesCurrentUser,
 134                                        kCFPreferencesAnyHost);
 135         if (value == NULL)
 136             return false;
 137     }
 138
 139     if (CFGetTypeID(value) == CFNumberGetTypeID()) {
 140         if (v != NULL)
 141             CFNumberGetValue(value, kCFNumberIntType, v);
 142     } else if (CFGetTypeID(value) == CFStringGetTypeID()) {
 143         if (v != NULL)
 144             *v = CFStringGetIntValue(value);
 145     } else {
 146         CFRelease(value);
 147         return false;
 148     }
 149
 150     CFRelease(value);
 151     return true;
 152 }
 153
 154 static bool
 155 getUserDefaultValue(CFStringRef key, int *v)
 156 {
 157     CFPropertyListRef value;
 158
 159     value = CFPreferencesCopyValue(key, kCFPreferencesAnyApplication,
 160                                    kCFPreferencesCurrentUser,
 161                                    kCFPreferencesCurrentHost);
 162     if (value == NULL)
 163         return false;
 164
 165     if (CFGetTypeID(value) == CFNumberGetTypeID()) {
 166         if (v != NULL)
 167             CFNumberGetValue(value, kCFNumberIntType, v);
 168     } else if (CFGetTypeID(value) == CFStringGetTypeID()) {
 169         if (v != NULL)
 170             *v = CFStringGetIntValue(value);
 171     } else {
 172         CFRelease(value);
 173         return false;
 174     }
 175
 176     CFRelease(value);
 177     return true;
 178 }
 179
 180 static int getLCDScaleParameters(void)
 181 {
 182     int mode;
 183     CFStringRef key;
 184
 185     key = CFSTR("AppleFontSmoothing");
 186     if (!getAppDefaultValue(key, &mode)) {
 187         if (!getUserDefaultValue(key, &mode))
 188             return 1;
 189     }
 190
 191         if (WKFontSmoothingModeIsLCD(mode))
 192                 return 4;
 193         else
 194                 return 1;
 195 }
 196
 197 static CFMutableDictionaryRef fontCache;
 198 static CFMutableDictionaryRef fixedPitchFonts;
 199
 200 - (void)clearCaches
 201 {
 202     [cacheForScreen release];
 203     [cacheForPrinter release];
 204
 205     cacheForScreen = [[NSMutableDictionary alloc] init];
 206     cacheForPrinter = [[NSMutableDictionary alloc] init];
 207
 208     if (fontCache)
 209         CFRelease(fontCache);
 210     fontCache = NULL;
 211
 212     if (fixedPitchFonts) {
 213         CFRelease (fixedPitchFonts);
 214         fixedPitchFonts = 0;
 215     }
 216
 217     [super clearCaches];
 218 }
 219
 220 static void
 221 fontsChanged( ATSFontNotificationInfoRef info, void *_factory)
 222 {
 223     WebTextRendererFactory *factory = (WebTextRendererFactory *)_factory;
 224
 225     LOG (FontCache, "clearing font caches");
 226
 227     ASSERT (factory);
 228
 229     [factory clearCaches];
 230 }
 231
 232 #define MINIMUM_GLYPH_CACHE_SIZE 1536 * 1024
 233
 234 + (void)createSharedFactory
 235 {
 236     if (![self sharedFactory]) {
 237         [[[self alloc] init] release];
 238
 239         size_t s;
 240         if (WebSystemMainMemory() > 128 * 1024 * 1024)
 241                 s = MINIMUM_GLYPH_CACHE_SIZE*getLCDScaleParameters();
 242         else
 243                 s = MINIMUM_GLYPH_CACHE_SIZE;
 244 #ifndef NDEBUG
 245         LOG (CacheSizes, "Glyph cache size set to %d bytes.", s);
 246 #endif
 247         WKSetUpFontCache(s);
 248
 249         // Ignore errors returned from ATSFontNotificationSubscribe.  If we can't subscribe then we
 250         // won't be told about changes to fonts.
 251         ATSFontNotificationSubscribe( fontsChanged, kATSFontNotifyOptionDefault, (void *)[super sharedFactory], nil );
 252     }
 253     ASSERT([[self sharedFactory] isKindOfClass:self]);
 254 }
 255
 256 + (WebTextRendererFactory *)sharedFactory;
 257 {
 258     return (WebTextRendererFactory *)[super sharedFactory];
 259 }
 260
 261 - (BOOL)isFontFixedPitch: (NSFont *)font
 262 {
 263     BOOL ret = NO;
 264
 265     if (!fixedPitchFonts) {
 266         fixedPitchFonts = CFDictionaryCreateMutable (0, 0, &kCFTypeDictionaryKeyCallBacks, 0);
 267     }
 268
 269     CFBooleanRef val = CFDictionaryGetValue (fixedPitchFonts, font);
 270     if (val) {
 271         ret = (val == kCFBooleanTrue);
 272     }
 273     else {
 274         // Special case Osaka-Mono.  According to <rdar://problem/3999467>, we should treat Osaka-Mono
 275         // as fixed pitch. Note that the AppKit does not report MS-PGothic as fixed pitch.
 276
 277         // Special case MS PGothic.  According to <rdar://problem/4032938, we should not treat MS-PGothic
 278         // as fixed pitch.  Note that AppKit does report MS-PGothic as fixed pitch.
 279         if (([font isFixedPitch] || [font _isFakeFixedPitch] || [[font fontName] caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame) &&
 280                 ![[font fontName] caseInsensitiveCompare:@"MS-PGothic"] == NSOrderedSame) {
 281             CFDictionarySetValue (fixedPitchFonts, font, kCFBooleanTrue);
 282             ret = YES;
 283         }
 284         else {
 285             CFDictionarySetValue (fixedPitchFonts, font, kCFBooleanFalse);
 286             ret = NO;
 287         }
 288     }
 289     return ret;
 290 }
 291
 292 - init
 293 {
 294     [super init];
 295
 296     cacheForScreen = [[NSMutableDictionary alloc] init];
 297     cacheForPrinter = [[NSMutableDictionary alloc] init];
 298
 299     return self;
 300 }
 301
 302 - (void)dealloc
 303 {
 304     [cacheForScreen release];
 305     [cacheForPrinter release];
 306     [viewBuffers release];
 307     [viewStack release];
 308
 309     [super dealloc];
 310 }
 311
 312 - (WebTextRenderer *)rendererWithFont:(NSFont *)font usingPrinterFont:(BOOL)usingPrinterFont
 313 {
 314     NSMutableDictionary *cache = usingPrinterFont ? cacheForPrinter : cacheForScreen;
 315     WebTextRenderer *renderer = [cache objectForKey:font];
 316     if (renderer == nil) {
 317         renderer = [[WebTextRenderer alloc] initWithFont:font usingPrinterFont:usingPrinterFont];
 318         [cache setObject:renderer forKey:font];
 319         [renderer release];
 320     }
 321     return renderer;
 322 }
 323
 324 - (NSFont *)fallbackFontWithTraits:(NSFontTraitMask)traits size:(float)size
 325 {
 326     NSFont *font = [self cachedFontFromFamily:@"Helvetica" traits:traits size:size];
 327     if (font == nil) {
 328         // The Helvetica fallback will almost always work, since that's a basic
 329         // font that we ship with all systems. But in the highly unusual case where
 330         // the user removed Helvetica, we fall back on Lucida Grande because that's
 331         // guaranteed to be there, according to Nathan Taylor. This is good enough
 332         // to avoid a crash, at least. To reduce the possibility of failure even further,
 333         // we don't even bother with traits.
 334         font = [self cachedFontFromFamily:@"Lucida Grande" traits:0 size:size];
 335     }
 336     return font;
 337 }
 338
 339
 340
 341 - (NSFont *)fontWithFamilies:(NSString **)families traits:(NSFontTraitMask)traits size:(float)size
 342 {
 343     NSFont *font = nil;
 344     NSString *family;
 345     int i = 0;
 346
 347     while (families && families[i] != 0 && font == nil){
 348         family = families[i++];
 349         if ([family length] != 0)
 350             font = [self cachedFontFromFamily: family traits:traits size:size];
 351     }
 352     if (font == nil) {
 353         // We didn't find a font.  Use a fallback font.
 354         static int matchCount = 3;
 355         static NSString *matchWords[] = { @"Arabic", @"Pashto", @"Urdu" };
 356         static NSString *matchFamilies[] = { @"Geeza Pro", @"Geeza Pro", @"Geeza Pro" };
 357
 358         // First we'll attempt to find an appropriate font using a match based on
 359         // the presence of keywords in the the requested names.  For example, we'll
 360         // match any name that contains "Arabic" to Geeza Pro.
 361         int j;
 362         i = 0;
 363         while (families && families[i] != 0 && font == nil) {
 364             family = families[i++];
 365             if ([family length] != 0) {
 366                 j = 0;
 367                 while (j < matchCount && font == nil) {
 368                     if ([family rangeOfString:matchWords[j] options:NSCaseInsensitiveSearch].location != NSNotFound) {
 369                         font = [self cachedFontFromFamily:matchFamilies[j] traits:traits size:size];
 370                     }
 371                     j++;
 372                 }
 373             }
 374         }
 375
 376         // Still nothing found, use the final fallback.
 377         if (font == nil) {
 378             font = [self fallbackFontWithTraits:traits size:size];
 379         }
 380     }
 381
 382     return font;
 383 }
 384
 385 static BOOL acceptableChoice(NSFontTraitMask desiredTraits, int desiredWeight,
 386     NSFontTraitMask candidateTraits, int candidateWeight)
 387 {
 388     return (candidateTraits & desiredTraits) == desiredTraits;
 389 }
 390
 391 static BOOL betterChoice(NSFontTraitMask desiredTraits, int desiredWeight,
 392     NSFontTraitMask chosenTraits, int chosenWeight,
 393     NSFontTraitMask candidateTraits, int candidateWeight)
 394 {
 395     if (!acceptableChoice(desiredTraits, desiredWeight, candidateTraits, candidateWeight)) {
 396         return NO;
 397     }
 398
 399     // A list of the traits we care about.
 400     // The top item in the list is the worst trait to mismatch; if a font has this
 401     // and we didn't ask for it, we'd prefer any other font in the family.
 402     const NSFontTraitMask masks[] = {
 403         NSPosterFontMask,
 404         NSSmallCapsFontMask,
 405         NSItalicFontMask,
 406         NSCompressedFontMask,
 407         NSCondensedFontMask,
 408         NSExpandedFontMask,
 409         NSNarrowFontMask,
 410         NSBoldFontMask,
 411         0 };
 412     int i = 0;
 413     NSFontTraitMask mask;
 414     while ((mask = masks[i++])) {
 415         if ((desiredTraits & mask) != 0) {
 416             ASSERT((chosenTraits & mask) != 0);
 417             ASSERT((candidateTraits & mask) != 0);
 418             continue;
 419         }
 420         BOOL chosenHasUnwantedTrait = (chosenTraits & mask) != 0;
 421         BOOL candidateHasUnwantedTrait = (candidateTraits & mask) != 0;
 422         if (!candidateHasUnwantedTrait && chosenHasUnwantedTrait) {
 423             return YES;
 424         }
 425         if (!chosenHasUnwantedTrait && candidateHasUnwantedTrait) {
 426             return NO;
 427         }
 428     }
 429
 430     int chosenWeightDelta = chosenWeight - desiredWeight;
 431     int candidateWeightDelta = candidateWeight - desiredWeight;
 432
 433     int chosenWeightDeltaMagnitude = ABS(chosenWeightDelta);
 434     int candidateWeightDeltaMagnitude = ABS(candidateWeightDelta);
 435
 436     // Smaller magnitude wins.
 437     // If both have same magnitude, tie breaker is that the smaller weight wins.
 438     // Otherwise, first font in the array wins (should almost never happen).
 439     if (candidateWeightDeltaMagnitude < chosenWeightDeltaMagnitude) {
 440         return YES;
 441     }
 442     if (candidateWeightDeltaMagnitude == chosenWeightDeltaMagnitude && candidateWeight < chosenWeight) {
 443         return YES;
 444     }
 445
 446     return NO;
 447 }
 448
 449 // Family name is somewhat of a misnomer here.  We first attempt to find an exact match
 450 // comparing the desiredFamily to the PostScript name of the installed fonts.  If that fails
 451 // we then do a search based on the family names of the installed fonts.
 452 - (NSFont *)fontWithFamily:(NSString *)desiredFamily traits:(NSFontTraitMask)desiredTraits size:(float)size
 453 {
 454     NSFontManager *fontManager = [NSFontManager sharedFontManager];
 455     NSFont *font= nil;
 456
 457     LOG (FontSelection, "looking for %@ with traits %x\n", desiredFamily, desiredTraits);
 458
 459     // Look for an exact match first.
 460     NSEnumerator *availableFonts = [[fontManager availableFonts] objectEnumerator];
 461     NSString *availableFont;
 462     while ((availableFont = [availableFonts nextObject])) {
 463         if ([desiredFamily caseInsensitiveCompare:availableFont] == NSOrderedSame) {
 464             NSFont *nameMatchedFont = [NSFont fontWithName:availableFont size:size];
 465
 466             // Special case Osaka-Mono.  According to <rdar://problem/3999467>, we need to
 467             // treat Osaka-Mono as fixed pitch.
 468             if ([desiredFamily caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame && desiredTraits == 0) {
 469                 LOG (FontSelection, "found exact match for Osaka-Mono\n");
 470                 return nameMatchedFont;
 471             }
 472
 473             NSFontTraitMask traits = [fontManager traitsOfFont:nameMatchedFont];
 474
 475             if ((traits & desiredTraits) == desiredTraits){
 476                 font = [fontManager convertFont:nameMatchedFont toHaveTrait:desiredTraits];
 477                 LOG (FontSelection, "returning exact match (%@)\n\n", [[[font fontDescriptor] fontAttributes] objectForKey: NSFontNameAttribute]);
 478                 return font;
 479             }
 480             LOG (FontSelection, "found exact match, but not desired traits, available traits %x\n", traits);
 481             break;
 482         }
 483     }
 484
 485     // Do a simple case insensitive search for a matching font family.
 486     // NSFontManager requires exact name matches.
 487     // This addresses the problem of matching arial to Arial, etc., but perhaps not all the issues.
 488     NSEnumerator *e = [[fontManager availableFontFamilies] objectEnumerator];
 489     NSString *availableFamily;
 490     while ((availableFamily = [e nextObject])) {
 491         if ([desiredFamily caseInsensitiveCompare:availableFamily] == NSOrderedSame) {
 492             break;
 493         }
 494     }
 495
 496     // Found a family, now figure out what weight and traits to use.
 497     BOOL choseFont = false;
 498     int chosenWeight = 0;
 499     NSFontTraitMask chosenTraits = 0;
 500
 501     NSArray *fonts = [fontManager availableMembersOfFontFamily:availableFamily];
 502     unsigned n = [fonts count];
 503     unsigned i;
 504     for (i = 0; i < n; i++) {
 505         NSArray *fontInfo = [fonts objectAtIndex:i];
 506
 507         // Array indices must be hard coded because of lame AppKit API.
 508         int fontWeight = [[fontInfo objectAtIndex:2] intValue];
 509         NSFontTraitMask fontTraits = [[fontInfo objectAtIndex:3] unsignedIntValue];
 510
 511         BOOL newWinner;
 512
 513         if (!choseFont) {
 514             newWinner = acceptableChoice(desiredTraits, DESIRED_WEIGHT, fontTraits, fontWeight);
 515         } else {
 516             newWinner = betterChoice(desiredTraits, DESIRED_WEIGHT,
 517                 chosenTraits, chosenWeight, fontTraits, fontWeight);
 518         }
 519
 520         if (newWinner) {
 521             choseFont = YES;
 522             chosenWeight = fontWeight;
 523             chosenTraits = fontTraits;
 524
 525             if (chosenWeight == DESIRED_WEIGHT
 526                     && (chosenTraits & IMPORTANT_FONT_TRAITS) == (desiredTraits & IMPORTANT_FONT_TRAITS)) {
 527                 break;
 528             }
 529         }
 530     }
 531
 532     if (!choseFont) {
 533         LOG (FontSelection, "nothing appropriate to return\n\n");
 534         return nil;
 535     }
 536
 537     font = [fontManager fontWithFamily:availableFamily traits:chosenTraits weight:chosenWeight size:size];
 538     LOG (FontSelection, "returning font family %@ (%@) traits %x, fontID = %x\n\n",
 539             availableFamily, [[[font fontDescriptor] fontAttributes] objectForKey: NSFontNameAttribute], chosenTraits, (unsigned int)[font _atsFontID]);
 540
 541     return font;
 542 }
 543
 544 typedef struct {
 545     NSString *family;
 546     NSFontTraitMask traits;
 547     float size;
 548 } FontCacheKey;
 549
 550 static const void *FontCacheKeyCopy(CFAllocatorRef allocator, const void *value)
 551 {
 552     const FontCacheKey *key = (const FontCacheKey *)value;
 553     FontCacheKey *result = malloc(sizeof(FontCacheKey));
 554     result->family = [key->family copy];
 555     result->traits = key->traits;
 556     result->size = key->size;
 557     return result;
 558 }
 559
 560 static void FontCacheKeyFree(CFAllocatorRef allocator, const void *value)
 561 {
 562     const FontCacheKey *key = (const FontCacheKey *)value;
 563     [key->family release];
 564     free((void *)key);
 565 }
 566
 567 static Boolean FontCacheKeyEqual(const void *value1, const void *value2)
 568 {
 569     const FontCacheKey *key1 = (const FontCacheKey *)value1;
 570     const FontCacheKey *key2 = (const FontCacheKey *)value2;
 571     return key1->size == key2->size && key1->traits == key2->traits && [key1->family isEqualToString:key2->family];
 572 }
 573
 574 static CFHashCode FontCacheKeyHash(const void *value)
 575 {
 576     const FontCacheKey *key = (const FontCacheKey *)value;
 577     return [key->family hash] ^ key->traits ^ (int)key->size;
 578 }
 579
 580 static const void *FontCacheValueRetain(CFAllocatorRef allocator, const void *value)
 581 {
 582     if (value != NULL) {
 583         CFRetain(value);
 584     }
 585     return value;
 586 }
 587
 588 static void FontCacheValueRelease(CFAllocatorRef allocator, const void *value)
 589 {
 590     if (value != NULL) {
 591         CFRelease(value);
 592     }
 593 }
 594
 595 - (NSFont *)cachedFontFromFamily:(NSString *)family traits:(NSFontTraitMask)traits size:(float)size
 596 {
 597     ASSERT(family);
 598
 599     if (!fontCache) {
 600         static const CFDictionaryKeyCallBacks fontCacheKeyCallBacks = { 0, FontCacheKeyCopy, FontCacheKeyFree, NULL, FontCacheKeyEqual, FontCacheKeyHash };
 601         static const CFDictionaryValueCallBacks fontCacheValueCallBacks = { 0, FontCacheValueRetain, FontCacheValueRelease, NULL, NULL };
 602         fontCache = CFDictionaryCreateMutable(NULL, 0, &fontCacheKeyCallBacks, &fontCacheValueCallBacks);
 603     }
 604
 605     const FontCacheKey fontKey = { family, traits, size };
 606     const void *value;
 607     NSFont *font;
 608     if (CFDictionaryGetValueIfPresent(fontCache, &fontKey, &value)) {
 609         font = (NSFont *)value;
 610     } else {
 611         if ([family length] == 0) {
 612             return nil;
 613         }
 614         font = [self fontWithFamily:family traits:traits size:size];
 615         CFDictionaryAddValue(fontCache, &fontKey, font);
 616     }
 617
 618 #ifdef DEBUG_MISSING_FONT
 619     static int unableToFindFontCount = 0;
 620     if (font == nil) {
 621         unableToFindFontCount++;
 622         NSLog(@"unableToFindFontCount %@, traits 0x%08x, size %f, %d\n", family, traits, size, unableToFindFontCount);
 623     }
 624 #endif
 625
 626     return font;
 627 }
 628
 629 @end