Use IDWriteFontFallback when available.

src/ports/SkFontMgr_win_dw.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDWrite.h"
 #include "SkDWriteFontFileStream.h"
 #include "SkFontMgr.h"
 #include "SkHRESULT.h"
 #include "SkStream.h"
 #include "SkTScopedComPtr.h"
 #include "SkThread.h"
 #include "SkTypeface.h"
 #include "SkTypefaceCache.h"
 #include "SkTypeface_win_dw.h"
 #include "SkTypes.h"
 #include "SkUtils.h"
 
 #include <dwrite.h>
 
+#if SK_HAS_DWRITE_2_H
+#include <dwrite_2.h>
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 
 class StreamFontFileLoader : public IDWriteFontFileLoader {
 public:
     // IUnknown methods
     virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void** ppvObject);
     virtual ULONG STDMETHODCALLTYPE AddRef();
     virtual ULONG STDMETHODCALLTYPE Release();
 
     // IDWriteFontFileLoader methods
@@ skipping 222 matching lines @@
 
 class SkFontMgr_DirectWrite : public SkFontMgr {
 public:
     /** localeNameLength must include the null terminator. */
     SkFontMgr_DirectWrite(IDWriteFactory* factory, IDWriteFontCollection* fontCollection,
                           WCHAR* localeName, int localeNameLength)
         : fFactory(SkRefComPtr(factory))
         , fFontCollection(SkRefComPtr(fontCollection))
         , fLocaleName(localeNameLength)
     {
+#ifdef SK_HAS_DWRITE_2_H
+        if (!SUCCEEDED(fFactory->QueryInterface(&fFactory2))) {
+            // IUnknown::QueryInterface states that if it fails, punk will be set to NULL.
+            // http://blogs.msdn.com/b/oldnewthing/archive/2004/03/26/96777.aspx
+            SK_ALWAYSBREAK(NULL == fFactory2.get());
+        }
+#endif
         memcpy(fLocaleName.get(), localeName, localeNameLength * sizeof(WCHAR));
     }
 
 protected:
     int onCountFamilies() const SK_OVERRIDE;
     void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE;
     SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE;
     SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE;
     virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
                                            const SkFontStyle& fontstyle) const SK_OVERRIDE;
@@ skipping 11 matching lines @@
 private:
     HRESULT getByFamilyName(const WCHAR familyName[], IDWriteFontFamily** fontFamily) const;
     HRESULT getDefaultFontFamily(IDWriteFontFamily** fontFamily) const;
 
     /** Creates a typeface using a typeface cache. */
     SkTypeface* createTypefaceFromDWriteFont(IDWriteFontFace* fontFace,
                                              IDWriteFont* font,
                                              IDWriteFontFamily* fontFamily) const;
 
     SkTScopedComPtr<IDWriteFactory> fFactory;
+#ifdef SK_HAS_DWRITE_2_H
+    SkTScopedComPtr<IDWriteFactory2> fFactory2;
+#endif
     SkTScopedComPtr<IDWriteFontCollection> fFontCollection;
     SkSMallocWCHAR fLocaleName;
     mutable SkMutex fTFCacheMutex;
     mutable SkTypefaceCache fTFCache;
 
     friend class SkFontStyleSet_DirectWrite;
     friend class FontFallbackRenderer;
 };
 
 class SkFontStyleSet_DirectWrite : public SkFontStyleSet {
@@ skipping 280 matching lines @@
     }
 
     ULONG STDMETHODCALLTYPE Release() SK_OVERRIDE {
         ULONG newCount = InterlockedDecrement(&fRefCount);
         if (0 == newCount) {
             delete this;
         }
         return newCount;
     }
 
-    virtual HRESULT STDMETHODCALLTYPE QueryInterface(
-        IID const& riid, void** ppvObject) SK_OVERRIDE
-    {
+    virtual HRESULT STDMETHODCALLTYPE QueryInterface(IID const& riid, void** ppvObject) SK_OVERRIDE{
         if (__uuidof(IUnknown) == riid ||
             __uuidof(IDWritePixelSnapping) == riid ||
             __uuidof(IDWriteTextRenderer) == riid)
         {
             *ppvObject = this;
             this->AddRef();
             return S_OK;
         }
         *ppvObject = NULL;
         return E_FAIL;
@@ skipping 16 matching lines @@
     }
 
     size_t len = wcsnlen_s(metrics.lfMessageFont.lfFaceName, LF_FACESIZE) + 1;
     if (0 != wcsncpy_s(name->reset(len), len, metrics.lfMessageFont.lfFaceName, _TRUNCATE)) {
         return E_UNEXPECTED;
     }
 
     return S_OK;
 }
 
