046d2d3ef83f0bdb50f483ec64d10dc68b5cb111
[WebKit-https.git] / WebCore / platform / graphics / win / FontCacheWin.cpp
1 /*
2  * Copyright (C) 2006, 2007 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 "FontData.h"
33 #include "Font.h"
34 #include <windows.h>
35 #include <mlang.h>
36 #include <ApplicationServices/ApplicationServices.h>
37 #include <WebKitSystemInterface/WebKitSystemInterface.h>
38
39 using std::min;
40
41 namespace WebCore
42 {
43
44 void FontCache::platformInit()
45 {
46     wkSetUpFontCache(1536 * 1024 * 4); // This size matches Mac.
47 }
48
49 IMLangFontLink2* FontCache::getFontLinkInterface()
50 {
51     static IMultiLanguage *multiLanguage;
52     if (!multiLanguage) {
53         if (CoCreateInstance(CLSID_CMultiLanguage, 0, CLSCTX_ALL, IID_IMultiLanguage, (void**)&multiLanguage) != S_OK)
54             return 0;
55     }
56
57     static IMLangFontLink2* langFontLink;
58     if (!langFontLink) {
59         if (multiLanguage->QueryInterface(&langFontLink) != S_OK)
60             return 0;
61     }
62
63     return langFontLink;
64 }
65
66 static int CALLBACK metaFileEnumProc(HDC hdc, HANDLETABLE* table, CONST ENHMETARECORD* record, int tableEntries, LPARAM logFont)
67 {
68     if (record->iType == EMR_EXTCREATEFONTINDIRECTW) {
69         const EMREXTCREATEFONTINDIRECTW* createFontRecord = reinterpret_cast<const EMREXTCREATEFONTINDIRECTW*>(record);
70         *reinterpret_cast<LOGFONT*>(logFont) = createFontRecord->elfw.elfLogFont;
71     }
72     return true;
73 }
74
75 const FontData* FontCache::getFontDataForCharacters(const Font& font, const UChar* characters, int length)
76 {
77     // IMLangFontLink::MapFont Method does what we want.
78     IMLangFontLink2* langFontLink = getFontLinkInterface();
79     if (!langFontLink)
80         return 0;
81
82     FontData* fontData = 0;
83     HDC hdc = GetDC(0);
84     HFONT primaryFont = font.primaryFont()->m_font.hfont();
85     HGDIOBJ oldFont = SelectObject(hdc, primaryFont);
86     HFONT hfont = 0;
87
88     DWORD acpCodePages;
89     langFontLink->CodePageToCodePages(CP_ACP, &acpCodePages);
90
91     DWORD actualCodePages;
92     long cchActual;
93     langFontLink->GetStrCodePages(characters, length, acpCodePages, &actualCodePages, &cchActual);
94     if (cchActual) {
95         // If simplified Chinese is one of the actual code pages, make one call to MapFont() asking for
96         // simplified Chinese only (and ignore the result). This ensures that we get consistent answers
97         // for characters that are in the simplified Chinese code page as well as other code pages and
98         // characters that are exclusively in the simplified Chinese code page.
99         // FIXME: This needs to be done only once per primary font. We could set a bit in the FontPlatformData
100         // indicating that we have done this.
101         const UINT simplifiedChineseCP = 936;
102         UINT codePage;
103         HFONT result;
104         if (actualCodePages && SUCCEEDED(langFontLink->CodePagesToCodePage(actualCodePages, simplifiedChineseCP, &codePage)) && codePage == simplifiedChineseCP) {
105             DWORD simplifiedChineseCodePages;
106             langFontLink->CodePageToCodePages(simplifiedChineseCP, &simplifiedChineseCodePages);
107             langFontLink->MapFont(hdc, simplifiedChineseCodePages, characters[0], &result);
108             langFontLink->ReleaseFont(result);
109         }
110         if (langFontLink->MapFont(hdc, actualCodePages, characters[0], &result) == S_OK) {
111             // Fill in a log font with the returned font from MLang, and then use that to create a new font.
112             LOGFONT lf;
113             GetObject(result, sizeof(LOGFONT), &lf);
114             langFontLink->ReleaseFont(result);
115             hfont = CreateFontIndirect(&lf);
116         }
117     }
118
119     if (!hfont) {
120         // Font linking failed but Uniscribe might still be able to find a fallback font.
121         // To find out what Uniscribe would do, we make it draw into a metafile and intercept
122         // calls to CreateFontIndirect().
123         HDC metaFileDc = CreateEnhMetaFile(hdc, NULL, NULL, NULL);
124         SelectObject(metaFileDc, hfont ? hfont : primaryFont);
125
126         bool scriptStringOutSucceeded = false;
127         SCRIPT_STRING_ANALYSIS ssa;
128
129         // FIXME: If length is greater than 1, we actually return the font for the last character.
130         // This function should be renamed getFontDataForCharacter and take a single 32-bit character.
131         if (SUCCEEDED(ScriptStringAnalyse(metaFileDc, characters, length, 0, -1, SSA_METAFILE | SSA_FALLBACK | SSA_GLYPHS | SSA_LINK,
132             0, NULL, NULL, NULL, NULL, NULL, &ssa))) {
133             scriptStringOutSucceeded = SUCCEEDED(ScriptStringOut(ssa, 0, 0, 0, NULL, 0, 0, FALSE));
134             ScriptStringFree(&ssa);
135         }
136         HENHMETAFILE metaFile = CloseEnhMetaFile(metaFileDc);
137         if (scriptStringOutSucceeded) {
138             LOGFONT logFont;
139             logFont.lfFaceName[0] = 0;
140             EnumEnhMetaFile(0, metaFile, metaFileEnumProc, &logFont, NULL);
141             if (logFont.lfFaceName[0])
142                 hfont = CreateFontIndirect(&logFont);
143         }
144         DeleteEnhMetaFile(metaFile);
145     }
146
147     if (hfont) {
148         SelectObject(hdc, hfont);
149         WCHAR name[LF_FACESIZE];
150         GetTextFace(hdc, LF_FACESIZE, name);
151
152         String familyName(name);
153         if (!familyName.isEmpty()) {
154             FontPlatformData* result = getCachedFontPlatformData(font.fontDescription(), familyName);
155             if (result)
156                 fontData = getCachedFontData(result);
157         }
158
159         SelectObject(hdc, oldFont);
160         DeleteObject(hfont);
161     }
162
163     ReleaseDC(0, hdc);
164     return fontData;
165 }
166
167 FontPlatformData* FontCache::getSimilarFontPlatformData(const Font& font)
168 {
169     return 0;
170 }
171
172 FontPlatformData* FontCache::getLastResortFallbackFont(const FontDescription& fontDescription)
173 {
174     // FIXME: Would be even better to somehow get the user's default font here.  For now we'll pick
175     // the default that the user would get without changing any prefs.
176     static AtomicString timesStr("Times New Roman");
177     return getCachedFontPlatformData(fontDescription, timesStr);
178 }
179
180 bool FontCache::fontExists(const FontDescription& fontDescription, const AtomicString& family)
181 {
182     LOGFONT winfont;
183
184     // The size here looks unusual.  The negative number is intentional.  The logical size constant is 32.
185     winfont.lfHeight = -fontDescription.computedPixelSize() * 32;
186     winfont.lfWidth = 0;
187     winfont.lfEscapement = 0;
188     winfont.lfOrientation = 0;
189     winfont.lfUnderline = false;
190     winfont.lfStrikeOut = false;
191     winfont.lfCharSet = DEFAULT_CHARSET;
192 #if PLATFORM(CG)
193     winfont.lfOutPrecision = OUT_TT_ONLY_PRECIS;
194 #else
195     winfont.lfOutPrecision = OUT_TT_PRECIS;
196 #endif
197     winfont.lfQuality = 5; // Force cleartype.
198     winfont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
199     winfont.lfItalic = fontDescription.italic();
200
201     // FIXME: Support weights for real.  Do our own enumeration of the available weights.
202     // We can't rely on Windows here, since we need to follow the CSS2 algorithm for how to fill in
203     // gaps in the weight list.
204     // FIXME: Hardcoding Lucida Grande for now.  It uses different weights than typical Win32 fonts
205     // (500/600 instead of 400/700).
206     static AtomicString lucidaStr("Lucida Grande");
207     if (equalIgnoringCase(family, lucidaStr))
208         winfont.lfWeight = fontDescription.bold() ? 600 : 500;
209     else
210         winfont.lfWeight = fontDescription.bold() ? 700 : 400;
211     int len = min(family.length(), (unsigned int)LF_FACESIZE - 1);
212     memcpy(winfont.lfFaceName, family.characters(), len * sizeof(WORD));
213     winfont.lfFaceName[len] = '\0';
214
215     HFONT hfont = CreateFontIndirect(&winfont);
216     // Windows will always give us a valid pointer here, even if the face name is non-existent.  We have to double-check
217     // and see if the family name was really used.
218     HDC dc = GetDC(0);
219     SaveDC(dc);
220     SelectObject(dc, hfont);
221     WCHAR name[LF_FACESIZE];
222     GetTextFace(dc, LF_FACESIZE, name);
223     RestoreDC(dc, -1);
224     ReleaseDC(0, dc);
225
226     DeleteObject(hfont);
227
228     return !wcsicmp(winfont.lfFaceName, name);
229 }
230
231 FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
232 {
233     bool isLucidaGrande = false;
234     static AtomicString lucidaStr("Lucida Grande");
235     if (equalIgnoringCase(family, lucidaStr))
236         isLucidaGrande = true;
237
238     bool useGDI = fontDescription.renderingMode() == AlternateRenderingMode && !isLucidaGrande;
239
240     LOGFONT winfont;
241
242     // The size here looks unusual.  The negative number is intentional.  The logical size constant is 32. We do this
243     // for subpixel precision when rendering using Uniscribe.  This masks rounding errors related to the HFONT metrics being
244     // different from the CGFont metrics.
245     // FIXME: We will eventually want subpixel precision for GDI mode, but the scaled rendering doesn't look as nice.  That may be solvable though.
246     winfont.lfHeight = -fontDescription.computedPixelSize() * (useGDI ? 1 : 32);
247     winfont.lfWidth = 0;
248     winfont.lfEscapement = 0;
249     winfont.lfOrientation = 0;
250     winfont.lfUnderline = false;
251     winfont.lfStrikeOut = false;
252     winfont.lfCharSet = DEFAULT_CHARSET;
253     winfont.lfOutPrecision = OUT_TT_ONLY_PRECIS;
254     winfont.lfQuality = DEFAULT_QUALITY;
255     winfont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
256     winfont.lfItalic = fontDescription.italic();
257
258     // FIXME: Support weights for real.  Do our own enumeration of the available weights.
259     // We can't rely on Windows here, since we need to follow the CSS2 algorithm for how to fill in
260     // gaps in the weight list.
261     // FIXME: Hardcoding Lucida Grande for now.  It uses different weights than typical Win32 fonts
262     // (500/600 instead of 400/700).
263     if (isLucidaGrande) {
264         winfont.lfWeight = fontDescription.bold() ? 600 : 500;
265         useGDI = false; // Never use GDI for Lucida Grande.
266     } else
267         winfont.lfWeight = fontDescription.bold() ? 700 : 400;
268     int len = min(family.length(), (unsigned int)LF_FACESIZE - 1);
269     memcpy(winfont.lfFaceName, family.characters(), len * sizeof(WORD));
270     winfont.lfFaceName[len] = '\0';
271
272     HFONT hfont = CreateFontIndirect(&winfont);
273     // Windows will always give us a valid pointer here, even if the face name is non-existent.  We have to double-check
274     // and see if the family name was really used.
275     HDC dc = GetDC(0);
276     SaveDC(dc);
277     SelectObject(dc, hfont);
278     WCHAR name[LF_FACESIZE];
279     GetTextFace(dc, LF_FACESIZE, name);
280     RestoreDC(dc, -1);
281     ReleaseDC(0, dc);
282
283     if (_wcsicmp(winfont.lfFaceName, name)) {
284         DeleteObject(hfont);
285         return 0;
286     }
287     
288     FontPlatformData* result = new FontPlatformData(hfont, fontDescription.computedPixelSize(),
289                                                     fontDescription.bold(), fontDescription.italic(), useGDI);
290     if (!result->cgFont()) {
291         // The creation of the CGFontRef failed for some reason.  We already asserted in debug builds, but to make
292         // absolutely sure that we don't use this font, go ahead and return 0 so that we can fall back to the next
293         // font.
294         delete result;
295         DeleteObject(hfont);
296         return 0;
297     }        
298
299     return result;
300 }
301
302 }
303