FYI, Language parameter on Android

src/ports/SkFontConfigInterface_android.cpp

 
 /*
  * Copyright 2013 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkFontConfigInterface.h"
 #include "SkTypeface_android.h"
@@ skipping 50 matching lines @@
 
 struct FamilyRec {
     FamilyRec() {
         memset(fFontRecID, INVALID_FONT_REC_ID, sizeof(fFontRecID));
     }
 
     static const int FONT_STYLE_COUNT = 4;
     FontRecID fFontRecID[FONT_STYLE_COUNT];
     bool fIsFallbackFont;
     SkPaintOptionsAndroid fPaintOptions;
+    // To allow fallback fonts to be identified by family names.
+    SkString fPseudoFamilyName;
 };
 
 
 typedef SkTDArray<FamilyRecID> FallbackFontList;
 
 class SkFontConfigInterfaceAndroid : public SkFontConfigInterface {
 public:
     SkFontConfigInterfaceAndroid(SkTDArray<FontFamily*>& fontFamilies);
     virtual ~SkFontConfigInterfaceAndroid();
 
@@ skipping 107 matching lines @@
                  "multiple families. skipping subsequent occurrences", tolc.lc());
     } else {
         familyNameDict.set(tolc.lc(), familyRecID);
     }
 }
 
 // Defined in SkFontHost_FreeType.cpp
 bool find_name_and_attributes(SkStream* stream, SkString* name,
                               SkTypeface::Style* style, bool* isFixedWidth);
 
+static void setPseudoFamilyName(FamilyRecID familyRecID, FamilyRec* familyRec) {
+    SkString pseudoFamilyName("##");
+    pseudoFamilyName.appendHex(static_cast<uint32_t>(familyRecID) ^ reinterpret_cast<uint32_t>(familyRec));
+    familyRec->fPseudoFamilyName = pseudoFamilyName;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontConfigInterfaceAndroid::SkFontConfigInterfaceAndroid(SkTDArray<FontFamily*>& fontFamilies) :
         fFonts(fontFamilies.count()),
         fFontFamilies(fontFamilies.count() / FamilyRec::FONT_STYLE_COUNT),
         fFamilyNameDict(1024),
         fDefaultFamilyRecID(INVALID_FAMILY_REC_ID),
         fFallbackFontDict(128),
         fFallbackFontAliasDict(128),
         fLocaleFallbackFontList(NULL) {
@@ skipping 51 matching lines @@
                 familyRec = &fFontFamilies.push_back();
                 familyRecID = fFontFamilies.count() - 1;
                 fontRec.fFamilyRecID = familyRecID;
 
                 familyRec->fIsFallbackFont = family->fIsFallbackFont;
                 familyRec->fPaintOptions = family->fFontFiles[j]->fPaintOptions;
 
                 // if this is a fallback font then add it to the appropriate fallback chains
                 if (familyRec->fIsFallbackFont) {
                     addFallbackFamily(familyRecID);
+                    // create a unique pseudo family name for the fallback family and
+                    // add the fallback font into the name dictionary.  This is needed
+                    // by getFallbackFamilyNameForChar() so that fallback families can be
+                    // requested by the pseudo family names of the fonts they contain.
+                    setPseudoFamilyName(familyRecID, familyRec);
+                    insert_into_name_dict(fFamilyNameDict, familyRec->fPseudoFamilyName.c_str(), familyRecID);
                 }
             } else if (familyRec->fPaintOptions != family->fFontFiles[j]->fPaintOptions) {
                 SkDebugf("Every font file within a family must have identical"
                          "language and variant attributes");
                 sk_throw();
             }
 
             // add this font to the current familyRec
             if (INVALID_FONT_REC_ID != familyRec->fFontRecID[fontRec.fStyle]) {
                 DEBUG_FONT(("Overwriting familyRec for style[%d] old,new:(%d,%d)",
                             fontRec.fStyle, familyRec->fFontRecID[fontRec.fStyle],
                             fontRecID));
             }
             familyRec->fFontRecID[fontRec.fStyle] = fontRecID;
-
-            // add the fallback file name to the name dictionary.  This is needed
-            // by getFallbackFamilyNameForChar() so that fallback families can be
-            // requested by the filenames of the fonts they contain.
-            if (familyRec && familyRec->fIsFallbackFont) {
-                insert_into_name_dict(fFamilyNameDict, fontRec.fFileName.c_str(), familyRecID);
-            }
         }
 
         // add the names that map to this family to the dictionary for easy lookup
         if (familyRec && !familyRec->fIsFallbackFont) {
             SkTDArray<const char*> names = family->fNames;
             if (names.isEmpty()) {
                 SkDEBUGFAIL("ERROR: non-fallback font with no name");
                 continue;
             }
 
@@ skipping 215 matching lines @@
         // if it is not one of the accepted variants then move to the next family
         int32_t acceptedVariants = SkPaintOptionsAndroid::kDefault_Variant |
                                    SkPaintOptionsAndroid::kElegant_Variant;
         if (!(fFontFamilies[familyRecID].fPaintOptions.getFontVariant() & acceptedVariants)) {
             continue;
         }
 
         FontRecID fontRecID = find_best_style(fFontFamilies[familyRecID], SkTypeface::kNormal);
         SkTypeface* face = this->getTypefaceForFontRec(fontRecID);
 
+        FontRecID fontRecID = find_best_style(familyRec, SkTypeface::kNormal);
+        SkTypeface* face = getTypefaceForFontRec(fontRecID);
+
         SkPaint paint;
         paint.setTypeface(face);
         paint.setTextEncoding(SkPaint::kUTF32_TextEncoding);
 
         uint16_t glyphID;
         paint.textToGlyphs(&uni, sizeof(uni), &glyphID);
         if (glyphID != 0) {
-            name->set(fFonts[fontRecID].fFileName);
+            name->set(familyRec.fPseudoFamilyName);
             return true;
         }
     }
     return false;
 }
 
 SkTypeface* SkFontConfigInterfaceAndroid::getTypefaceForChar(SkUnichar uni,
                                                              SkTypeface::Style style,
                                                              SkPaintOptionsAndroid::FontVariant fontVariant) {
     FontRecID fontRecID = find_best_style(fFontFamilies[fDefaultFamilyRecID], style);
@@ skipping 308 matching lines @@
     return SkCreateTypefaceForScriptNG(getHBScriptFromHBScriptOld(script), style, fontVariant);
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr::Factory() {
     return NULL;
 }