1/*
2 * Copyright (C) 2006, 2007, 2008 Apple 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#include "config.h"
30#include <winsock2.h>
31#include "FontCache.h"
32#include "Font.h"
33#include "SimpleFontData.h"
34#include "UnicodeRange.h"
35#include <mlang.h>
36#include <windows.h>
37#include <wtf/StdLibExtras.h>
38#include <wtf/text/StringHash.h>
39#if USE(CG)
40#include <ApplicationServices/ApplicationServices.h>
41#include <WebKitSystemInterface/WebKitSystemInterface.h>
42#endif
43
44using std::min;
45
46namespace WebCore
47{
48
49void FontCache::platformInit()
50{
51#if USE(CG)
52    wkSetUpFontCache(1536 * 1024 * 4); // This size matches Mac.
53#endif
54}
55
56IMLangFontLink2* FontCache::getFontLinkInterface()
57{
58    static IMultiLanguage *multiLanguage;
59    if (!multiLanguage) {
60        if (CoCreateInstance(CLSID_CMultiLanguage, 0, CLSCTX_ALL, IID_IMultiLanguage, (void**)&multiLanguage) != S_OK)
61            return 0;
62    }
63
64    static IMLangFontLink2* langFontLink;
65    if (!langFontLink) {
66        if (multiLanguage->QueryInterface(&langFontLink) != S_OK)
67            return 0;
68    }
69
70    return langFontLink;
71}
72
73static int CALLBACK metaFileEnumProc(HDC hdc, HANDLETABLE* table, CONST ENHMETARECORD* record, int tableEntries, LPARAM logFont)
74{
75    if (record->iType == EMR_EXTCREATEFONTINDIRECTW) {
76        const EMREXTCREATEFONTINDIRECTW* createFontRecord = reinterpret_cast<const EMREXTCREATEFONTINDIRECTW*>(record);
77        *reinterpret_cast<LOGFONT*>(logFont) = createFontRecord->elfw.elfLogFont;
78    }
79    return true;
80}
81
82static int CALLBACK linkedFontEnumProc(CONST LOGFONT* logFont, CONST TEXTMETRIC* metrics, DWORD fontType, LPARAM hfont)
83{
84    *reinterpret_cast<HFONT*>(hfont) = CreateFontIndirect(logFont);
85    return false;
86}
87
88static const Vector<String>* getLinkedFonts(String& family)
89{
90    static HashMap<String, Vector<String>*> systemLinkMap;
91    Vector<String>* result = systemLinkMap.get(family);
92    if (result)
93        return result;
94
95    result = new Vector<String>;
96    systemLinkMap.set(family, result);
97    HKEY fontLinkKey;
98    if (FAILED(RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\FontLink\\SystemLink", 0, KEY_READ, &fontLinkKey)))
99        return result;
100
101    DWORD linkedFontsBufferSize = 0;
102    RegQueryValueEx(fontLinkKey, family.charactersWithNullTermination(), 0, NULL, NULL, &linkedFontsBufferSize);
103    WCHAR* linkedFonts = reinterpret_cast<WCHAR*>(malloc(linkedFontsBufferSize));
104    if (SUCCEEDED(RegQueryValueEx(fontLinkKey, family.charactersWithNullTermination(), 0, NULL, reinterpret_cast<BYTE*>(linkedFonts), &linkedFontsBufferSize))) {
105        unsigned i = 0;
106        unsigned length = linkedFontsBufferSize / sizeof(*linkedFonts);
107        while (i < length) {
108            while (i < length && linkedFonts[i] != ',')
109                i++;
110            i++;
111            unsigned j = i;
112            while (j < length && linkedFonts[j])
113                j++;
114            result->append(String(linkedFonts + i, j - i));
115            i = j + 1;
116        }
117    }
118    free(linkedFonts);
119    RegCloseKey(fontLinkKey);
120    return result;
121}
122
123static const Vector<DWORD, 4>& getCJKCodePageMasks()
124{
125    // The default order in which we look for a font for a CJK character. If the user's default code page is
126    // one of these, we will use it first.
127    static const UINT CJKCodePages[] = {
128        932, /* Japanese */
129        936, /* Simplified Chinese */
130        950, /* Traditional Chinese */
131        949  /* Korean */
132    };
133
134    static Vector<DWORD, 4> codePageMasks;
135    static bool initialized;
136    if (!initialized) {
137        initialized = true;
138        IMLangFontLink2* langFontLink = fontCache()->getFontLinkInterface();
139        if (!langFontLink)
140            return codePageMasks;
141
142        UINT defaultCodePage;
143        DWORD defaultCodePageMask = 0;
144        if (GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_RETURN_NUMBER | LOCALE_IDEFAULTANSICODEPAGE, reinterpret_cast<LPWSTR>(&defaultCodePage), sizeof(defaultCodePage)))
145            langFontLink->CodePageToCodePages(defaultCodePage, &defaultCodePageMask);
146
147        if (defaultCodePage == CJKCodePages[0] || defaultCodePage == CJKCodePages[1] || defaultCodePage == CJKCodePages[2] || defaultCodePage == CJKCodePages[3])
148            codePageMasks.append(defaultCodePageMask);
149        for (unsigned i = 0; i < 4; ++i) {
150            if (defaultCodePage != CJKCodePages[i]) {
151                DWORD codePageMask;
152                langFontLink->CodePageToCodePages(CJKCodePages[i], &codePageMask);
153                codePageMasks.append(codePageMask);
154            }
155        }
156    }
157    return codePageMasks;
158}
159
160static bool currentFontContainsCharacter(HDC hdc, UChar character)
161{
162    static Vector<char, 512> glyphsetBuffer;
163    glyphsetBuffer.resize(GetFontUnicodeRanges(hdc, 0));
164    GLYPHSET* glyphset = reinterpret_cast<GLYPHSET*>(glyphsetBuffer.data());
165    GetFontUnicodeRanges(hdc, glyphset);
166
167    // FIXME: Change this to a binary search.
168    unsigned i = 0;
169    while (i < glyphset->cRanges && glyphset->ranges[i].wcLow <= character)
170        i++;
171
172    return i && glyphset->ranges[i - 1].wcLow + glyphset->ranges[i - 1].cGlyphs > character;
173}
174
175static HFONT createMLangFont(IMLangFontLink2* langFontLink, HDC hdc, DWORD codePageMask, UChar character = 0)
176{
177    HFONT MLangFont;
178    HFONT hfont = 0;
179    if (SUCCEEDED(langFontLink->MapFont(hdc, codePageMask, character, &MLangFont)) && MLangFont) {
180        LOGFONT lf;
181        GetObject(MLangFont, sizeof(LOGFONT), &lf);
182        langFontLink->ReleaseFont(MLangFont);
183        hfont = CreateFontIndirect(&lf);
184    }
185    return hfont;
186}
187
188const SimpleFontData* FontCache::getFontDataForCharacters(const Font& font, const UChar* characters, int length)
189{
190    UChar character = characters[0];
191    SimpleFontData* fontData = 0;
192    HDC hdc = GetDC(0);
193    HFONT primaryFont = font.primaryFont()->fontDataForCharacter(character)->platformData().hfont();
194    HGDIOBJ oldFont = SelectObject(hdc, primaryFont);
195    HFONT hfont = 0;
196
197    if (IMLangFontLink2* langFontLink = getFontLinkInterface()) {
198        // Try MLang font linking first.
199        DWORD codePages = 0;
200        langFontLink->GetCharCodePages(character, &codePages);
201
202        if (codePages && findCharUnicodeRange(character) == cRangeSetCJK) {
203            // The CJK character may belong to multiple code pages. We want to
204            // do font linking against a single one of them, preferring the default
205            // code page for the user's locale.
206            const Vector<DWORD, 4>& CJKCodePageMasks = getCJKCodePageMasks();
207            unsigned numCodePages = CJKCodePageMasks.size();
208            for (unsigned i = 0; i < numCodePages && !hfont; ++i) {
209                hfont = createMLangFont(langFontLink, hdc, CJKCodePageMasks[i]);
210                if (hfont && !(codePages & CJKCodePageMasks[i])) {
211                    // We asked about a code page that is not one of the code pages
212                    // returned by MLang, so the font might not contain the character.
213                    SelectObject(hdc, hfont);
214                    if (!currentFontContainsCharacter(hdc, character)) {
215                        DeleteObject(hfont);
216                        hfont = 0;
217                    }
218                    SelectObject(hdc, primaryFont);
219                }
220            }
221        } else
222            hfont = createMLangFont(langFontLink, hdc, codePages, character);
223    }
224
225    // A font returned from MLang is trusted to contain the character.
226    bool containsCharacter = hfont;
227
228    if (!hfont) {
229        // To find out what font Uniscribe would use, we make it draw into a metafile and intercept
230        // calls to CreateFontIndirect().
231        HDC metaFileDc = CreateEnhMetaFile(hdc, NULL, NULL, NULL);
232        SelectObject(metaFileDc, primaryFont);
233
234        bool scriptStringOutSucceeded = false;
235        SCRIPT_STRING_ANALYSIS ssa;
236
237        // FIXME: If length is greater than 1, we actually return the font for the last character.
238        // This function should be renamed getFontDataForCharacter and take a single 32-bit character.
239        if (SUCCEEDED(ScriptStringAnalyse(metaFileDc, characters, length, 0, -1, SSA_METAFILE | SSA_FALLBACK | SSA_GLYPHS | SSA_LINK,
240            0, NULL, NULL, NULL, NULL, NULL, &ssa))) {
241            scriptStringOutSucceeded = SUCCEEDED(ScriptStringOut(ssa, 0, 0, 0, NULL, 0, 0, FALSE));
242            ScriptStringFree(&ssa);
243        }
244        HENHMETAFILE metaFile = CloseEnhMetaFile(metaFileDc);
245        if (scriptStringOutSucceeded) {
246            LOGFONT logFont;
247            logFont.lfFaceName[0] = 0;
248            EnumEnhMetaFile(0, metaFile, metaFileEnumProc, &logFont, NULL);
249            if (logFont.lfFaceName[0])
250                hfont = CreateFontIndirect(&logFont);
251        }
252        DeleteEnhMetaFile(metaFile);
253    }
254
255    String familyName;
256    const Vector<String>* linkedFonts = 0;
257    unsigned linkedFontIndex = 0;
258    while (hfont) {
259        SelectObject(hdc, hfont);
260        WCHAR name[LF_FACESIZE];
261        GetTextFace(hdc, LF_FACESIZE, name);
262        familyName = name;
263
264        if (containsCharacter || currentFontContainsCharacter(hdc, character))
265            break;
266
267        if (!linkedFonts)
268            linkedFonts = getLinkedFonts(familyName);
269        SelectObject(hdc, oldFont);
270        DeleteObject(hfont);
271        hfont = 0;
272
273        if (linkedFonts->size() <= linkedFontIndex)
274            break;
275
276        LOGFONT logFont;
277        logFont.lfCharSet = DEFAULT_CHARSET;
278        memcpy(logFont.lfFaceName, linkedFonts->at(linkedFontIndex).characters(), linkedFonts->at(linkedFontIndex).length() * sizeof(WCHAR));
279        logFont.lfFaceName[linkedFonts->at(linkedFontIndex).length()] = 0;
280        EnumFontFamiliesEx(hdc, &logFont, linkedFontEnumProc, reinterpret_cast<LPARAM>(&hfont), 0);
281        linkedFontIndex++;
282    }
283
284    if (hfont) {
285        if (!familyName.isEmpty()) {
286            FontPlatformData* result = getCachedFontPlatformData(font.fontDescription(), familyName);
287            if (result)
288                fontData = getCachedFontData(result);
289        }
290
291        SelectObject(hdc, oldFont);
292        DeleteObject(hfont);
293    }
294
295    ReleaseDC(0, hdc);
296    return fontData;
297}
298
299SimpleFontData* FontCache::getSimilarFontPlatformData(const Font& font)
300{
301    return 0;
302}
303
304static SimpleFontData* fontDataFromDescriptionAndLogFont(FontCache* fontCache, const FontDescription& fontDescription, const LOGFONT& font, AtomicString& outFontFamilyName)
305{
306    AtomicString familyName = String(font.lfFaceName, wcsnlen(font.lfFaceName, LF_FACESIZE));
307    SimpleFontData* fontData = fontCache->getCachedFontData(fontDescription, familyName);
308    if (fontData)
309        outFontFamilyName = familyName;
310    return fontData;
311}
312
313SimpleFontData* FontCache::getLastResortFallbackFont(const FontDescription& fontDescription)
314{
315    DEFINE_STATIC_LOCAL(AtomicString, fallbackFontName, ());
316    if (!fallbackFontName.isEmpty())
317        return getCachedFontData(fontDescription, fallbackFontName);
318
319    // FIXME: Would be even better to somehow get the user's default font here.  For now we'll pick
320    // the default that the user would get without changing any prefs.
321
322    // Search all typical Windows-installed full Unicode fonts.
323    // Sorted by most to least glyphs according to http://en.wikipedia.org/wiki/Unicode_typefaces
324    // Start with Times New Roman also since it is the default if the user doesn't change prefs.
325    static AtomicString fallbackFonts[] = {
326        AtomicString("Times New Roman"),
327        AtomicString("Microsoft Sans Serif"),
328        AtomicString("Tahoma"),
329        AtomicString("Lucida Sans Unicode"),
330        AtomicString("Arial")
331    };
332    SimpleFontData* simpleFont;
333    for (size_t i = 0; i < WTF_ARRAY_LENGTH(fallbackFonts); ++i) {
334        if (simpleFont = getCachedFontData(fontDescription, fallbackFonts[i])) {
335            fallbackFontName = fallbackFonts[i];
336            return simpleFont;
337        }
338    }
339
340    // Fall back to the DEFAULT_GUI_FONT if no known Unicode fonts are available.
341    if (HFONT defaultGUIFont = static_cast<HFONT>(GetStockObject(DEFAULT_GUI_FONT))) {
342        LOGFONT defaultGUILogFont;
343        GetObject(defaultGUIFont, sizeof(defaultGUILogFont), &defaultGUILogFont);
344        if (simpleFont = fontDataFromDescriptionAndLogFont(this, fontDescription, defaultGUILogFont, fallbackFontName))
345            return simpleFont;
346    }
347
348    // Fall back to Non-client metrics fonts.
349    NONCLIENTMETRICS nonClientMetrics = {0};
350    nonClientMetrics.cbSize = sizeof(nonClientMetrics);
351    if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(nonClientMetrics), &nonClientMetrics, 0)) {
352        if (simpleFont = fontDataFromDescriptionAndLogFont(this, fontDescription, nonClientMetrics.lfMessageFont, fallbackFontName))
353            return simpleFont;
354        if (simpleFont = fontDataFromDescriptionAndLogFont(this, fontDescription, nonClientMetrics.lfMenuFont, fallbackFontName))
355            return simpleFont;
356        if (simpleFont = fontDataFromDescriptionAndLogFont(this, fontDescription, nonClientMetrics.lfStatusFont, fallbackFontName))
357            return simpleFont;
358        if (simpleFont = fontDataFromDescriptionAndLogFont(this, fontDescription, nonClientMetrics.lfCaptionFont, fallbackFontName))
359            return simpleFont;
360        if (simpleFont = fontDataFromDescriptionAndLogFont(this, fontDescription, nonClientMetrics.lfSmCaptionFont, fallbackFontName))
361            return simpleFont;
362    }
363
364    ASSERT_NOT_REACHED();
365    return 0;
366}
367
368static LONG toGDIFontWeight(FontWeight fontWeight)
369{
370    static LONG gdiFontWeights[] = {
371        FW_THIN,        // FontWeight100
372        FW_EXTRALIGHT,  // FontWeight200
373        FW_LIGHT,       // FontWeight300
374        FW_NORMAL,      // FontWeight400
375        FW_MEDIUM,      // FontWeight500
376        FW_SEMIBOLD,    // FontWeight600
377        FW_BOLD,        // FontWeight700
378        FW_EXTRABOLD,   // FontWeight800
379        FW_HEAVY        // FontWeight900
380    };
381    return gdiFontWeights[fontWeight];
382}
383
384static inline bool isGDIFontWeightBold(LONG gdiFontWeight)
385{
386    return gdiFontWeight >= FW_SEMIBOLD;
387}
388
389static LONG adjustedGDIFontWeight(LONG gdiFontWeight, const String& family)
390{
391    static AtomicString lucidaStr("Lucida Grande");
392    if (equalIgnoringCase(family, lucidaStr)) {
393        if (gdiFontWeight == FW_NORMAL)
394            return FW_MEDIUM;
395        if (gdiFontWeight == FW_BOLD)
396            return FW_SEMIBOLD;
397    }
398    return gdiFontWeight;
399}
400
401struct MatchImprovingProcData {
402    MatchImprovingProcData(LONG desiredWeight, bool desiredItalic)
403        : m_desiredWeight(desiredWeight)
404        , m_desiredItalic(desiredItalic)
405        , m_hasMatched(false)
406    {
407    }
408
409    LONG m_desiredWeight;
410    bool m_desiredItalic;
411    bool m_hasMatched;
412    LOGFONT m_chosen;
413};
414
415static int CALLBACK matchImprovingEnumProc(CONST LOGFONT* candidate, CONST TEXTMETRIC* metrics, DWORD fontType, LPARAM lParam)
416{
417    MatchImprovingProcData* matchData = reinterpret_cast<MatchImprovingProcData*>(lParam);
418
419    if (!matchData->m_hasMatched) {
420        matchData->m_hasMatched = true;
421        matchData->m_chosen = *candidate;
422        return 1;
423    }
424
425    if (!candidate->lfItalic != !matchData->m_chosen.lfItalic) {
426        if (!candidate->lfItalic == !matchData->m_desiredItalic)
427            matchData->m_chosen = *candidate;
428
429        return 1;
430    }
431
432    unsigned chosenWeightDeltaMagnitude = abs(matchData->m_chosen.lfWeight - matchData->m_desiredWeight);
433    unsigned candidateWeightDeltaMagnitude = abs(candidate->lfWeight - matchData->m_desiredWeight);
434
435    // If both are the same distance from the desired weight, prefer the candidate if it is further from regular.
436    if (chosenWeightDeltaMagnitude == candidateWeightDeltaMagnitude && abs(candidate->lfWeight - FW_NORMAL) > abs(matchData->m_chosen.lfWeight - FW_NORMAL)) {
437        matchData->m_chosen = *candidate;
438        return 1;
439    }
440
441    // Otherwise, prefer the one closer to the desired weight.
442    if (candidateWeightDeltaMagnitude < chosenWeightDeltaMagnitude)
443        matchData->m_chosen = *candidate;
444
445    return 1;
446}
447
448static HFONT createGDIFont(const AtomicString& family, LONG desiredWeight, bool desiredItalic, int size, bool synthesizeItalic)
449{
450    HDC hdc = GetDC(0);
451
452    LOGFONT logFont;
453    logFont.lfCharSet = DEFAULT_CHARSET;
454    unsigned familyLength = min(family.length(), static_cast<unsigned>(LF_FACESIZE - 1));
455    memcpy(logFont.lfFaceName, family.characters(), familyLength * sizeof(UChar));
456    logFont.lfFaceName[familyLength] = 0;
457    logFont.lfPitchAndFamily = 0;
458
459    MatchImprovingProcData matchData(desiredWeight, desiredItalic);
460    EnumFontFamiliesEx(hdc, &logFont, matchImprovingEnumProc, reinterpret_cast<LPARAM>(&matchData), 0);
461
462    ReleaseDC(0, hdc);
463
464    if (!matchData.m_hasMatched)
465        return 0;
466
467    matchData.m_chosen.lfHeight = -size;
468    matchData.m_chosen.lfWidth = 0;
469    matchData.m_chosen.lfEscapement = 0;
470    matchData.m_chosen.lfOrientation = 0;
471    matchData.m_chosen.lfUnderline = false;
472    matchData.m_chosen.lfStrikeOut = false;
473    matchData.m_chosen.lfCharSet = DEFAULT_CHARSET;
474#if USE(CG) || USE(CAIRO)
475    matchData.m_chosen.lfOutPrecision = OUT_TT_ONLY_PRECIS;
476#else
477    matchData.m_chosen.lfOutPrecision = OUT_TT_PRECIS;
478#endif
479    matchData.m_chosen.lfQuality = DEFAULT_QUALITY;
480    matchData.m_chosen.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
481
482   if (desiredItalic && !matchData.m_chosen.lfItalic && synthesizeItalic)
483       matchData.m_chosen.lfItalic = 1;
484
485    HFONT result = CreateFontIndirect(&matchData.m_chosen);
486    if (!result)
487        return 0;
488
489    HDC dc = GetDC(0);
490    SaveDC(dc);
491    SelectObject(dc, result);
492    WCHAR actualName[LF_FACESIZE];
493    GetTextFace(dc, LF_FACESIZE, actualName);
494    RestoreDC(dc, -1);
495    ReleaseDC(0, dc);
496
497    if (wcsicmp(matchData.m_chosen.lfFaceName, actualName)) {
498        DeleteObject(result);
499        result = 0;
500    }
501
502    return result;
503}
504
505struct TraitsInFamilyProcData {
506    TraitsInFamilyProcData(const AtomicString& familyName)
507        : m_familyName(familyName)
508    {
509    }
510
511    const AtomicString& m_familyName;
512    HashSet<unsigned> m_traitsMasks;
513};
514
515static int CALLBACK traitsInFamilyEnumProc(CONST LOGFONT* logFont, CONST TEXTMETRIC* metrics, DWORD fontType, LPARAM lParam)
516{
517    TraitsInFamilyProcData* procData = reinterpret_cast<TraitsInFamilyProcData*>(lParam);
518
519    unsigned traitsMask = 0;
520    traitsMask |= logFont->lfItalic ? FontStyleItalicMask : FontStyleNormalMask;
521    traitsMask |= FontVariantNormalMask;
522    LONG weight = adjustedGDIFontWeight(logFont->lfWeight, procData->m_familyName);
523    traitsMask |= weight == FW_THIN ? FontWeight100Mask :
524        weight == FW_EXTRALIGHT ? FontWeight200Mask :
525        weight == FW_LIGHT ? FontWeight300Mask :
526        weight == FW_NORMAL ? FontWeight400Mask :
527        weight == FW_MEDIUM ? FontWeight500Mask :
528        weight == FW_SEMIBOLD ? FontWeight600Mask :
529        weight == FW_BOLD ? FontWeight700Mask :
530        weight == FW_EXTRABOLD ? FontWeight800Mask :
531                                 FontWeight900Mask;
532    procData->m_traitsMasks.add(traitsMask);
533    return 1;
534}
535void FontCache::getTraitsInFamily(const AtomicString& familyName, Vector<unsigned>& traitsMasks)
536{
537    HDC hdc = GetDC(0);
538
539    LOGFONT logFont;
540    logFont.lfCharSet = DEFAULT_CHARSET;
541    unsigned familyLength = min(familyName.length(), static_cast<unsigned>(LF_FACESIZE - 1));
542    memcpy(logFont.lfFaceName, familyName.characters(), familyLength * sizeof(UChar));
543    logFont.lfFaceName[familyLength] = 0;
544    logFont.lfPitchAndFamily = 0;
545
546    TraitsInFamilyProcData procData(familyName);
547    EnumFontFamiliesEx(hdc, &logFont, traitsInFamilyEnumProc, reinterpret_cast<LPARAM>(&procData), 0);
548    copyToVector(procData.m_traitsMasks, traitsMasks);
549
550    ReleaseDC(0, hdc);
551}
552
553FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
554{
555    bool isLucidaGrande = false;
556    static AtomicString lucidaStr("Lucida Grande");
557    if (equalIgnoringCase(family, lucidaStr))
558        isLucidaGrande = true;
559
560    bool useGDI = fontDescription.renderingMode() == AlternateRenderingMode && !isLucidaGrande;
561
562    // The logical size constant is 32. We do this for subpixel precision when rendering using Uniscribe.
563    // This masks rounding errors related to the HFONT metrics being  different from the CGFont metrics.
564    // FIXME: We will eventually want subpixel precision for GDI mode, but the scaled rendering doesn't
565    // look as nice. That may be solvable though.
566    LONG weight = adjustedGDIFontWeight(toGDIFontWeight(fontDescription.weight()), family);
567    HFONT hfont = createGDIFont(family, weight, fontDescription.italic(),
568                                fontDescription.computedPixelSize() * (useGDI ? 1 : 32), useGDI);
569
570    if (!hfont)
571        return 0;
572
573    if (isLucidaGrande)
574        useGDI = false; // Never use GDI for Lucida Grande.
575
576    LOGFONT logFont;
577    GetObject(hfont, sizeof(LOGFONT), &logFont);
578
579    bool synthesizeBold = isGDIFontWeightBold(weight) && !isGDIFontWeightBold(logFont.lfWeight);
580    bool synthesizeItalic = fontDescription.italic() && !logFont.lfItalic;
581
582    FontPlatformData* result = new FontPlatformData(hfont, fontDescription.computedPixelSize(), synthesizeBold, synthesizeItalic, useGDI);
583
584#if USE(CG)
585    bool fontCreationFailed = !result->cgFont();
586#elif USE(CAIRO)
587    bool fontCreationFailed = !result->scaledFont();
588#endif
589
590    if (fontCreationFailed) {
591        // The creation of the CGFontRef failed for some reason.  We already asserted in debug builds, but to make
592        // absolutely sure that we don't use this font, go ahead and return 0 so that we can fall back to the next
593        // font.
594        delete result;
595        DeleteObject(hfont);
596        return 0;
597    }
598
599    return result;
600}
601
602}
603
604