git-svn-id: http://skia.googlecode.com/svn/trunk@7863 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/ports/SkFontConfigInterface_direct.cpp b/src/ports/SkFontConfigInterface_direct.cpp
new file mode 100644
index 0000000..bba1eaf
--- /dev/null
+++ b/src/ports/SkFontConfigInterface_direct.cpp
@@ -0,0 +1,579 @@
+/*
+ * Copyright 2009 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/* migrated from chrome/src/skia/ext/SkFontHost_fontconfig_direct.cpp */
+
+#include <map>
+#include <string>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <fontconfig/fontconfig.h>
+
+#include "SkFontConfigInterface.h"
+//#include "SkUtils.h"
+#include "SkStream.h"
+
+class SkFontConfigInterfaceDirect : public SkFontConfigInterface {
+public:
+ SkFontConfigInterfaceDirect();
+ virtual ~SkFontConfigInterfaceDirect();
+
+ virtual bool match(const char familyName[], SkTypeface::Style requested,
+ unsigned* fileFaceID, SkTypeface::Style* outStyle) SK_OVERRIDE;
+ virtual bool getFamilyName(unsigned fileFaceID, SkString* name) SK_OVERRIDE;
+ virtual SkStream* openStream(unsigned fileFaceID) SK_OVERRIDE;
+
+private:
+ SkMutex mutex_;
+
+ // fileid stored in two maps below are unique per font file.
+ std::map<unsigned, std::string> fileid_to_filename_;
+ std::map<std::string, unsigned> filename_to_fileid_;
+
+ // Cache of |family,style| to |FontMatch| to minimize querying FontConfig.
+ typedef std::pair<std::string, int> FontMatchKey;
+ struct FontMatch {
+ std::string family;
+ SkTypeface::Style style;
+ unsigned filefaceid;
+ };
+ std::map<FontMatchKey, FontMatch> font_match_cache_;
+
+ unsigned next_file_id_;
+};
+
+SkFontConfigInterface* SkCreateDirectFontConfigInterface();
+SkFontConfigInterface* SkCreateDirectFontConfigInterface() {
+ return SkNEW(SkFontConfigInterfaceDirect);
+}
+
+namespace {
+
+// Equivalence classes, used to match the Liberation and other fonts
+// with their metric-compatible replacements. See the discussion in
+// GetFontEquivClass().
+enum FontEquivClass
+{
+ OTHER,
+ SANS,
+ SERIF,
+ MONO,
+ SYMBOL,
+ PGOTHIC,
+ GOTHIC,
+ PMINCHO,
+ MINCHO,
+ SIMSUN,
+ NSIMSUN,
+ SIMHEI,
+ PMINGLIU,
+ MINGLIU,
+ PMINGLIUHK,
+ MINGLIUHK,
+};
+
+// Match the font name against a whilelist of fonts, returning the equivalence
+// class.
+FontEquivClass GetFontEquivClass(const char* fontname)
+{
+ // It would be nice for fontconfig to tell us whether a given suggested
+ // replacement is a "strong" match (that is, an equivalent font) or
+ // a "weak" match (that is, fontconfig's next-best attempt at finding a
+ // substitute). However, I played around with the fontconfig API for
+ // a good few hours and could not make it reveal this information.
+ //
+ // So instead, we hardcode. Initially this function emulated
+ // /etc/fonts/conf.d/30-metric-aliases.conf
+ // from my Ubuntu system, but we're better off being very conservative.
+
+ // Arimo, Tinos and Cousine are a set of fonts metric-compatible with
+ // Arial, Times New Roman and Courier New with a character repertoire
+ // much larger than Liberation. Note that Cousine is metrically
+ // compatible with Courier New, but the former is sans-serif while
+ // the latter is serif.
+
+
+ struct FontEquivMap {
+ FontEquivClass clazz;
+ const char name[40];
+ };
+
+ static const FontEquivMap kFontEquivMap[] = {
+ { SANS, "Arial" },
+ { SANS, "Arimo" },
+ { SANS, "Liberation Sans" },
+
+ { SERIF, "Times New Roman" },
+ { SERIF, "Tinos" },
+ { SERIF, "Liberation Serif" },
+
+ { MONO, "Courier New" },
+ { MONO, "Cousine" },
+ { MONO, "Liberation Mono" },
+
+ { SYMBOL, "Symbol" },
+ { SYMBOL, "Symbol Neu" },
+
+ // ＭＳ Ｐゴシック
+ { PGOTHIC, "MS PGothic" },
+ { PGOTHIC, "\xef\xbc\xad\xef\xbc\xb3 \xef\xbc\xb0"
+ "\xe3\x82\xb4\xe3\x82\xb7\xe3\x83\x83\xe3\x82\xaf" },
+ { PGOTHIC, "IPAPGothic" },
+ { PGOTHIC, "MotoyaG04Gothic" },
+
+ // ＭＳ ゴシック
+ { GOTHIC, "MS Gothic" },
+ { GOTHIC, "\xef\xbc\xad\xef\xbc\xb3 "
+ "\xe3\x82\xb4\xe3\x82\xb7\xe3\x83\x83\xe3\x82\xaf" },
+ { GOTHIC, "IPAGothic" },
+ { GOTHIC, "MotoyaG04GothicMono" },
+
+ // ＭＳ Ｐ明朝
+ { PMINCHO, "MS PMincho" },
+ { PMINCHO, "\xef\xbc\xad\xef\xbc\xb3 \xef\xbc\xb0"
+ "\xe6\x98\x8e\xe6\x9c\x9d"},
+ { PMINCHO, "IPAPMincho" },
+ { PMINCHO, "MotoyaG04Mincho" },
+
+ // ＭＳ 明朝
+ { MINCHO, "MS Mincho" },
+ { MINCHO, "\xef\xbc\xad\xef\xbc\xb3 \xe6\x98\x8e\xe6\x9c\x9d" },
+ { MINCHO, "IPAMincho" },
+ { MINCHO, "MotoyaG04MinchoMono" },
+
+ // 宋体
+ { SIMSUN, "Simsun" },
+ { SIMSUN, "\xe5\xae\x8b\xe4\xbd\x93" },
+ { SIMSUN, "MSung GB18030" },
+ { SIMSUN, "Song ASC" },
+
+ // 新宋体
+ { NSIMSUN, "NSimsun" },
+ { NSIMSUN, "\xe6\x96\xb0\xe5\xae\x8b\xe4\xbd\x93" },
+ { NSIMSUN, "MSung GB18030" },
+ { NSIMSUN, "N Song ASC" },
+
+ // 黑体
+ { SIMHEI, "Simhei" },
+ { SIMHEI, "\xe9\xbb\x91\xe4\xbd\x93" },
+ { SIMHEI, "MYingHeiGB18030" },
+ { SIMHEI, "MYingHeiB5HK" },
+
+ // 新細明體
+ { PMINGLIU, "PMingLiU"},
+ { PMINGLIU, "\xe6\x96\xb0\xe7\xb4\xb0\xe6\x98\x8e\xe9\xab\x94" },
+ { PMINGLIU, "MSung B5HK"},
+
+ // 細明體
+ { MINGLIU, "MingLiU"},
+ { MINGLIU, "\xe7\xb4\xb0\xe6\x98\x8e\xe9\xab\x94" },
+ { MINGLIU, "MSung B5HK"},
+
+ // 新細明體
+ { PMINGLIUHK, "PMingLiU_HKSCS"},
+ { PMINGLIUHK, "\xe6\x96\xb0\xe7\xb4\xb0\xe6\x98\x8e\xe9\xab\x94_HKSCS" },
+ { PMINGLIUHK, "MSung B5HK"},
+
+ // 細明體
+ { MINGLIUHK, "MingLiU_HKSCS"},
+ { MINGLIUHK, "\xe7\xb4\xb0\xe6\x98\x8e\xe9\xab\x94_HKSCS" },
+ { MINGLIUHK, "MSung B5HK"},
+ };
+
+ static const size_t kFontCount =
+ sizeof(kFontEquivMap)/sizeof(kFontEquivMap[0]);
+
+ // TODO(jungshik): If this loop turns out to be hot, turn
+ // the array to a static (hash)map to speed it up.
+ for (size_t i = 0; i < kFontCount; ++i) {
+ if (strcasecmp(kFontEquivMap[i].name, fontname) == 0)
+ return kFontEquivMap[i].clazz;
+ }
+ return OTHER;
+}
+
+
+// Return true if |font_a| and |font_b| are visually and at the metrics
+// level interchangeable.
+bool IsMetricCompatibleReplacement(const char* font_a, const char* font_b)
+{
+ FontEquivClass class_a = GetFontEquivClass(font_a);
+ FontEquivClass class_b = GetFontEquivClass(font_b);
+
+ return class_a != OTHER && class_a == class_b;
+}
+
+inline unsigned FileFaceIdToFileId(unsigned filefaceid)
+{
+ return filefaceid >> 4;
+}
+
+inline unsigned FileIdAndFaceIndexToFileFaceId(unsigned fileid, int face_index)
+{
+ SkASSERT((face_index & 0xfu) == face_index);
+ return (fileid << 4) | face_index;
+}
+
+// Normally we only return exactly the font asked for. In last-resort
+// cases, the request either doesn't specify a font or is one of the
+// basic font names like "Sans", "Serif" or "Monospace". This function
+// tells you whether a given request is for such a fallback.
+bool IsFallbackFontAllowed(const std::string& family) {
+ const char* family_cstr = family.c_str();
+ return family.empty() ||
+ strcasecmp(family_cstr, "sans") == 0 ||
+ strcasecmp(family_cstr, "serif") == 0 ||
+ strcasecmp(family_cstr, "monospace") == 0;
+}
+
+// Find matching font from |font_set| for the given font family.
+FcPattern* MatchFont(FcFontSet* font_set,
+ FcChar8* post_config_family,
+ const std::string& family) {
+ // Older versions of fontconfig have a bug where they cannot select
+ // only scalable fonts so we have to manually filter the results.
+ FcPattern* match = NULL;
+ for (int i = 0; i < font_set->nfont; ++i) {
+ FcPattern* current = font_set->fonts[i];
+ FcBool is_scalable;
+
+ if (FcPatternGetBool(current, FC_SCALABLE, 0,
+ &is_scalable) != FcResultMatch ||
+ !is_scalable) {
+ continue;
+ }
+
+ // fontconfig can also return fonts which are unreadable
+ FcChar8* c_filename;
+ if (FcPatternGetString(current, FC_FILE, 0, &c_filename) != FcResultMatch)
+ continue;
+
+ if (access(reinterpret_cast<char*>(c_filename), R_OK) != 0)
+ continue;
+
+ match = current;
+ break;
+ }
+
+ if (match && !IsFallbackFontAllowed(family)) {
+ bool acceptable_substitute = false;
+ for (int id = 0; id < 255; ++id) {
+ FcChar8* post_match_family;
+ if (FcPatternGetString(match, FC_FAMILY, id, &post_match_family) !=
+ FcResultMatch)
+ break;
+ acceptable_substitute =
+ (strcasecmp(reinterpret_cast<char*>(post_config_family),
+ reinterpret_cast<char*>(post_match_family)) == 0 ||
+ // Workaround for Issue 12530:
+ // requested family: "Bitstream Vera Sans"
+ // post_config_family: "Arial"
+ // post_match_family: "Bitstream Vera Sans"
+ // -> We should treat this case as a good match.
+ strcasecmp(family.c_str(),
+ reinterpret_cast<char*>(post_match_family)) == 0) ||
+ IsMetricCompatibleReplacement(family.c_str(),
+ reinterpret_cast<char*>(post_match_family));
+ if (acceptable_substitute)
+ break;
+ }
+ if (!acceptable_substitute)
+ return NULL;
+ }
+
+ return match;
+}
+
+// Retrieves |is_bold|, |is_italic| and |font_family| properties from |font|.
+bool GetFontProperties(FcPattern* font,
+ std::string* font_family,
+ SkTypeface::Style* style) {
+ FcChar8* c_family;
+ if (FcPatternGetString(font, FC_FAMILY, 0, &c_family))
+ return false;
+
+ int resulting_bold;
+ if (FcPatternGetInteger(font, FC_WEIGHT, 0, &resulting_bold))
+ resulting_bold = FC_WEIGHT_NORMAL;
+
+ int resulting_italic;
+ if (FcPatternGetInteger(font, FC_SLANT, 0, &resulting_italic))
+ resulting_italic = FC_SLANT_ROMAN;
+
+ // If we ask for an italic font, fontconfig might take a roman font and set
+ // the undocumented property FC_MATRIX to a skew matrix. It'll then say
+ // that the font is italic or oblique. So, if we see a matrix, we don't
+ // believe that it's italic.
+ FcValue matrix;
+ const bool have_matrix = FcPatternGet(font, FC_MATRIX, 0, &matrix) == 0;
+
+ // If we ask for an italic font, fontconfig might take a roman font and set
+ // FC_EMBOLDEN.
+ FcValue embolden;
+ const bool have_embolden = FcPatternGet(font, FC_EMBOLDEN, 0, &embolden) == 0;
+
+ int styleBits = 0;
+ if (resulting_bold > FC_WEIGHT_MEDIUM && !have_embolden) {
+ styleBits |= SkTypeface::kBold;
+ }
+ if (resulting_italic > FC_SLANT_ROMAN && !have_matrix) {
+ styleBits |= SkTypeface::kItalic;
+ }
+
+ *font_family = reinterpret_cast<char*>(c_family);
+ *style = (SkTypeface::Style)styleBits;
+ return true;
+}
+
+} // anonymous namespace
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define kMaxFontFamilyLength 1024
+
+SkFontConfigInterfaceDirect::SkFontConfigInterfaceDirect() : next_file_id_(0) {
+ FcInit();
+}
+
+SkFontConfigInterfaceDirect::~SkFontConfigInterfaceDirect() {
+}
+
+bool SkFontConfigInterfaceDirect::match(const char familyName[],
+ SkTypeface::Style style,
+ unsigned* result_filefaceid,
+ SkTypeface::Style* result_style) {
+ if (NULL == familyName) {
+ familyName = "sans-serif";
+ }
+ size_t familyLen = strlen(familyName);
+ if (familyLen > kMaxFontFamilyLength) {
+ return false;
+ }
+
+ SkAutoMutexAcquire ac(mutex_);
+
+ // search our cache
+ {
+ FontMatchKey key = FontMatchKey(familyName, style);
+ const std::map<FontMatchKey, FontMatch>::const_iterator i =
+ font_match_cache_.find(key);
+ if (i != font_match_cache_.end()) {
+ *result_style = i->second.style;
+ *result_filefaceid = i->second.filefaceid;
+ return true;
+ }
+ }
+
+ FcPattern* pattern = FcPatternCreate();
+
+ FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
+ FcPatternAddInteger(pattern, FC_WEIGHT,
+ (style & SkTypeface::kBold) ? FC_WEIGHT_BOLD
+ : FC_WEIGHT_NORMAL);
+ FcPatternAddInteger(pattern, FC_SLANT,
+ (style & SkTypeface::kItalic) ? FC_SLANT_ITALIC
+ : FC_SLANT_ROMAN);
+ FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
+
+ FcConfigSubstitute(NULL, pattern, FcMatchPattern);
+ FcDefaultSubstitute(pattern);
+
+ // Font matching:
+ // CSS often specifies a fallback list of families:
+ // font-family: a, b, c, serif;
+ // However, fontconfig will always do its best to find *a* font when asked
+ // for something so we need a way to tell if the match which it has found is
+ // "good enough" for us. Otherwise, we can return NULL which gets piped up
+ // and lets WebKit know to try the next CSS family name. However, fontconfig
+ // configs allow substitutions (mapping "Arial -> Helvetica" etc) and we
+ // wish to support that.
+ //
+ // Thus, if a specific family is requested we set @family_requested. Then we
+ // record two strings: the family name after config processing and the
+ // family name after resolving. If the two are equal, it's a good match.
+ //
+ // So consider the case where a user has mapped Arial to Helvetica in their
+ // config.
+ // requested family: "Arial"
+ // post_config_family: "Helvetica"
+ // post_match_family: "Helvetica"
+ // -> good match
+ //
+ // and for a missing font:
+ // requested family: "Monaco"
+ // post_config_family: "Monaco"
+ // post_match_family: "Times New Roman"
+ // -> BAD match
+ //
+ // However, we special-case fallback fonts; see IsFallbackFontAllowed().
+ FcChar8* post_config_family;
+ FcPatternGetString(pattern, FC_FAMILY, 0, &post_config_family);
+
+ FcResult result;
+ FcFontSet* font_set = FcFontSort(0, pattern, 0, 0, &result);
+ if (!font_set) {
+ FcPatternDestroy(pattern);
+ return false;
+ }
+
+ FcPattern* match = MatchFont(font_set, post_config_family, familyName);
+ if (!match) {
+ FcPatternDestroy(pattern);
+ FcFontSetDestroy(font_set);
+ return false;
+ }
+
+ FcPatternDestroy(pattern);
+
+ FcChar8* c_filename;
+ if (FcPatternGetString(match, FC_FILE, 0, &c_filename) != FcResultMatch) {
+ FcFontSetDestroy(font_set);
+ return false;
+ }
+ int face_index;
+ if (FcPatternGetInteger(match, FC_INDEX, 0, &face_index) != FcResultMatch) {
+ FcFontSetDestroy(font_set);
+ return false;
+ }
+
+ FontMatch font_match;
+ {
+ unsigned out_fileid;
+ const std::string filename(reinterpret_cast<char*>(c_filename));
+ const std::map<std::string, unsigned>::const_iterator
+ i = filename_to_fileid_.find(filename);
+ if (i == filename_to_fileid_.end()) {
+ out_fileid = next_file_id_++;
+ filename_to_fileid_[filename] = out_fileid;
+ fileid_to_filename_[out_fileid] = filename;
+ } else {
+ out_fileid = i->second;
+ }
+ // fileid stored in filename_to_fileid_ and fileid_to_filename_ is
+ // unique only up to the font file. We have to encode face_index for
+ // the out param.
+ font_match.filefaceid =
+ FileIdAndFaceIndexToFileFaceId(out_fileid, face_index);
+ }
+
+ bool success = GetFontProperties(match,
+ &font_match.family,
+ &font_match.style);
+ FcFontSetDestroy(font_set);
+
+ if (success) {
+ font_match_cache_[FontMatchKey(familyName, style)] = font_match;
+ *result_filefaceid = font_match.filefaceid;
+ *result_style = font_match.style;
+ }
+
+ return success;
+}
+
+bool SkFontConfigInterfaceDirect::getFamilyName(unsigned filefaceid,
+ SkString* result_family) {
+ SkAutoMutexAcquire ac(mutex_);
+
+ FcPattern* pattern = FcPatternCreate();
+
+ {
+ const std::map<unsigned, std::string>::const_iterator
+ i = fileid_to_filename_.find(FileFaceIdToFileId(filefaceid));
+ if (i == fileid_to_filename_.end()) {
+ FcPatternDestroy(pattern);
+ return false;
+ }
+ int face_index = filefaceid & 0xfu;
+ FcPatternAddString(pattern, FC_FILE,
+ reinterpret_cast<const FcChar8*>(i->second.c_str()));
+ // face_index is added only when family is empty because it is not
+ // necessary to uniquiely identify a font if both file and
+ // family are given.
+ FcPatternAddInteger(pattern, FC_INDEX, face_index);
+ }
+
+ FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
+
+ FcConfigSubstitute(NULL, pattern, FcMatchPattern);
+ FcDefaultSubstitute(pattern);
+
+ // Font matching:
+ // CSS often specifies a fallback list of families:
+ // font-family: a, b, c, serif;
+ // However, fontconfig will always do its best to find *a* font when asked
+ // for something so we need a way to tell if the match which it has found is
+ // "good enough" for us. Otherwise, we can return NULL which gets piped up
+ // and lets WebKit know to try the next CSS family name. However, fontconfig
+ // configs allow substitutions (mapping "Arial -> Helvetica" etc) and we
+ // wish to support that.
+ //
+ // Thus, if a specific family is requested we set @family_requested. Then we
+ // record two strings: the family name after config processing and the
+ // family name after resolving. If the two are equal, it's a good match.
+ //
+ // So consider the case where a user has mapped Arial to Helvetica in their
+ // config.
+ // requested family: "Arial"
+ // post_config_family: "Helvetica"
+ // post_match_family: "Helvetica"
+ // -> good match
+ //
+ // and for a missing font:
+ // requested family: "Monaco"
+ // post_config_family: "Monaco"
+ // post_match_family: "Times New Roman"
+ // -> BAD match
+ //
+ // However, we special-case fallback fonts; see IsFallbackFontAllowed().
+ FcChar8* post_config_family;
+ FcPatternGetString(pattern, FC_FAMILY, 0, &post_config_family);
+SkDebugf("--- post_config_family <%s>\n", post_config_family);
+ FcResult result;
+ FcFontSet* font_set = FcFontSort(0, pattern, 0, 0, &result);
+ if (!font_set) {
+ FcPatternDestroy(pattern);
+ return false;
+ }
+
+ FcPattern* match = MatchFont(font_set, post_config_family, (const char*)post_config_family);
+ if (!match) {
+ FcPatternDestroy(pattern);
+ FcFontSetDestroy(font_set);
+ return false;
+ }
+
+ FcPatternDestroy(pattern);
+
+ FontMatch font_match;
+ font_match.filefaceid = filefaceid;
+
+ bool success = GetFontProperties(match,
+ &font_match.family,
+ &font_match.style);
+ FcFontSetDestroy(font_set);
+
+ if (success) {
+SkDebugf("--- font_match.family <%s>\n", font_match.family.c_str());
+ result_family->set(font_match.family.c_str());
+ }
+
+ return success;
+}
+
+SkStream* SkFontConfigInterfaceDirect::openStream(unsigned filefaceid) {
+ SkAutoMutexAcquire ac(mutex_);
+ const std::map<unsigned, std::string>::const_iterator
+ i = fileid_to_filename_.find(FileFaceIdToFileId(filefaceid));
+ if (i == fileid_to_filename_.end()) {
+ return NULL;
+ }
+ int fd = open(i->second.c_str(), O_RDONLY);
+ return (fd >= 0) ? SkNEW_ARGS(SkFDStream, (fd, true)) : NULL;
+}
+
+