| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <fcntl.h> |
| #include <fontconfig/fontconfig.h> |
| #include <stddef.h> |
| #include <string.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| |
| #include <string> |
| |
| #include "base/posix/eintr_wrapper.h" |
| #include "ppapi/c/private/pp_private_font_charset.h" |
| #include "ppapi/c/trusted/ppb_browser_font_trusted.h" |
| |
| namespace { |
| |
| // MSCharSetToFontconfig translates a Microsoft charset identifier to a |
| // fontconfig language set by appending to |langset|. |
| // Returns true if |langset| is Latin/Greek/Cyrillic. |
| bool MSCharSetToFontconfig(FcLangSet* langset, unsigned fdwCharSet) { |
| // We have need to translate raw fdwCharSet values into terms that |
| // fontconfig can understand. (See the description of fdwCharSet in the MSDN |
| // documentation for CreateFont: |
| // http://msdn.microsoft.com/en-us/library/dd183499(VS.85).aspx ) |
| // |
| // Although the argument is /called/ 'charset', the actual values conflate |
| // character sets (which are sets of Unicode code points) and character |
| // encodings (which are algorithms for turning a series of bits into a |
| // series of code points.) Sometimes the values will name a language, |
| // sometimes they'll name an encoding. In the latter case I'm assuming that |
| // they mean the set of code points in the domain of that encoding. |
| // |
| // fontconfig deals with ISO 639-1 language codes: |
| // http://en.wikipedia.org/wiki/List_of_ISO_639-1_codes |
| // |
| // So, for each of the documented fdwCharSet values I've had to take a |
| // guess at the set of ISO 639-1 languages intended. |
| |
| bool is_lgc = false; |
| switch (fdwCharSet) { |
| case PP_PRIVATEFONTCHARSET_ANSI: |
| // These values I don't really know what to do with, so I'm going to map |
| // them to English also. |
| case PP_PRIVATEFONTCHARSET_DEFAULT: |
| case PP_PRIVATEFONTCHARSET_MAC: |
| case PP_PRIVATEFONTCHARSET_OEM: |
| case PP_PRIVATEFONTCHARSET_SYMBOL: |
| is_lgc = true; |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("en")); |
| break; |
| case PP_PRIVATEFONTCHARSET_BALTIC: |
| // The three baltic languages. |
| is_lgc = true; |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("et")); |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("lv")); |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("lt")); |
| break; |
| case PP_PRIVATEFONTCHARSET_CHINESEBIG5: |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("zh-tw")); |
| break; |
| case PP_PRIVATEFONTCHARSET_GB2312: |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("zh-cn")); |
| break; |
| case PP_PRIVATEFONTCHARSET_EASTEUROPE: |
| // A scattering of eastern European languages. |
| is_lgc = true; |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("pl")); |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("cs")); |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("sk")); |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("hu")); |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("hr")); |
| break; |
| case PP_PRIVATEFONTCHARSET_GREEK: |
| is_lgc = true; |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("el")); |
| break; |
| case PP_PRIVATEFONTCHARSET_HANGUL: |
| case PP_PRIVATEFONTCHARSET_JOHAB: |
| // Korean |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("ko")); |
| break; |
| case PP_PRIVATEFONTCHARSET_RUSSIAN: |
| is_lgc = true; |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("ru")); |
| break; |
| case PP_PRIVATEFONTCHARSET_SHIFTJIS: |
| // Japanese |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("ja")); |
| break; |
| case PP_PRIVATEFONTCHARSET_TURKISH: |
| is_lgc = true; |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("tr")); |
| break; |
| case PP_PRIVATEFONTCHARSET_VIETNAMESE: |
| is_lgc = true; |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("vi")); |
| break; |
| case PP_PRIVATEFONTCHARSET_ARABIC: |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("ar")); |
| break; |
| case PP_PRIVATEFONTCHARSET_HEBREW: |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("he")); |
| break; |
| case PP_PRIVATEFONTCHARSET_THAI: |
| FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("th")); |
| break; |
| // default: |
| // Don't add any languages in that case that we don't recognise the |
| // constant. |
| } |
| return is_lgc; |
| } |
| |
| } // namespace |
| |
| namespace content { |
| |
| int MatchFontFaceWithFallback(const std::string& face, |
| bool is_bold, |
| bool is_italic, |
| uint32_t charset, |
| uint32_t fallback_family) { |
| FcLangSet* langset = FcLangSetCreate(); |
| bool is_lgc = MSCharSetToFontconfig(langset, charset); |
| FcPattern* pattern = FcPatternCreate(); |
| FcPatternAddString( |
| pattern, FC_FAMILY, reinterpret_cast<const FcChar8*>(face.c_str())); |
| |
| // TODO(thestig) Check if we can access Chrome's per-script font preference |
| // here and select better default fonts for non-LGC case. |
| std::string generic_font_name; |
| if (is_lgc) { |
| switch (fallback_family) { |
| case PP_BROWSERFONT_TRUSTED_FAMILY_SERIF: |
| generic_font_name = "Times New Roman"; |
| break; |
| case PP_BROWSERFONT_TRUSTED_FAMILY_SANSSERIF: |
| generic_font_name = "Arial"; |
| break; |
| case PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE: |
| generic_font_name = "Courier New"; |
| break; |
| } |
| } |
| if (!generic_font_name.empty()) { |
| const FcChar8* fc_generic_font_name = |
| reinterpret_cast<const FcChar8*>(generic_font_name.c_str()); |
| FcPatternAddString(pattern, FC_FAMILY, fc_generic_font_name); |
| } |
| |
| if (is_bold) |
| FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD); |
| if (is_italic) |
| FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC); |
| FcPatternAddLangSet(pattern, FC_LANG, langset); |
| FcPatternAddBool(pattern, FC_SCALABLE, FcTrue); |
| FcConfigSubstitute(NULL, pattern, FcMatchPattern); |
| FcDefaultSubstitute(pattern); |
| |
| FcResult result; |
| FcFontSet* font_set = FcFontSort(0, pattern, 0, 0, &result); |
| int font_fd = -1; |
| int good_enough_index = -1; |
| bool good_enough_index_set = false; |
| |
| if (font_set) { |
| for (int i = 0; i < font_set->nfont; ++i) { |
| FcPattern* current = font_set->fonts[i]; |
| |
| // Older versions of fontconfig have a bug where they cannot select |
| // only scalable fonts so we have to manually filter the results. |
| FcBool is_scalable; |
| if (FcPatternGetBool(current, FC_SCALABLE, 0, &is_scalable) != |
| FcResultMatch || |
| !is_scalable) { |
| continue; |
| } |
| |
| FcChar8* c_filename; |
| if (FcPatternGetString(current, FC_FILE, 0, &c_filename) != |
| FcResultMatch) { |
| continue; |
| } |
| |
| // We only want to return sfnt (TrueType) based fonts. We don't have a |
| // very good way of detecting this so we'll filter based on the |
| // filename. |
| bool is_sfnt = false; |
| static const char kSFNTExtensions[][5] = {".ttf", ".otc", ".TTF", ".ttc", |
| ""}; |
| const size_t filename_len = strlen(reinterpret_cast<char*>(c_filename)); |
| for (unsigned j = 0;; j++) { |
| if (kSFNTExtensions[j][0] == 0) { |
| // None of the extensions matched. |
| break; |
| } |
| const size_t ext_len = strlen(kSFNTExtensions[j]); |
| if (filename_len > ext_len && |
| memcmp(c_filename + filename_len - ext_len, |
| kSFNTExtensions[j], |
| ext_len) == 0) { |
| is_sfnt = true; |
| break; |
| } |
| } |
| |
| if (!is_sfnt) |
| continue; |
| |
| // This font is good enough to pass muster, but we might be able to do |
| // better with subsequent ones. |
| if (!good_enough_index_set) { |
| good_enough_index = i; |
| good_enough_index_set = true; |
| } |
| |
| FcValue matrix; |
| bool have_matrix = FcPatternGet(current, FC_MATRIX, 0, &matrix) == 0; |
| |
| if (is_italic && have_matrix) { |
| // we asked for an italic font, but fontconfig is giving us a |
| // non-italic font with a transformation matrix. |
| continue; |
| } |
| |
| FcValue embolden; |
| const bool have_embolden = |
| FcPatternGet(current, FC_EMBOLDEN, 0, &embolden) == 0; |
| |
| if (is_bold && have_embolden) { |
| // we asked for a bold font, but fontconfig gave us a non-bold font |
| // and asked us to apply fake bolding. |
| continue; |
| } |
| |
| font_fd = |
| HANDLE_EINTR(open(reinterpret_cast<char*>(c_filename), O_RDONLY)); |
| if (font_fd >= 0) |
| break; |
| } |
| } |
| |
| if (font_fd == -1 && good_enough_index_set) { |
| // We didn't find a font that we liked, so we fallback to something |
| // acceptable. |
| FcPattern* current = font_set->fonts[good_enough_index]; |
| FcChar8* c_filename; |
| FcPatternGetString(current, FC_FILE, 0, &c_filename); |
| font_fd = HANDLE_EINTR(open(reinterpret_cast<char*>(c_filename), O_RDONLY)); |
| } |
| |
| if (font_set) |
| FcFontSetDestroy(font_set); |
| FcPatternDestroy(pattern); |
| |
| return font_fd; |
| } |
| |
| } // namespace content |