+class FontFallbackSource : public IDWriteTextAnalysisSource {
+public:
+    FontFallbackSource(const WCHAR* string, UINT32 length, const WCHAR* locale,
+                       IDWriteNumberSubstitution* numberSubstitution)
+        : fString(string)
+        , fLength(length)
+        , fLocale(locale)
+        , fNumberSubstitution(numberSubstitution)
+    { }
+
+    virtual ~FontFallbackSource() { }
+
+    // IDWriteTextAnalysisSource methods
+    virtual HRESULT STDMETHODCALLTYPE GetTextAtPosition(
+        UINT32 textPosition,
+        WCHAR const** textString,
+        UINT32* textLength) SK_OVERRIDE
+    {
+        if (fLength <= textPosition) {
+            *textString = NULL;
+            *textLength = 0;
+            return S_OK;
+        }
+        *textString = fString + textPosition;
+        *textLength = fLength - textPosition;
+        return S_OK;
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE GetTextBeforePosition(
+        UINT32 textPosition,
+        WCHAR const** textString,
+        UINT32* textLength) SK_OVERRIDE
+    {
+        if (textPosition < 1 || fLength <= textPosition) {
+            *textString = NULL;
+            *textLength = 0;
+            return S_OK;
+        }
+        *textString = fString;
+        *textLength = textPosition;
+        return S_OK;
+    }
+
+    virtual DWRITE_READING_DIRECTION STDMETHODCALLTYPE GetParagraphReadingDirection() SK_OVERRIDE {
+        // TODO: this is also interesting.
+        return DWRITE_READING_DIRECTION_LEFT_TO_RIGHT;
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE GetLocaleName(
+        UINT32 textPosition,
+        UINT32* textLength,
+        WCHAR const** localeName) SK_OVERRIDE
+    {
+        *localeName = fLocale;
+        return S_OK;
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE GetNumberSubstitution(
+        UINT32 textPosition,
+        UINT32* textLength,
+        IDWriteNumberSubstitution** numberSubstitution) SK_OVERRIDE
+    {
+        *numberSubstitution = fNumberSubstitution;
+        return S_OK;
+    }
+
+    // IUnknown methods
+    ULONG STDMETHODCALLTYPE AddRef() SK_OVERRIDE {
+        return InterlockedIncrement(&fRefCount);
+    }
+
+    ULONG STDMETHODCALLTYPE Release() SK_OVERRIDE {
+        ULONG newCount = InterlockedDecrement(&fRefCount);
+        if (0 == newCount) {
+            delete this;
+        }
+        return newCount;
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE QueryInterface(IID const& riid, void** ppvObject) SK_OVERRIDE{
+        if (__uuidof(IUnknown) == riid ||
+            __uuidof(IDWriteTextAnalysisSource) == riid)
+        {
+            *ppvObject = this;
+            this->AddRef();
+            return S_OK;
+        }
+        *ppvObject = NULL;
+        return E_FAIL;
+    }
+
+protected:
+    ULONG fRefCount;
+    const WCHAR* fString;
+    UINT32 fLength;
+    const WCHAR* fLocale;
+    IDWriteNumberSubstitution* fNumberSubstitution;
+};
+
 SkTypeface* SkFontMgr_DirectWrite::onMatchFamilyStyleCharacter(const char familyName[],
                                                                const SkFontStyle& style,
                                                                const char* bcp47[], int bcp47Count,
                                                                SkUnichar character) const
 {
-    // TODO: use IDWriteFactory2::GetSystemFontFallback when available.
-
     const DWriteStyle dwStyle(style);
 
     SkSMallocWCHAR dwFamilyName;
     if (NULL == familyName) {
         HRN(getDefaultFontFamilyName(&dwFamilyName));
     } else {
         HRN(sk_cstring_to_wchar(familyName, &dwFamilyName));
     }
 
+    WCHAR str[16];
+    UINT32 strLen = static_cast<UINT32>(
+        SkUTF16_FromUnichar(character, reinterpret_cast<uint16_t*>(str)));
+
     const SkSMallocWCHAR* dwBcp47;
     SkSMallocWCHAR dwBcp47Local;
     if (bcp47Count < 1) {
         dwBcp47 = &fLocaleName;
     } else {
         // TODO: support fallback stack.
         // TODO: DirectWrite supports 'zh-CN' or 'zh-Hans', but 'zh' misses completely
         // and may produce a Japanese font.
         HRN(sk_cstring_to_wchar(bcp47[bcp47Count - 1], &dwBcp47Local));
         dwBcp47 = &dwBcp47Local;
     }
 
+#if SK_HAS_DWRITE_2_H
+    if (fFactory2.get()) {
+        SkTScopedComPtr<IDWriteFontFallback> fontFallback;
+        HRNM(fFactory2->GetSystemFontFallback(&fontFallback), "Could not get system fallback.");
+
+        SkTScopedComPtr<IDWriteNumberSubstitution> numberSubstitution;
+        HRNM(fFactory2->CreateNumberSubstitution(DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE, NULL, TRUE,
+                                                 &numberSubstitution),
+             "Could not create number substitution.");
+        SkTScopedComPtr<FontFallbackSource> fontFallbackSource(
+            new FontFallbackSource(str, strLen, *dwBcp47, numberSubstitution.get()));
+
+        UINT32 mappedLength;
+        SkTScopedComPtr<IDWriteFont> font;
+        FLOAT scale;
+        HRNM(fontFallback->MapCharacters(fontFallbackSource.get(),
+                                         0, // textPosition,
+                                         strLen,
+                                         fFontCollection.get(),
+                                         dwFamilyName,
+                                         dwStyle.fWeight,
+                                         dwStyle.fSlant,
+                                         dwStyle.fWidth,
+                                         &mappedLength,
+                                         &font,
+                                         &scale),
+             "Could not map characters");
+        if (!font.get()) {
+            return NULL;
+        }
+
+        SkTScopedComPtr<IDWriteFontFace> fontFace;
+        HRNM(font->CreateFontFace(&fontFace), "Could not get font face from font.");
+
+        SkTScopedComPtr<IDWriteFontFamily> fontFamily;
+        HRNM(font->GetFontFamily(&fontFamily), "Could not get family from font.");
+        return this->createTypefaceFromDWriteFont(fontFace.get(), font.get(), fontFamily.get());
+    }
+#else
+#  pragma message("No dwrite_2.h is available, font fallback may be affected.")
+#endif
+
     SkTScopedComPtr<IDWriteTextFormat> fallbackFormat;
     HRNM(fFactory->CreateTextFormat(dwFamilyName,
                                     fFontCollection.get(),
                                     dwStyle.fWeight,
                                     dwStyle.fSlant,
                                     dwStyle.fWidth,
                                     72.0f,
                                     *dwBcp47,
                                     &fallbackFormat),
          "Could not create text format.");
 
-    WCHAR str[16];
-    UINT32 strLen = static_cast<UINT32>(
-        SkUTF16_FromUnichar(character, reinterpret_cast<uint16_t*>(str)));
     SkTScopedComPtr<IDWriteTextLayout> fallbackLayout;
     HRNM(fFactory->CreateTextLayout(str, strLen, fallbackFormat.get(),
                                     200.0f, 200.0f,
                                     &fallbackLayout),
          "Could not create text layout.");
 
     SkTScopedComPtr<FontFallbackRenderer> fontFallbackRenderer(
         new FontFallbackRenderer(this, character));
 
     HRNM(fallbackLayout->Draw(NULL, fontFallbackRenderer.get(), 50.0f, 50.0f),
@@ skipping 273 matching lines @@
 }
 
 #include "SkFontMgr_indirect.h"
 SK_API SkFontMgr* SkFontMgr_New_DirectWriteRenderer(SkRemotableFontMgr* proxy) {
     SkAutoTUnref<SkFontMgr> impl(SkFontMgr_New_DirectWrite());
     if (impl.get() == NULL) {
         return NULL;
     }
     return SkNEW_ARGS(SkFontMgr_Indirect, (impl.get(), proxy));
 }