src/third_party/WebKit/Source/platform/fonts/win/FontFallbackWin.cpp

   1 /*
   2  * Copyright (c) 2006, 2007, 2008, 2009, 2010, 2012 Google 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 are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "platform/fonts/win/FontFallbackWin.h"
  33
  34 #include "SkFontMgr.h"
  35 #include "SkTypeface.h"
  36 #include "wtf/HashMap.h"
  37 #include "wtf/text/StringHash.h"
  38 #include "wtf/text/WTFString.h"
  39 #include <limits>
  40 #include <unicode/locid.h>
  41 #include <unicode/uchar.h>
  42
  43 namespace WebCore {
  44
  45 namespace {
  46
  47 static inline bool isFontPresent(const UChar* fontName, SkFontMgr* fontManager)
  48 {
  49     String family = fontName;
  50     RefPtr<SkTypeface> tf = adoptRef(fontManager->legacyCreateTypeface(family.utf8().data(), SkTypeface::kNormal));
  51     if (!tf)
  52         return false;
  53
  54     SkTypeface::LocalizedStrings* actualFamilies = tf->createFamilyNameIterator();
  55     bool matchesRequestedFamily = false;
  56     SkTypeface::LocalizedString actualFamily;
  57     while (actualFamilies->next(&actualFamily)) {
  58         if (equalIgnoringCase(family, AtomicString::fromUTF8(actualFamily.fString.c_str()))) {
  59             matchesRequestedFamily = true;
  60             break;
  61         }
  62     }
  63     actualFamilies->unref();
  64
  65     return matchesRequestedFamily;
  66 }
  67
  68 // A simple mapping from UScriptCode to family name. This is a sparse array,
  69 // which works well since the range of UScriptCode values is small.
  70 typedef const UChar* ScriptToFontMap[USCRIPT_CODE_LIMIT];
  71
  72 void initializeScriptMonospaceFontMap(ScriptToFontMap& scriptFontMap, SkFontMgr* fontManager)
  73 {
  74     struct FontMap {
  75         UScriptCode script;
  76         const UChar* family;
  77     };
  78
  79     static const FontMap fontMap[] = {
  80         { USCRIPT_HEBREW, L"courier new" },
  81         { USCRIPT_ARABIC, L"courier new" },
  82     };
  83
  84     for (size_t i = 0; i < WTF_ARRAY_LENGTH(fontMap); ++i)
  85         scriptFontMap[fontMap[i].script] = fontMap[i].family;
  86 }
  87
  88 void initializeScriptFontMap(ScriptToFontMap& scriptFontMap, SkFontMgr* fontManager)
  89 {
  90     struct FontMap {
  91         UScriptCode script;
  92         const UChar* family;
  93     };
  94
  95     static const FontMap fontMap[] = {
  96         {USCRIPT_LATIN, L"times new roman"},
  97         {USCRIPT_GREEK, L"times new roman"},
  98         {USCRIPT_CYRILLIC, L"times new roman"},
  99         // FIXME: Consider trying new Vista fonts before XP fonts for CJK.
 100         // Some Vista users do want to use Vista cleartype CJK fonts. If we
 101         // did, the results of tests with CJK characters would have to be
 102         // regenerated for Vista.
 103         {USCRIPT_SIMPLIFIED_HAN, L"simsun"},
 104         {USCRIPT_TRADITIONAL_HAN, L"pmingliu"},
 105         {USCRIPT_HIRAGANA, L"ms pgothic"},
 106         {USCRIPT_KATAKANA, L"ms pgothic"},
 107         {USCRIPT_KATAKANA_OR_HIRAGANA, L"ms pgothic"},
 108         {USCRIPT_HANGUL, L"gulim"},
 109         {USCRIPT_THAI, L"tahoma"},
 110         {USCRIPT_HEBREW, L"david"},
 111         {USCRIPT_ARABIC, L"tahoma"},
 112         {USCRIPT_DEVANAGARI, L"mangal"},
 113         {USCRIPT_BENGALI, L"vrinda"},
 114         {USCRIPT_GURMUKHI, L"raavi"},
 115         {USCRIPT_GUJARATI, L"shruti"},
 116         {USCRIPT_TAMIL, L"latha"},
 117         {USCRIPT_TELUGU, L"gautami"},
 118         {USCRIPT_KANNADA, L"tunga"},
 119         {USCRIPT_GEORGIAN, L"sylfaen"},
 120         {USCRIPT_ARMENIAN, L"sylfaen"},
 121         {USCRIPT_THAANA, L"mv boli"},
 122         {USCRIPT_CANADIAN_ABORIGINAL, L"euphemia"},
 123         {USCRIPT_CHEROKEE, L"plantagenet cherokee"},
 124         {USCRIPT_MONGOLIAN, L"mongolian balti"},
 125         // For USCRIPT_COMMON, we map blocks to scripts when
 126         // that makes sense.
 127     };
 128
 129     struct ScriptToFontFamilies {
 130         UScriptCode script;
 131         const UChar** families;
 132     };
 133
 134     // Kartika on Vista or earlier lacks the support for Chillu
 135     // letters added to Unicode 5.1.
 136     // Try AnjaliOldLipi (a very widely used Malaylalam font with the full
 137     // Unicode 5.x support) before falling back to Kartika.
 138     static const UChar* malayalamFonts[] = {L"AnjaliOldLipi", L"Lohit Malayalam", L"Kartika", L"Rachana", 0};
 139     // Try Khmer OS before Vista fonts because 'Khmer OS' goes along better
 140     // with Latin and looks better/larger for the same size.
 141     static const UChar* khmerFonts[] = {L"Khmer OS", L"MoolBoran", L"DaunPenh", L"Code2000", 0};
 142     // For the following 6 scripts, two or fonts are listed. The fonts in
 143     // the 1st slot are not available on Windows XP. To support these
 144     // scripts on XP, listed in the rest of slots are widely used
 145     // fonts.
 146     static const UChar* ethiopicFonts[] = {L"Nyala", L"Abyssinica SIL", L"Ethiopia Jiret", L"Visual Geez Unicode", L"GF Zemen Unicode", 0};
 147     static const UChar* oriyaFonts[] = {L"Kalinga", L"ori1Uni", L"Lohit Oriya", 0};
 148     static const UChar* laoFonts[] = {L"DokChampa", L"Saysettha OT", L"Phetsarath OT", L"Code2000", 0};
 149     static const UChar* tibetanFonts[] = {L"Microsoft Himalaya", L"Jomolhari", L"Tibetan Machine Uni", 0};
 150     static const UChar* sinhalaFonts[] = {L"Iskoola Pota", L"AksharUnicode", 0};
 151     static const UChar* yiFonts[] = {L"Microsoft Yi Balti", L"Nuosu SIL", L"Code2000", 0};
 152     // http://www.bethmardutho.org/support/meltho/download/index.php
 153     static const UChar* syriacFonts[] = {L"Estrangelo Edessa", L"Estrangelo Nisibin", L"Code2000", 0};
 154     // No Myanmar/Burmese font is shipped with Windows, yet. Try a few
 155     // widely available/used ones that supports Unicode 5.1 or later.
 156     static const UChar* myanmarFonts[] = {L"Padauk", L"Parabaik", L"Myanmar3", L"Code2000", 0};
 157
 158     static const ScriptToFontFamilies scriptToFontFamilies[] = {
 159         {USCRIPT_MALAYALAM, malayalamFonts},
 160         {USCRIPT_KHMER, khmerFonts},
 161         {USCRIPT_ETHIOPIC, ethiopicFonts},
 162         {USCRIPT_ORIYA, oriyaFonts},
 163         {USCRIPT_LAO, laoFonts},
 164         {USCRIPT_TIBETAN, tibetanFonts},
 165         {USCRIPT_SINHALA, sinhalaFonts},
 166         {USCRIPT_YI, yiFonts},
 167         {USCRIPT_SYRIAC, syriacFonts},
 168         {USCRIPT_MYANMAR, myanmarFonts},
 169     };
 170
 171     for (size_t i = 0; i < WTF_ARRAY_LENGTH(fontMap); ++i)
 172         scriptFontMap[fontMap[i].script] = fontMap[i].family;
 173
 174     // FIXME: Instead of scanning the hard-coded list, we have to
 175     // use EnumFont* to 'inspect' fonts to pick up fonts covering scripts
 176     // when it's possible (e.g. using OS/2 table). If we do that, this
 177     // had better be pulled out of here.
 178     for (size_t i = 0; i < WTF_ARRAY_LENGTH(scriptToFontFamilies); ++i) {
 179         UScriptCode script = scriptToFontFamilies[i].script;
 180         scriptFontMap[script] = 0;
 181         const UChar** familyPtr = scriptToFontFamilies[i].families;
 182         while (*familyPtr) {
 183             if (isFontPresent(*familyPtr, fontManager)) {
 184                 scriptFontMap[script] = *familyPtr;
 185                 break;
 186             }
 187             ++familyPtr;
 188         }
 189     }
 190
 191     // Initialize the locale-dependent mapping.
 192     // Since Chrome synchronizes the ICU default locale with its UI locale,
 193     // this ICU locale tells the current UI locale of Chrome.
 194     icu::Locale locale = icu::Locale::getDefault();
 195     const UChar* localeFamily = 0;
 196     if (locale == icu::Locale::getJapanese()) {
 197         localeFamily = scriptFontMap[USCRIPT_HIRAGANA];
 198     } else if (locale == icu::Locale::getKorean()) {
 199         localeFamily = scriptFontMap[USCRIPT_HANGUL];
 200     } else if (locale == icu::Locale::getTraditionalChinese()) {
 201         localeFamily = scriptFontMap[USCRIPT_TRADITIONAL_HAN];
 202     } else {
 203         // For other locales, use the simplified Chinese font for Han.
 204         localeFamily = scriptFontMap[USCRIPT_SIMPLIFIED_HAN];
 205     }
 206     if (localeFamily)
 207         scriptFontMap[USCRIPT_HAN] = localeFamily;
 208 }
 209
 210 // There are a lot of characters in USCRIPT_COMMON that can be covered
 211 // by fonts for scripts closely related to them. See
 212 // http://unicode.org/cldr/utility/list-unicodeset.jsp?a=[:Script=Common:]
 213 // FIXME: make this more efficient with a wider coverage
 214 UScriptCode getScriptBasedOnUnicodeBlock(int ucs4)
 215 {
 216     UBlockCode block = ublock_getCode(ucs4);
 217     switch (block) {
 218     case UBLOCK_CJK_SYMBOLS_AND_PUNCTUATION:
 219         return USCRIPT_HAN;
 220     case UBLOCK_HIRAGANA:
 221     case UBLOCK_KATAKANA:
 222         return USCRIPT_HIRAGANA;
 223     case UBLOCK_ARABIC:
 224         return USCRIPT_ARABIC;
 225     case UBLOCK_THAI:
 226         return USCRIPT_THAI;
 227     case UBLOCK_GREEK:
 228         return USCRIPT_GREEK;
 229     case UBLOCK_DEVANAGARI:
 230         // For Danda and Double Danda (U+0964, U+0965), use a Devanagari
 231         // font for now although they're used by other scripts as well.
 232         // Without a context, we can't do any better.
 233         return USCRIPT_DEVANAGARI;
 234     case UBLOCK_ARMENIAN:
 235         return USCRIPT_ARMENIAN;
 236     case UBLOCK_GEORGIAN:
 237         return USCRIPT_GEORGIAN;
 238     case UBLOCK_KANNADA:
 239         return USCRIPT_KANNADA;
 240     default:
 241         return USCRIPT_COMMON;
 242     }
 243 }
 244
 245 UScriptCode getScript(int ucs4)
 246 {
 247     UErrorCode err = U_ZERO_ERROR;
 248     UScriptCode script = uscript_getScript(ucs4, &err);
 249     // If script is invalid, common or inherited or there's an error,
 250     // infer a script based on the unicode block of a character.
 251     if (script <= USCRIPT_INHERITED || U_FAILURE(err))
 252         script = getScriptBasedOnUnicodeBlock(ucs4);
 253     return script;
 254 }
 255
 256 } // namespace
 257
 258 // FIXME: this is font fallback code version 0.1
 259 //  - Cover all the scripts
 260 //  - Get the default font for each script/generic family from the
 261 //    preference instead of hardcoding in the source.
 262 //    (at least, read values from the registry for IE font settings).
 263 //  - Support generic families (from FontDescription)
 264 //  - If the default font for a script is not available,
 265 //    try some more fonts known to support it. Finally, we can
 266 //    use EnumFontFamilies or similar APIs to come up with a list of
 267 //    fonts supporting the script and cache the result.
 268 //  - Consider using UnicodeSet (or UnicodeMap) converted from
 269 //    GLYPHSET (BMP) or directly read from truetype cmap tables to
 270 //    keep track of which character is supported by which font
 271 //  - Update script_font_cache in response to WM_FONTCHANGE
 272
 273 const UChar* getFontFamilyForScript(UScriptCode script,
 274     FontDescription::GenericFamilyType generic,
 275     SkFontMgr* fontManager)
 276 {
 277     static ScriptToFontMap scriptFontMap;
 278     static ScriptToFontMap scriptMonospaceFontMap;
 279     static bool initialized = false;
 280     if (!initialized) {
 281         initializeScriptFontMap(scriptFontMap, fontManager);
 282         initializeScriptMonospaceFontMap(scriptMonospaceFontMap, fontManager);
 283         initialized = true;
 284     }
 285     if (script == USCRIPT_INVALID_CODE)
 286         return 0;
 287     ASSERT(script < USCRIPT_CODE_LIMIT);
 288     if (generic == FontDescription::MonospaceFamily && scriptMonospaceFontMap[script])
 289         return scriptMonospaceFontMap[script];
 290     return scriptFontMap[script];
 291 }
 292
 293 // FIXME:
 294 //  - Handle 'Inherited', 'Common' and 'Unknown'
 295 //    (see http://www.unicode.org/reports/tr24/#Usage_Model )
 296 //    For 'Inherited' and 'Common', perhaps we need to
 297 //    accept another parameter indicating the previous family
 298 //    and just return it.
 299 //  - All the characters (or characters up to the point a single
 300 //    font can cover) need to be taken into account
 301 const UChar* getFallbackFamily(UChar32 character,
 302     FontDescription::GenericFamilyType generic,
 303     UScriptCode* scriptChecked,
 304     SkFontMgr* fontManager)
 305 {
 306     ASSERT(character);
 307     UScriptCode script = getScript(character);
 308
 309     // For the full-width ASCII characters (U+FF00 - U+FF5E), use the font for
 310     // Han (determined in a locale-dependent way above). Full-width ASCII
 311     // characters are rather widely used in Japanese and Chinese documents and
 312     // they're fully covered by Chinese, Japanese and Korean fonts.
 313     if (0xFF00 < character && character < 0xFF5F)
 314         script = USCRIPT_HAN;
 315
 316     if (script == USCRIPT_COMMON)
 317         script = getScriptBasedOnUnicodeBlock(character);
 318
 319     const UChar* family = getFontFamilyForScript(script, generic, fontManager);
 320     // Another lame work-around to cover non-BMP characters.
 321     // If the font family for script is not found or the character is
 322     // not in BMP (> U+FFFF), we resort to the hard-coded list of
 323     // fallback fonts for now.
 324     if (!family || character > 0xFFFF) {
 325         int plane = character >> 16;
 326         switch (plane) {
 327         case 1:
 328             family = L"code2001";
 329             break;
 330         case 2:
 331             // Use a Traditional Chinese ExtB font if in Traditional Chinese locale.
 332             // Otherwise, use a Simplified Chinese ExtB font. Windows Japanese
 333             // fonts do support a small subset of ExtB (that are included in JIS X 0213),
 334             // but its coverage is rather sparse.
 335             // Eventually, this should be controlled by lang/xml:lang.
 336             if (icu::Locale::getDefault() == icu::Locale::getTraditionalChinese())
 337                 family = L"pmingliu-extb";
 338             else
 339                 family = L"simsun-extb";
 340             break;
 341         default:
 342             family = L"lucida sans unicode";
 343         }
 344     }
 345
 346     if (scriptChecked)
 347         *scriptChecked = script;
 348     return family;
 349 }
 350
 351 } // namespace WebCore