Lookup glyphs based on character code and language tag.

gm/fontmgr.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 #include "SkCanvas.h"
 #include "SkFontMgr.h"
 #include "SkGraphics.h"
 #include "SkTypeface.h"
 
 #ifdef SK_BUILD_FOR_WIN
     #include "SkTypeface_win.h"
 #endif
 
 // limit this just so we don't take too long to draw
 #define MAX_FAMILIES    30
 
 static SkScalar drawString(SkCanvas* canvas, const SkString& text, SkScalar x,
                            SkScalar y, const SkPaint& paint) {
     canvas->drawText(text.c_str(), text.size(), x, y, paint);
     return x + paint.measureText(text.c_str(), text.size());
 }
 
+static SkScalar drawCharacter(SkCanvas* canvas, uint32_t character, SkScalar x,
+                              SkScalar y, SkPaint& paint, SkFontMgr* fm,
+                              const char* fontName, const char* bpc47,
+                              const SkFontStyle& fontStyle) {
+    // find typeface containing the requested character and draw it
+    SkString ch;
+    ch.appendUnichar(character);
+    SkTypeface* typeface = fm->matchFamilyStyleCharacter(fontName, fontStyle, bpc47, character);
+    SkSafeUnref(paint.setTypeface(typeface));
+    x = drawString(canvas, ch, x, y, paint) + 20;

[tomhudson, 2014/08/21 20:24:41]

Assuming character width << 20?

+
+    // repeat the process, but this time use the family name of the typeface
+    // from the first pass.  This emulates the behavior in Blink where it
+    // it expects to get the same glyph when following this pattern.
+    SkString familyName;
+    typeface->getFamilyName(&familyName);

[bungeman-skia, 2014/08/26 21:15:44]

'typeface' can be NULL here if 'matchFamilyStyleCharacter' returns NULL, which
it will if there is no typeface with the given character (or if it isn't yet
implemented). I think that if 'matchFamilyStyleCharacter' returns NULL above, we
might just want to draw nothing (just return at that point). This will also move
any rebaselining effort to whoever actually implements
'matchFamilyStyleCharacter' on other platforms.

+    SkTypeface* typefaceCopy = fm->legacyCreateTypeface(familyName.c_str(), SkTypeface::kNormal);

[bungeman-skia, 2014/08/26 21:55:35]

Instead of 'SkTypeface::kNormal', you might want to use 'typeface->style()'.

+    SkSafeUnref(paint.setTypeface(typefaceCopy));
+    return drawString(canvas, ch, x, y, paint) + 20;
+}
+
 class FontMgrGM : public skiagm::GM {
 public:
     FontMgrGM(SkFontMgr* fontMgr = NULL) {
         SkGraphics::SetFontCacheLimit(16 * 1024 * 1024);
 
         fName.set("fontmgr_iter");
         if (fontMgr) {
             fName.append("_factory");
             fFM.reset(fontMgr);
         } else {
             fFM.reset(SkFontMgr::RefDefault());
         }
     }
 
 protected:
     virtual SkString onShortName() {
         return fName;
     }
 
     virtual SkISize onISize() {
-        return SkISize::Make(640, 1024);
+        return SkISize::Make(1536, 768);
     }
 
     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
         SkScalar y = 20;
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setLCDRenderText(true);
         paint.setSubpixelText(true);
         paint.setTextSize(17);
 
@@ skipping 10 matching lines @@
 
             SkAutoTUnref<SkFontStyleSet> set(fm->createStyleSet(i));
             for (int j = 0; j < set->count(); ++j) {
                 SkString sname;
                 SkFontStyle fs;
                 set->getStyle(j, &fs, &sname);
                 sname.appendf(" [%d %d %d]", fs.weight(), fs.width(), fs.isItalic());
 
                 SkSafeUnref(paint.setTypeface(set->createTypeface(j)));
                 x = drawString(canvas, sname, x, y, paint) + 20;
+
+                // check to see that we get different glyphs in japanese and chinese
+                x = drawCharacter(canvas, 0x5203, x, y, paint, fm, fName.c_str(), "zh", fs);
+                x = drawCharacter(canvas, 0x5203, x, y, paint, fm, fName.c_str(), "ja", fs);
+                // check that emoji characters are found
+                x = drawCharacter(canvas, 0x1f601, x, y, paint, fm, fName.c_str(), NULL, fs);
             }
             y += 24;
         }
     }
 
     virtual uint32_t onGetFlags() const SK_OVERRIDE {
         // fontdescriptors (and therefore serialization) don't yet understand
         // these new styles, so skip tests that exercise that for now.
 
         // If certain fonts are picked up (e.g. Microsoft Jhenghei 20MB for Regular, 12MB for Bold),
@@ skipping 102 matching lines @@
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 DEF_GM( return SkNEW(FontMgrGM); )
 DEF_GM( return SkNEW(FontMgrMatchGM); )
 
 #ifdef SK_BUILD_FOR_WIN
     DEF_GM( return SkNEW_ARGS(FontMgrGM, (SkFontMgr_New_DirectWrite())); )
 #endif