| /* |
| * 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 "src/utils/win/SkDWriteNTDDI_VERSION.h" |
| |
| #include "include/core/SkTypes.h" |
| #if defined(SK_BUILD_FOR_WIN) |
| |
| #include "include/core/SkFontMgr.h" |
| #include "include/core/SkStream.h" |
| #include "include/core/SkTypeface.h" |
| #include "include/core/SkTypes.h" |
| #include "include/private/SkMutex.h" |
| #include "src/core/SkEndian.h" |
| #include "src/core/SkTypefaceCache.h" |
| #include "src/ports/SkTypeface_win_dw.h" |
| #include "src/utils/SkUTF.h" |
| #include "src/utils/win/SkDWrite.h" |
| #include "src/utils/win/SkDWriteFontFileStream.h" |
| #include "src/utils/win/SkHRESULT.h" |
| #include "src/utils/win/SkObjBase.h" |
| #include "src/utils/win/SkTScopedComPtr.h" |
| |
| #include <dwrite.h> |
| #include <dwrite_2.h> |
| #include <dwrite_3.h> |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| class StreamFontFileLoader : public IDWriteFontFileLoader { |
| public: |
| // IUnknown methods |
| SK_STDMETHODIMP QueryInterface(REFIID iid, void** ppvObject) override; |
| SK_STDMETHODIMP_(ULONG) AddRef() override; |
| SK_STDMETHODIMP_(ULONG) Release() override; |
| |
| // IDWriteFontFileLoader methods |
| SK_STDMETHODIMP CreateStreamFromKey( |
| void const* fontFileReferenceKey, |
| UINT32 fontFileReferenceKeySize, |
| IDWriteFontFileStream** fontFileStream) override; |
| |
| // Takes ownership of stream. |
| static HRESULT Create(std::unique_ptr<SkStreamAsset> stream, |
| StreamFontFileLoader** streamFontFileLoader) { |
| *streamFontFileLoader = new StreamFontFileLoader(std::move(stream)); |
| if (nullptr == *streamFontFileLoader) { |
| return E_OUTOFMEMORY; |
| } |
| return S_OK; |
| } |
| |
| private: |
| StreamFontFileLoader(std::unique_ptr<SkStreamAsset> stream) |
| : fStream(std::move(stream)), fRefCount(1) |
| {} |
| virtual ~StreamFontFileLoader() { } |
| |
| std::unique_ptr<SkStreamAsset> fStream; |
| ULONG fRefCount; |
| }; |
| |
| SK_STDMETHODIMP StreamFontFileLoader::QueryInterface(REFIID iid, void** ppvObject) { |
| if (iid == IID_IUnknown || iid == __uuidof(IDWriteFontFileLoader)) { |
| *ppvObject = this; |
| AddRef(); |
| return S_OK; |
| } else { |
| *ppvObject = nullptr; |
| return E_NOINTERFACE; |
| } |
| } |
| |
| SK_STDMETHODIMP_(ULONG) StreamFontFileLoader::AddRef() { |
| return InterlockedIncrement(&fRefCount); |
| } |
| |
| SK_STDMETHODIMP_(ULONG) StreamFontFileLoader::Release() { |
| ULONG newCount = InterlockedDecrement(&fRefCount); |
| if (0 == newCount) { |
| delete this; |
| } |
| return newCount; |
| } |
| |
| SK_STDMETHODIMP StreamFontFileLoader::CreateStreamFromKey( |
| void const* fontFileReferenceKey, |
| UINT32 fontFileReferenceKeySize, |
| IDWriteFontFileStream** fontFileStream) |
| { |
| SkTScopedComPtr<SkDWriteFontFileStreamWrapper> stream; |
| HR(SkDWriteFontFileStreamWrapper::Create(fStream->duplicate().release(), &stream)); |
| *fontFileStream = stream.release(); |
| return S_OK; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| class StreamFontFileEnumerator : public IDWriteFontFileEnumerator { |
| public: |
| // IUnknown methods |
| SK_STDMETHODIMP QueryInterface(REFIID iid, void** ppvObject) override; |
| SK_STDMETHODIMP_(ULONG) AddRef() override; |
| SK_STDMETHODIMP_(ULONG) Release() override; |
| |
| // IDWriteFontFileEnumerator methods |
| SK_STDMETHODIMP MoveNext(BOOL* hasCurrentFile) override; |
| SK_STDMETHODIMP GetCurrentFontFile(IDWriteFontFile** fontFile) override; |
| |
| static HRESULT Create(IDWriteFactory* factory, IDWriteFontFileLoader* fontFileLoader, |
| StreamFontFileEnumerator** streamFontFileEnumerator) { |
| *streamFontFileEnumerator = new StreamFontFileEnumerator(factory, fontFileLoader); |
| if (nullptr == *streamFontFileEnumerator) { |
| return E_OUTOFMEMORY; |
| } |
| return S_OK; |
| } |
| private: |
| StreamFontFileEnumerator(IDWriteFactory* factory, IDWriteFontFileLoader* fontFileLoader); |
| virtual ~StreamFontFileEnumerator() { } |
| |
| ULONG fRefCount; |
| |
| SkTScopedComPtr<IDWriteFactory> fFactory; |
| SkTScopedComPtr<IDWriteFontFile> fCurrentFile; |
| SkTScopedComPtr<IDWriteFontFileLoader> fFontFileLoader; |
| bool fHasNext; |
| }; |
| |
| StreamFontFileEnumerator::StreamFontFileEnumerator(IDWriteFactory* factory, |
| IDWriteFontFileLoader* fontFileLoader) |
| : fRefCount(1) |
| , fFactory(SkRefComPtr(factory)) |
| , fCurrentFile() |
| , fFontFileLoader(SkRefComPtr(fontFileLoader)) |
| , fHasNext(true) |
| { } |
| |
| SK_STDMETHODIMP StreamFontFileEnumerator::QueryInterface(REFIID iid, void** ppvObject) { |
| if (iid == IID_IUnknown || iid == __uuidof(IDWriteFontFileEnumerator)) { |
| *ppvObject = this; |
| AddRef(); |
| return S_OK; |
| } else { |
| *ppvObject = nullptr; |
| return E_NOINTERFACE; |
| } |
| } |
| |
| SK_STDMETHODIMP_(ULONG) StreamFontFileEnumerator::AddRef() { |
| return InterlockedIncrement(&fRefCount); |
| } |
| |
| SK_STDMETHODIMP_(ULONG) StreamFontFileEnumerator::Release() { |
| ULONG newCount = InterlockedDecrement(&fRefCount); |
| if (0 == newCount) { |
| delete this; |
| } |
| return newCount; |
| } |
| |
| SK_STDMETHODIMP StreamFontFileEnumerator::MoveNext(BOOL* hasCurrentFile) { |
| *hasCurrentFile = FALSE; |
| |
| if (!fHasNext) { |
| return S_OK; |
| } |
| fHasNext = false; |
| |
| UINT32 dummy = 0; |
| HR(fFactory->CreateCustomFontFileReference( |
| &dummy, //cannot be nullptr |
| sizeof(dummy), //even if this is 0 |
| fFontFileLoader.get(), |
| &fCurrentFile)); |
| |
| *hasCurrentFile = TRUE; |
| return S_OK; |
| } |
| |
| SK_STDMETHODIMP StreamFontFileEnumerator::GetCurrentFontFile(IDWriteFontFile** fontFile) { |
| if (fCurrentFile.get() == nullptr) { |
| *fontFile = nullptr; |
| return E_FAIL; |
| } |
| |
| *fontFile = SkRefComPtr(fCurrentFile.get()); |
| return S_OK; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| class StreamFontCollectionLoader : public IDWriteFontCollectionLoader { |
| public: |
| // IUnknown methods |
| SK_STDMETHODIMP QueryInterface(REFIID iid, void** ppvObject) override; |
| SK_STDMETHODIMP_(ULONG) AddRef() override; |
| SK_STDMETHODIMP_(ULONG) Release() override; |
| |
| // IDWriteFontCollectionLoader methods |
| SK_STDMETHODIMP CreateEnumeratorFromKey( |
| IDWriteFactory* factory, |
| void const* collectionKey, |
| UINT32 collectionKeySize, |
| IDWriteFontFileEnumerator** fontFileEnumerator) override; |
| |
| static HRESULT Create(IDWriteFontFileLoader* fontFileLoader, |
| StreamFontCollectionLoader** streamFontCollectionLoader) { |
| *streamFontCollectionLoader = new StreamFontCollectionLoader(fontFileLoader); |
| if (nullptr == *streamFontCollectionLoader) { |
| return E_OUTOFMEMORY; |
| } |
| return S_OK; |
| } |
| private: |
| StreamFontCollectionLoader(IDWriteFontFileLoader* fontFileLoader) |
| : fRefCount(1) |
| , fFontFileLoader(SkRefComPtr(fontFileLoader)) |
| { } |
| virtual ~StreamFontCollectionLoader() { } |
| |
| ULONG fRefCount; |
| SkTScopedComPtr<IDWriteFontFileLoader> fFontFileLoader; |
| }; |
| |
| SK_STDMETHODIMP StreamFontCollectionLoader::QueryInterface(REFIID iid, void** ppvObject) { |
| if (iid == IID_IUnknown || iid == __uuidof(IDWriteFontCollectionLoader)) { |
| *ppvObject = this; |
| AddRef(); |
| return S_OK; |
| } else { |
| *ppvObject = nullptr; |
| return E_NOINTERFACE; |
| } |
| } |
| |
| SK_STDMETHODIMP_(ULONG) StreamFontCollectionLoader::AddRef() { |
| return InterlockedIncrement(&fRefCount); |
| } |
| |
| SK_STDMETHODIMP_(ULONG) StreamFontCollectionLoader::Release() { |
| ULONG newCount = InterlockedDecrement(&fRefCount); |
| if (0 == newCount) { |
| delete this; |
| } |
| return newCount; |
| } |
| |
| SK_STDMETHODIMP StreamFontCollectionLoader::CreateEnumeratorFromKey( |
| IDWriteFactory* factory, |
| void const* collectionKey, |
| UINT32 collectionKeySize, |
| IDWriteFontFileEnumerator** fontFileEnumerator) |
| { |
| SkTScopedComPtr<StreamFontFileEnumerator> enumerator; |
| HR(StreamFontFileEnumerator::Create(factory, fFontFileLoader.get(), &enumerator)); |
| *fontFileEnumerator = enumerator.release(); |
| return S_OK; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| class SkFontMgr_DirectWrite : public SkFontMgr { |
| public: |
| /** localeNameLength and defaultFamilyNameLength must include the null terminator. */ |
| SkFontMgr_DirectWrite(IDWriteFactory* factory, IDWriteFontCollection* fontCollection, |
| IDWriteFontFallback* fallback, |
| const WCHAR* localeName, int localeNameLength, |
| const WCHAR* defaultFamilyName, int defaultFamilyNameLength) |
| : fFactory(SkRefComPtr(factory)) |
| , fFontFallback(SkSafeRefComPtr(fallback)) |
| , fFontCollection(SkRefComPtr(fontCollection)) |
| , fLocaleName(localeNameLength) |
| , fDefaultFamilyName(defaultFamilyNameLength) |
| { |
| memcpy(fLocaleName.get(), localeName, localeNameLength * sizeof(WCHAR)); |
| memcpy(fDefaultFamilyName.get(), defaultFamilyName, defaultFamilyNameLength*sizeof(WCHAR)); |
| } |
| |
| protected: |
| int onCountFamilies() const override; |
| void onGetFamilyName(int index, SkString* familyName) const override; |
| SkFontStyleSet* onCreateStyleSet(int index) const override; |
| SkFontStyleSet* onMatchFamily(const char familyName[]) const override; |
| SkTypeface* onMatchFamilyStyle(const char familyName[], |
| const SkFontStyle& fontstyle) const override; |
| SkTypeface* onMatchFamilyStyleCharacter(const char familyName[], const SkFontStyle&, |
| const char* bcp47[], int bcp47Count, |
| SkUnichar character) const override; |
| SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember, |
| const SkFontStyle& fontstyle) const override; |
| sk_sp<SkTypeface> onMakeFromStreamIndex(std::unique_ptr<SkStreamAsset>, int ttcIndex) const override; |
| sk_sp<SkTypeface> onMakeFromStreamArgs(std::unique_ptr<SkStreamAsset>, const SkFontArguments&) const override; |
| sk_sp<SkTypeface> onMakeFromData(sk_sp<SkData>, int ttcIndex) const override; |
| sk_sp<SkTypeface> onMakeFromFile(const char path[], int ttcIndex) const override; |
| sk_sp<SkTypeface> onLegacyMakeTypeface(const char familyName[], SkFontStyle) const override; |
| |
| private: |
| HRESULT getByFamilyName(const WCHAR familyName[], IDWriteFontFamily** fontFamily) const; |
| sk_sp<SkTypeface> fallback(const WCHAR* dwFamilyName, DWriteStyle, |
| const WCHAR* dwBcp47, UINT32 character) const; |
| sk_sp<SkTypeface> layoutFallback(const WCHAR* dwFamilyName, DWriteStyle, |
| const WCHAR* dwBcp47, UINT32 character) const; |
| |
| /** Creates a typeface using a typeface cache. */ |
| sk_sp<SkTypeface> makeTypefaceFromDWriteFont(IDWriteFontFace* fontFace, |
| IDWriteFont* font, |
| IDWriteFontFamily* fontFamily) const; |
| |
| SkTScopedComPtr<IDWriteFactory> fFactory; |
| SkTScopedComPtr<IDWriteFontFallback> fFontFallback; |
| SkTScopedComPtr<IDWriteFontCollection> fFontCollection; |
| SkSMallocWCHAR fLocaleName; |
| SkSMallocWCHAR fDefaultFamilyName; |
| mutable SkMutex fTFCacheMutex; |
| mutable SkTypefaceCache fTFCache; |
| |
| friend class SkFontStyleSet_DirectWrite; |
| friend class FontFallbackRenderer; |
| }; |
| |
| class SkFontStyleSet_DirectWrite : public SkFontStyleSet { |
| public: |
| SkFontStyleSet_DirectWrite(const SkFontMgr_DirectWrite* fontMgr, |
| IDWriteFontFamily* fontFamily) |
| : fFontMgr(SkRef(fontMgr)) |
| , fFontFamily(SkRefComPtr(fontFamily)) |
| { } |
| |
| int count() override; |
| void getStyle(int index, SkFontStyle* fs, SkString* styleName) override; |
| SkTypeface* createTypeface(int index) override; |
| SkTypeface* matchStyle(const SkFontStyle& pattern) override; |
| |
| private: |
| sk_sp<const SkFontMgr_DirectWrite> fFontMgr; |
| SkTScopedComPtr<IDWriteFontFamily> fFontFamily; |
| }; |
| |
| static HRESULT are_same(IUnknown* a, IUnknown* b, bool& same) { |
| SkTScopedComPtr<IUnknown> iunkA; |
| HRM(a->QueryInterface(&iunkA), "Failed to QI<IUnknown> for a."); |
| |
| SkTScopedComPtr<IUnknown> iunkB; |
| HRM(b->QueryInterface(&iunkB), "Failed to QI<IUnknown> for b."); |
| |
| same = (iunkA.get() == iunkB.get()); |
| return S_OK; |
| } |
| |
| struct ProtoDWriteTypeface { |
| IDWriteFontFace* fDWriteFontFace; |
| IDWriteFont* fDWriteFont; |
| IDWriteFontFamily* fDWriteFontFamily; |
| }; |
| |
| static bool FindByDWriteFont(SkTypeface* cached, void* ctx) { |
| DWriteFontTypeface* cshFace = reinterpret_cast<DWriteFontTypeface*>(cached); |
| ProtoDWriteTypeface* ctxFace = reinterpret_cast<ProtoDWriteTypeface*>(ctx); |
| |
| // IDWriteFontFace5 introduced both Equals and HasVariations |
| SkTScopedComPtr<IDWriteFontFace5> cshFontFace5; |
| SkTScopedComPtr<IDWriteFontFace5> ctxFontFace5; |
| cshFace->fDWriteFontFace->QueryInterface(&cshFontFace5); |
| ctxFace->fDWriteFontFace->QueryInterface(&ctxFontFace5); |
| if (cshFontFace5 && ctxFontFace5) { |
| return cshFontFace5->Equals(ctxFontFace5.get()); |
| } |
| |
| bool same; |
| |
| //Check to see if the two fonts are identical. |
| HRB(are_same(cshFace->fDWriteFont.get(), ctxFace->fDWriteFont, same)); |
| if (same) { |
| return true; |
| } |
| |
| HRB(are_same(cshFace->fDWriteFontFace.get(), ctxFace->fDWriteFontFace, same)); |
| if (same) { |
| return true; |
| } |
| |
| //Check if the two fonts share the same loader and have the same key. |
| UINT32 cshNumFiles; |
| UINT32 ctxNumFiles; |
| HRB(cshFace->fDWriteFontFace->GetFiles(&cshNumFiles, nullptr)); |
| HRB(ctxFace->fDWriteFontFace->GetFiles(&ctxNumFiles, nullptr)); |
| if (cshNumFiles != ctxNumFiles) { |
| return false; |
| } |
| |
| SkTScopedComPtr<IDWriteFontFile> cshFontFile; |
| SkTScopedComPtr<IDWriteFontFile> ctxFontFile; |
| HRB(cshFace->fDWriteFontFace->GetFiles(&cshNumFiles, &cshFontFile)); |
| HRB(ctxFace->fDWriteFontFace->GetFiles(&ctxNumFiles, &ctxFontFile)); |
| |
| //for (each file) { //we currently only admit fonts from one file. |
| SkTScopedComPtr<IDWriteFontFileLoader> cshFontFileLoader; |
| SkTScopedComPtr<IDWriteFontFileLoader> ctxFontFileLoader; |
| HRB(cshFontFile->GetLoader(&cshFontFileLoader)); |
| HRB(ctxFontFile->GetLoader(&ctxFontFileLoader)); |
| HRB(are_same(cshFontFileLoader.get(), ctxFontFileLoader.get(), same)); |
| if (!same) { |
| return false; |
| } |
| //} |
| |
| const void* cshRefKey; |
| UINT32 cshRefKeySize; |
| const void* ctxRefKey; |
| UINT32 ctxRefKeySize; |
| HRB(cshFontFile->GetReferenceKey(&cshRefKey, &cshRefKeySize)); |
| HRB(ctxFontFile->GetReferenceKey(&ctxRefKey, &ctxRefKeySize)); |
| if (cshRefKeySize != ctxRefKeySize) { |
| return false; |
| } |
| if (0 != memcmp(cshRefKey, ctxRefKey, ctxRefKeySize)) { |
| return false; |
| } |
| |
| //TODO: better means than comparing name strings? |
| //NOTE: .ttc and fake bold/italic will end up here. |
| SkTScopedComPtr<IDWriteLocalizedStrings> cshFamilyNames; |
| SkTScopedComPtr<IDWriteLocalizedStrings> cshFaceNames; |
| HRB(cshFace->fDWriteFontFamily->GetFamilyNames(&cshFamilyNames)); |
| HRB(cshFace->fDWriteFont->GetFaceNames(&cshFaceNames)); |
| UINT32 cshFamilyNameLength; |
| UINT32 cshFaceNameLength; |
| HRB(cshFamilyNames->GetStringLength(0, &cshFamilyNameLength)); |
| HRB(cshFaceNames->GetStringLength(0, &cshFaceNameLength)); |
| |
| SkTScopedComPtr<IDWriteLocalizedStrings> ctxFamilyNames; |
| SkTScopedComPtr<IDWriteLocalizedStrings> ctxFaceNames; |
| HRB(ctxFace->fDWriteFontFamily->GetFamilyNames(&ctxFamilyNames)); |
| HRB(ctxFace->fDWriteFont->GetFaceNames(&ctxFaceNames)); |
| UINT32 ctxFamilyNameLength; |
| UINT32 ctxFaceNameLength; |
| HRB(ctxFamilyNames->GetStringLength(0, &ctxFamilyNameLength)); |
| HRB(ctxFaceNames->GetStringLength(0, &ctxFaceNameLength)); |
| |
| if (cshFamilyNameLength != ctxFamilyNameLength || |
| cshFaceNameLength != ctxFaceNameLength) |
| { |
| return false; |
| } |
| |
| SkSMallocWCHAR cshFamilyName(cshFamilyNameLength+1); |
| SkSMallocWCHAR cshFaceName(cshFaceNameLength+1); |
| HRB(cshFamilyNames->GetString(0, cshFamilyName.get(), cshFamilyNameLength+1)); |
| HRB(cshFaceNames->GetString(0, cshFaceName.get(), cshFaceNameLength+1)); |
| |
| SkSMallocWCHAR ctxFamilyName(ctxFamilyNameLength+1); |
| SkSMallocWCHAR ctxFaceName(ctxFaceNameLength+1); |
| HRB(ctxFamilyNames->GetString(0, ctxFamilyName.get(), ctxFamilyNameLength+1)); |
| HRB(ctxFaceNames->GetString(0, ctxFaceName.get(), ctxFaceNameLength+1)); |
| |
| return wcscmp(cshFamilyName.get(), ctxFamilyName.get()) == 0 && |
| wcscmp(cshFaceName.get(), ctxFaceName.get()) == 0; |
| } |
| |
| sk_sp<SkTypeface> SkFontMgr_DirectWrite::makeTypefaceFromDWriteFont( |
| IDWriteFontFace* fontFace, |
| IDWriteFont* font, |
| IDWriteFontFamily* fontFamily) const { |
| SkAutoMutexExclusive ama(fTFCacheMutex); |
| ProtoDWriteTypeface spec = { fontFace, font, fontFamily }; |
| sk_sp<SkTypeface> face = fTFCache.findByProcAndRef(FindByDWriteFont, &spec); |
| if (nullptr == face) { |
| face = DWriteFontTypeface::Make(fFactory.get(), fontFace, font, fontFamily, nullptr); |
| if (face) { |
| fTFCache.add(face); |
| } |
| } |
| return face; |
| } |
| |
| int SkFontMgr_DirectWrite::onCountFamilies() const { |
| return fFontCollection->GetFontFamilyCount(); |
| } |
| |
| void SkFontMgr_DirectWrite::onGetFamilyName(int index, SkString* familyName) const { |
| SkTScopedComPtr<IDWriteFontFamily> fontFamily; |
| HRVM(fFontCollection->GetFontFamily(index, &fontFamily), "Could not get requested family."); |
| |
| SkTScopedComPtr<IDWriteLocalizedStrings> familyNames; |
| HRVM(fontFamily->GetFamilyNames(&familyNames), "Could not get family names."); |
| |
| sk_get_locale_string(familyNames.get(), fLocaleName.get(), familyName); |
| } |
| |
| SkFontStyleSet* SkFontMgr_DirectWrite::onCreateStyleSet(int index) const { |
| SkTScopedComPtr<IDWriteFontFamily> fontFamily; |
| HRNM(fFontCollection->GetFontFamily(index, &fontFamily), "Could not get requested family."); |
| |
| return new SkFontStyleSet_DirectWrite(this, fontFamily.get()); |
| } |
| |
| SkFontStyleSet* SkFontMgr_DirectWrite::onMatchFamily(const char familyName[]) const { |
| if (!familyName) { |
| return nullptr; |
| } |
| |
| SkSMallocWCHAR dwFamilyName; |
| HRN(sk_cstring_to_wchar(familyName, &dwFamilyName)); |
| |
| UINT32 index; |
| BOOL exists; |
| HRNM(fFontCollection->FindFamilyName(dwFamilyName.get(), &index, &exists), |
| "Failed while finding family by name."); |
| if (!exists) { |
| return nullptr; |
| } |
| |
| return this->onCreateStyleSet(index); |
| } |
| |
| SkTypeface* SkFontMgr_DirectWrite::onMatchFamilyStyle(const char familyName[], |
| const SkFontStyle& fontstyle) const { |
| sk_sp<SkFontStyleSet> sset(this->matchFamily(familyName)); |
| return sset->matchStyle(fontstyle); |
| } |
| |
| class FontFallbackRenderer : public IDWriteTextRenderer { |
| public: |
| FontFallbackRenderer(const SkFontMgr_DirectWrite* outer, UINT32 character) |
| : fRefCount(1), fOuter(SkSafeRef(outer)), fCharacter(character), fResolvedTypeface(nullptr) { |
| } |
| |
| // IUnknown methods |
| SK_STDMETHODIMP QueryInterface(IID const& riid, void** ppvObject) override { |
| if (__uuidof(IUnknown) == riid || |
| __uuidof(IDWritePixelSnapping) == riid || |
| __uuidof(IDWriteTextRenderer) == riid) |
| { |
| *ppvObject = this; |
| this->AddRef(); |
| return S_OK; |
| } |
| *ppvObject = nullptr; |
| return E_FAIL; |
| } |
| |
| SK_STDMETHODIMP_(ULONG) AddRef() override { |
| return InterlockedIncrement(&fRefCount); |
| } |
| |
| SK_STDMETHODIMP_(ULONG) Release() override { |
| ULONG newCount = InterlockedDecrement(&fRefCount); |
| if (0 == newCount) { |
| delete this; |
| } |
| return newCount; |
| } |
| |
| // IDWriteTextRenderer methods |
| SK_STDMETHODIMP DrawGlyphRun( |
| void* clientDrawingContext, |
| FLOAT baselineOriginX, |
| FLOAT baselineOriginY, |
| DWRITE_MEASURING_MODE measuringMode, |
| DWRITE_GLYPH_RUN const* glyphRun, |
| DWRITE_GLYPH_RUN_DESCRIPTION const* glyphRunDescription, |
| IUnknown* clientDrawingEffect) override |
| { |
| if (!glyphRun->fontFace) { |
| HRM(E_INVALIDARG, "Glyph run without font face."); |
| } |
| |
| SkTScopedComPtr<IDWriteFont> font; |
| HRM(fOuter->fFontCollection->GetFontFromFontFace(glyphRun->fontFace, &font), |
| "Could not get font from font face."); |
| |
| // It is possible that the font passed does not actually have the requested character, |
| // due to no font being found and getting the fallback font. |
| // Check that the font actually contains the requested character. |
| BOOL exists; |
| HRM(font->HasCharacter(fCharacter, &exists), "Could not find character."); |
| |
| if (exists) { |
| SkTScopedComPtr<IDWriteFontFamily> fontFamily; |
| HRM(font->GetFontFamily(&fontFamily), "Could not get family."); |
| fResolvedTypeface = fOuter->makeTypefaceFromDWriteFont(glyphRun->fontFace, |
| font.get(), |
| fontFamily.get()); |
| } |
| |
| return S_OK; |
| } |
| |
| SK_STDMETHODIMP DrawUnderline( |
| void* clientDrawingContext, |
| FLOAT baselineOriginX, |
| FLOAT baselineOriginY, |
| DWRITE_UNDERLINE const* underline, |
| IUnknown* clientDrawingEffect) override |
| { return E_NOTIMPL; } |
| |
| SK_STDMETHODIMP DrawStrikethrough( |
| void* clientDrawingContext, |
| FLOAT baselineOriginX, |
| FLOAT baselineOriginY, |
| DWRITE_STRIKETHROUGH const* strikethrough, |
| IUnknown* clientDrawingEffect) override |
| { return E_NOTIMPL; } |
| |
| SK_STDMETHODIMP DrawInlineObject( |
| void* clientDrawingContext, |
| FLOAT originX, |
| FLOAT originY, |
| IDWriteInlineObject* inlineObject, |
| BOOL isSideways, |
| BOOL isRightToLeft, |
| IUnknown* clientDrawingEffect) override |
| { return E_NOTIMPL; } |
| |
| // IDWritePixelSnapping methods |
| SK_STDMETHODIMP IsPixelSnappingDisabled( |
| void* clientDrawingContext, |
| BOOL* isDisabled) override |
| { |
| *isDisabled = FALSE; |
| return S_OK; |
| } |
| |
| SK_STDMETHODIMP GetCurrentTransform( |
| void* clientDrawingContext, |
| DWRITE_MATRIX* transform) override |
| { |
| const DWRITE_MATRIX ident = { 1.0, 0.0, 0.0, 1.0, 0.0, 0.0 }; |
| *transform = ident; |
| return S_OK; |
| } |
| |
| SK_STDMETHODIMP GetPixelsPerDip( |
| void* clientDrawingContext, |
| FLOAT* pixelsPerDip) override |
| { |
| *pixelsPerDip = 1.0f; |
| return S_OK; |
| } |
| |
| sk_sp<SkTypeface> ConsumeFallbackTypeface() { return std::move(fResolvedTypeface); } |
| |
| private: |
| virtual ~FontFallbackRenderer() { } |
| |
| ULONG fRefCount; |
| sk_sp<const SkFontMgr_DirectWrite> fOuter; |
| UINT32 fCharacter; |
| sk_sp<SkTypeface> fResolvedTypeface; |
| }; |
| |
| class FontFallbackSource : public IDWriteTextAnalysisSource { |
| public: |
| FontFallbackSource(const WCHAR* string, UINT32 length, const WCHAR* locale, |
| IDWriteNumberSubstitution* numberSubstitution) |
| : fRefCount(1) |
| , fString(string) |
| , fLength(length) |
| , fLocale(locale) |
| , fNumberSubstitution(numberSubstitution) |
| { } |
| |
| // IUnknown methods |
| SK_STDMETHODIMP QueryInterface(IID const& riid, void** ppvObject) override { |
| if (__uuidof(IUnknown) == riid || |
| __uuidof(IDWriteTextAnalysisSource) == riid) |
| { |
| *ppvObject = this; |
| this->AddRef(); |
| return S_OK; |
| } |
| *ppvObject = nullptr; |
| return E_FAIL; |
| } |
| |
| SK_STDMETHODIMP_(ULONG) AddRef() override { |
| return InterlockedIncrement(&fRefCount); |
| } |
| |
| SK_STDMETHODIMP_(ULONG) Release() override { |
| ULONG newCount = InterlockedDecrement(&fRefCount); |
| if (0 == newCount) { |
| delete this; |
| } |
| return newCount; |
| } |
| |
| // IDWriteTextAnalysisSource methods |
| SK_STDMETHODIMP GetTextAtPosition( |
| UINT32 textPosition, |
| WCHAR const** textString, |
| UINT32* textLength) override |
| { |
| if (fLength <= textPosition) { |
| *textString = nullptr; |
| *textLength = 0; |
| return S_OK; |
| } |
| *textString = fString + textPosition; |
| *textLength = fLength - textPosition; |
| return S_OK; |
| } |
| |
| SK_STDMETHODIMP GetTextBeforePosition( |
| UINT32 textPosition, |
| WCHAR const** textString, |
| UINT32* textLength) override |
| { |
| if (textPosition < 1 || fLength <= textPosition) { |
| *textString = nullptr; |
| *textLength = 0; |
| return S_OK; |
| } |
| *textString = fString; |
| *textLength = textPosition; |
| return S_OK; |
| } |
| |
| SK_STDMETHODIMP_(DWRITE_READING_DIRECTION) GetParagraphReadingDirection() override { |
| // TODO: this is also interesting. |
| return DWRITE_READING_DIRECTION_LEFT_TO_RIGHT; |
| } |
| |
| SK_STDMETHODIMP GetLocaleName( |
| UINT32 textPosition, |
| UINT32* textLength, |
| WCHAR const** localeName) override |
| { |
| *localeName = fLocale; |
| return S_OK; |
| } |
| |
| SK_STDMETHODIMP GetNumberSubstitution( |
| UINT32 textPosition, |
| UINT32* textLength, |
| IDWriteNumberSubstitution** numberSubstitution) override |
| { |
| *numberSubstitution = fNumberSubstitution; |
| return S_OK; |
| } |
| |
| private: |
| virtual ~FontFallbackSource() { } |
| |
| 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 |
| { |
| const DWriteStyle dwStyle(style); |
| |
| const WCHAR* dwFamilyName = nullptr; |
| SkSMallocWCHAR dwFamilyNameLocal; |
| if (familyName) { |
| HRN(sk_cstring_to_wchar(familyName, &dwFamilyNameLocal)); |
| dwFamilyName = dwFamilyNameLocal; |
| } |
| |
| 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 (fFontFallback) { |
| return this->fallback(dwFamilyName, dwStyle, dwBcp47->get(), character).release(); |
| } |
| |
| // LayoutFallback may use the system font collection for fallback. |
| return this->layoutFallback(dwFamilyName, dwStyle, dwBcp47->get(), character).release(); |
| } |
| |
| sk_sp<SkTypeface> SkFontMgr_DirectWrite::fallback(const WCHAR* dwFamilyName, |
| DWriteStyle dwStyle, |
| const WCHAR* dwBcp47, |
| UINT32 character) const |
| { |
| WCHAR str[16]; |
| UINT32 strLen = SkTo<UINT32>(SkUTF::ToUTF16(character, reinterpret_cast<uint16_t*>(str))); |
| |
| if (!fFontFallback) { |
| return nullptr; |
| } |
| |
| SkTScopedComPtr<IDWriteNumberSubstitution> numberSubstitution; |
| HRNM(fFactory->CreateNumberSubstitution(DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE, dwBcp47, |
| 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(fFontFallback->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 nullptr; |
| } |
| |
| 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->makeTypefaceFromDWriteFont(fontFace.get(), font.get(), fontFamily.get()); |
| } |
| |
| sk_sp<SkTypeface> SkFontMgr_DirectWrite::layoutFallback(const WCHAR* dwFamilyName, |
| DWriteStyle dwStyle, |
| const WCHAR* dwBcp47, |
| UINT32 character) const |
| { |
| WCHAR str[16]; |
| UINT32 strLen = SkTo<UINT32>(SkUTF::ToUTF16(character, reinterpret_cast<uint16_t*>(str))); |
| |
| SkTScopedComPtr<IDWriteTextFormat> fallbackFormat; |
| HRNM(fFactory->CreateTextFormat(dwFamilyName ? dwFamilyName : L"", |
| fFontCollection.get(), |
| dwStyle.fWeight, |
| dwStyle.fSlant, |
| dwStyle.fWidth, |
| 72.0f, |
| dwBcp47, |
| &fallbackFormat), |
| "Could not create text format."); |
| |
| // No matter how the font collection is set on this IDWriteTextLayout, it is not possible to |
| // disable use of the system font collection in fallback. |
| 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->SetFontCollection(fFontCollection.get(), { 0, strLen }), |
| "Could not set layout font collection."); |
| HRNM(fallbackLayout->Draw(nullptr, fontFallbackRenderer.get(), 50.0f, 50.0f), |
| "Could not draw layout with renderer."); |
| |
| return fontFallbackRenderer->ConsumeFallbackTypeface(); |
| } |
| |
| SkTypeface* SkFontMgr_DirectWrite::onMatchFaceStyle(const SkTypeface* familyMember, |
| const SkFontStyle& fontstyle) const { |
| SkString familyName; |
| SkFontStyleSet_DirectWrite sset( |
| this, ((DWriteFontTypeface*)familyMember)->fDWriteFontFamily.get() |
| ); |
| return sset.matchStyle(fontstyle); |
| } |
| |
| template <typename T> class SkAutoIDWriteUnregister { |
| public: |
| SkAutoIDWriteUnregister(IDWriteFactory* factory, T* unregister) |
| : fFactory(factory), fUnregister(unregister) |
| { } |
| SkAutoIDWriteUnregister(const SkAutoIDWriteUnregister&) = delete; |
| SkAutoIDWriteUnregister& operator=(const SkAutoIDWriteUnregister&) = delete; |
| SkAutoIDWriteUnregister(SkAutoIDWriteUnregister&&) = delete; |
| SkAutoIDWriteUnregister& operator=(SkAutoIDWriteUnregister&&) = delete; |
| |
| ~SkAutoIDWriteUnregister() { |
| if (fUnregister) { |
| unregister(fFactory, fUnregister); |
| } |
| } |
| |
| T* detatch() { |
| T* old = fUnregister; |
| fUnregister = nullptr; |
| return old; |
| } |
| |
| private: |
| HRESULT unregister(IDWriteFactory* factory, IDWriteFontFileLoader* unregister) { |
| return factory->UnregisterFontFileLoader(unregister); |
| } |
| |
| HRESULT unregister(IDWriteFactory* factory, IDWriteFontCollectionLoader* unregister) { |
| return factory->UnregisterFontCollectionLoader(unregister); |
| } |
| |
| IDWriteFactory* fFactory; |
| T* fUnregister; |
| }; |
| |
| sk_sp<SkTypeface> SkFontMgr_DirectWrite::onMakeFromStreamIndex(std::unique_ptr<SkStreamAsset> stream, |
| int ttcIndex) const { |
| SkTScopedComPtr<StreamFontFileLoader> fontFileLoader; |
| HRN(StreamFontFileLoader::Create(std::move(stream), &fontFileLoader)); |
| HRN(fFactory->RegisterFontFileLoader(fontFileLoader.get())); |
| SkAutoIDWriteUnregister<StreamFontFileLoader> autoUnregisterFontFileLoader( |
| fFactory.get(), fontFileLoader.get()); |
| |
| SkTScopedComPtr<StreamFontCollectionLoader> fontCollectionLoader; |
| HRN(StreamFontCollectionLoader::Create(fontFileLoader.get(), &fontCollectionLoader)); |
| HRN(fFactory->RegisterFontCollectionLoader(fontCollectionLoader.get())); |
| SkAutoIDWriteUnregister<StreamFontCollectionLoader> autoUnregisterFontCollectionLoader( |
| fFactory.get(), fontCollectionLoader.get()); |
| |
| SkTScopedComPtr<IDWriteFontCollection> fontCollection; |
| HRN(fFactory->CreateCustomFontCollection(fontCollectionLoader.get(), nullptr, 0, &fontCollection)); |
| |
| // Find the first non-simulated font which has the given ttc index. |
| UINT32 familyCount = fontCollection->GetFontFamilyCount(); |
| for (UINT32 familyIndex = 0; familyIndex < familyCount; ++familyIndex) { |
| SkTScopedComPtr<IDWriteFontFamily> fontFamily; |
| HRN(fontCollection->GetFontFamily(familyIndex, &fontFamily)); |
| |
| UINT32 fontCount = fontFamily->GetFontCount(); |
| for (UINT32 fontIndex = 0; fontIndex < fontCount; ++fontIndex) { |
| SkTScopedComPtr<IDWriteFont> font; |
| HRN(fontFamily->GetFont(fontIndex, &font)); |
| if (font->GetSimulations() != DWRITE_FONT_SIMULATIONS_NONE) { |
| continue; |
| } |
| |
| SkTScopedComPtr<IDWriteFontFace> fontFace; |
| HRN(font->CreateFontFace(&fontFace)); |
| |
| int faceIndex = fontFace->GetIndex(); |
| if (faceIndex == ttcIndex) { |
| return DWriteFontTypeface::Make(fFactory.get(), |
| fontFace.get(), font.get(), fontFamily.get(), |
| sk_make_sp<DWriteFontTypeface::Loaders>( |
| fFactory.get(), |
| autoUnregisterFontFileLoader.detatch(), |
| autoUnregisterFontCollectionLoader.detatch())); |
| } |
| } |
| } |
| |
| return nullptr; |
| } |
| |
| sk_sp<SkTypeface> SkFontMgr_DirectWrite::onMakeFromStreamArgs(std::unique_ptr<SkStreamAsset> stream, |
| const SkFontArguments& args) const { |
| SkTScopedComPtr<StreamFontFileLoader> fontFileLoader; |
| HRN(StreamFontFileLoader::Create(std::move(stream), &fontFileLoader)); |
| HRN(fFactory->RegisterFontFileLoader(fontFileLoader.get())); |
| SkAutoIDWriteUnregister<StreamFontFileLoader> autoUnregisterFontFileLoader( |
| fFactory.get(), fontFileLoader.get()); |
| |
| SkTScopedComPtr<StreamFontCollectionLoader> fontCollectionLoader; |
| HRN(StreamFontCollectionLoader::Create(fontFileLoader.get(), &fontCollectionLoader)); |
| HRN(fFactory->RegisterFontCollectionLoader(fontCollectionLoader.get())); |
| SkAutoIDWriteUnregister<StreamFontCollectionLoader> autoUnregisterFontCollectionLoader( |
| fFactory.get(), fontCollectionLoader.get()); |
| |
| SkTScopedComPtr<IDWriteFontCollection> fontCollection; |
| HRN(fFactory->CreateCustomFontCollection(fontCollectionLoader.get(), nullptr, 0, |
| &fontCollection)); |
| |
| // Find the first non-simulated font which has the given ttc index. |
| UINT32 familyCount = fontCollection->GetFontFamilyCount(); |
| for (UINT32 familyIndex = 0; familyIndex < familyCount; ++familyIndex) { |
| SkTScopedComPtr<IDWriteFontFamily> fontFamily; |
| HRN(fontCollection->GetFontFamily(familyIndex, &fontFamily)); |
| |
| UINT32 fontCount = fontFamily->GetFontCount(); |
| for (UINT32 fontIndex = 0; fontIndex < fontCount; ++fontIndex) { |
| SkTScopedComPtr<IDWriteFont> font; |
| HRN(fontFamily->GetFont(fontIndex, &font)); |
| |
| // Skip if the current font is simulated |
| if (font->GetSimulations() != DWRITE_FONT_SIMULATIONS_NONE) { |
| continue; |
| } |
| SkTScopedComPtr<IDWriteFontFace> fontFace; |
| HRN(font->CreateFontFace(&fontFace)); |
| int faceIndex = fontFace->GetIndex(); |
| int ttcIndex = args.getCollectionIndex(); |
| |
| // Skip if the current face index does not match the ttcIndex |
| if (faceIndex != ttcIndex) { |
| continue; |
| } |
| |
| #if defined(NTDDI_WIN10_RS3) && NTDDI_VERSION >= NTDDI_WIN10_RS3 |
| |
| SkTScopedComPtr<IDWriteFontFace5> fontFace5; |
| if (SUCCEEDED(fontFace->QueryInterface(&fontFace5)) && fontFace5->HasVariations()) { |
| UINT32 fontAxisCount = fontFace5->GetFontAxisValueCount(); |
| UINT32 argsCoordCount = args.getVariationDesignPosition().coordinateCount; |
| SkAutoSTMalloc<8, DWRITE_FONT_AXIS_VALUE> fontAxisValues(fontAxisCount); |
| SkTScopedComPtr<IDWriteFontResource> fontResource; |
| HRN(fontFace5->GetFontResource(&fontResource)); |
| // Set all axes by default values |
| HRN(fontResource->GetDefaultFontAxisValues(fontAxisValues, fontAxisCount)); |
| |
| for (UINT32 fontIndex = 0; fontIndex < fontAxisCount; ++fontIndex) { |
| for (UINT32 argsIndex = 0; argsIndex < argsCoordCount; ++argsIndex) { |
| if (SkEndian_SwapBE32(fontAxisValues[fontIndex].axisTag) == |
| args.getVariationDesignPosition().coordinates[argsIndex].axis) { |
| fontAxisValues[fontIndex].value = |
| args.getVariationDesignPosition().coordinates[argsIndex].value; |
| } |
| } |
| } |
| |
| SkTScopedComPtr<IDWriteFontFace5> fontFace5_Out; |
| HRN(fontResource->CreateFontFace(DWRITE_FONT_SIMULATIONS_NONE, |
| fontAxisValues.get(), |
| fontAxisCount, |
| &fontFace5_Out)); |
| fontFace.reset(); |
| HRN(fontFace5_Out->QueryInterface(&fontFace)); |
| } |
| |
| #endif |
| |
| return DWriteFontTypeface::Make( |
| fFactory.get(), fontFace.get(), font.get(), fontFamily.get(), |
| sk_make_sp<DWriteFontTypeface::Loaders>( |
| fFactory.get(), |
| autoUnregisterFontFileLoader.detatch(), |
| autoUnregisterFontCollectionLoader.detatch())); |
| } |
| } |
| |
| return nullptr; |
| } |
| |
| sk_sp<SkTypeface> SkFontMgr_DirectWrite::onMakeFromData(sk_sp<SkData> data, int ttcIndex) const { |
| return this->makeFromStream(std::make_unique<SkMemoryStream>(std::move(data)), ttcIndex); |
| } |
| |
| sk_sp<SkTypeface> SkFontMgr_DirectWrite::onMakeFromFile(const char path[], int ttcIndex) const { |
| return this->makeFromStream(SkStream::MakeFromFile(path), ttcIndex); |
| } |
| |
| HRESULT SkFontMgr_DirectWrite::getByFamilyName(const WCHAR wideFamilyName[], |
| IDWriteFontFamily** fontFamily) const { |
| UINT32 index; |
| BOOL exists; |
| HR(fFontCollection->FindFamilyName(wideFamilyName, &index, &exists)); |
| |
| if (exists) { |
| HR(fFontCollection->GetFontFamily(index, fontFamily)); |
| } |
| return S_OK; |
| } |
| |
| sk_sp<SkTypeface> SkFontMgr_DirectWrite::onLegacyMakeTypeface(const char familyName[], |
| SkFontStyle style) const { |
| SkTScopedComPtr<IDWriteFontFamily> fontFamily; |
| const DWriteStyle dwStyle(style); |
| if (familyName) { |
| SkSMallocWCHAR dwFamilyName; |
| if (SUCCEEDED(sk_cstring_to_wchar(familyName, &dwFamilyName))) { |
| this->getByFamilyName(dwFamilyName, &fontFamily); |
| if (!fontFamily && fFontFallback) { |
| return this->fallback(dwFamilyName, dwStyle, fLocaleName.get(), 32); |
| } |
| } |
| } |
| |
| if (!fontFamily) { |
| if (fFontFallback) { |
| return this->fallback(nullptr, dwStyle, fLocaleName.get(), 32); |
| } |
| // SPI_GETNONCLIENTMETRICS lfMessageFont can fail in Win8. (DisallowWin32kSystemCalls) |
| // layoutFallback causes DCHECK in Chromium. (Uses system font collection.) |
| HRNM(this->getByFamilyName(fDefaultFamilyName, &fontFamily), |
| "Could not create DWrite font family from LOGFONT."); |
| } |
| |
| if (!fontFamily) { |
| // Could not obtain the default font. |
| HRNM(fFontCollection->GetFontFamily(0, &fontFamily), |
| "Could not get default-default font family."); |
| } |
| |
| SkTScopedComPtr<IDWriteFont> font; |
| HRNM(fontFamily->GetFirstMatchingFont(dwStyle.fWeight, dwStyle.fWidth, dwStyle.fSlant, &font), |
| "Could not get matching font."); |
| |
| SkTScopedComPtr<IDWriteFontFace> fontFace; |
| HRNM(font->CreateFontFace(&fontFace), "Could not create font face."); |
| |
| return this->makeTypefaceFromDWriteFont(fontFace.get(), font.get(), fontFamily.get()); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| int SkFontStyleSet_DirectWrite::count() { |
| return fFontFamily->GetFontCount(); |
| } |
| |
| SkTypeface* SkFontStyleSet_DirectWrite::createTypeface(int index) { |
| SkTScopedComPtr<IDWriteFont> font; |
| HRNM(fFontFamily->GetFont(index, &font), "Could not get font."); |
| |
| SkTScopedComPtr<IDWriteFontFace> fontFace; |
| HRNM(font->CreateFontFace(&fontFace), "Could not create font face."); |
| |
| return fFontMgr->makeTypefaceFromDWriteFont(fontFace.get(), font.get(), fFontFamily.get()).release(); |
| } |
| |
| void SkFontStyleSet_DirectWrite::getStyle(int index, SkFontStyle* fs, SkString* styleName) { |
| SkTScopedComPtr<IDWriteFont> font; |
| HRVM(fFontFamily->GetFont(index, &font), "Could not get font."); |
| |
| if (fs) { |
| *fs = get_style(font.get()); |
| } |
| |
| if (styleName) { |
| SkTScopedComPtr<IDWriteLocalizedStrings> faceNames; |
| if (SUCCEEDED(font->GetFaceNames(&faceNames))) { |
| sk_get_locale_string(faceNames.get(), fFontMgr->fLocaleName.get(), styleName); |
| } |
| } |
| } |
| |
| SkTypeface* SkFontStyleSet_DirectWrite::matchStyle(const SkFontStyle& pattern) { |
| SkTScopedComPtr<IDWriteFont> font; |
| DWriteStyle dwStyle(pattern); |
| // TODO: perhaps use GetMatchingFonts and get the least simulated? |
| HRNM(fFontFamily->GetFirstMatchingFont(dwStyle.fWeight, dwStyle.fWidth, dwStyle.fSlant, &font), |
| "Could not match font in family."); |
| |
| SkTScopedComPtr<IDWriteFontFace> fontFace; |
| HRNM(font->CreateFontFace(&fontFace), "Could not create font face."); |
| |
| return fFontMgr->makeTypefaceFromDWriteFont(fontFace.get(), font.get(), |
| fFontFamily.get()).release(); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| #include "include/ports/SkTypeface_win.h" |
| |
| SK_API sk_sp<SkFontMgr> SkFontMgr_New_DirectWrite(IDWriteFactory* factory, |
| IDWriteFontCollection* collection) { |
| return SkFontMgr_New_DirectWrite(factory, collection, nullptr); |
| } |
| |
| SK_API sk_sp<SkFontMgr> SkFontMgr_New_DirectWrite(IDWriteFactory* factory, |
| IDWriteFontCollection* collection, |
| IDWriteFontFallback* fallback) { |
| if (nullptr == factory) { |
| factory = sk_get_dwrite_factory(); |
| if (nullptr == factory) { |
| return nullptr; |
| } |
| } |
| |
| SkTScopedComPtr<IDWriteFontCollection> systemFontCollection; |
| if (nullptr == collection) { |
| HRNM(factory->GetSystemFontCollection(&systemFontCollection, FALSE), |
| "Could not get system font collection."); |
| collection = systemFontCollection.get(); |
| } |
| |
| // It is possible to have been provided a font fallback when factory2 is not available. |
| SkTScopedComPtr<IDWriteFontFallback> systemFontFallback; |
| if (nullptr == fallback) { |
| SkTScopedComPtr<IDWriteFactory2> factory2; |
| if (!SUCCEEDED(factory->QueryInterface(&factory2))) { |
| // IUnknown::QueryInterface states that if it fails, punk will be set to nullptr. |
| // http://blogs.msdn.com/b/oldnewthing/archive/2004/03/26/96777.aspx |
| SkASSERT_RELEASE(nullptr == factory2.get()); |
| } else { |
| HRNM(factory2->GetSystemFontFallback(&systemFontFallback), |
| "Could not get system fallback."); |
| fallback = systemFontFallback.get(); |
| } |
| } |
| |
| const WCHAR* defaultFamilyName = L""; |
| int defaultFamilyNameLen = 1; |
| NONCLIENTMETRICSW metrics; |
| metrics.cbSize = sizeof(metrics); |
| if (nullptr == fallback) { |
| if (SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(metrics), &metrics, 0)) { |
| defaultFamilyName = metrics.lfMessageFont.lfFaceName; |
| defaultFamilyNameLen = LF_FACESIZE; |
| } |
| } |
| |
| WCHAR localeNameStorage[LOCALE_NAME_MAX_LENGTH]; |
| const WCHAR* localeName = L""; |
| int localeNameLen = 1; |
| |
| // Dynamically load GetUserDefaultLocaleName function, as it is not available on XP. |
| SkGetUserDefaultLocaleNameProc getUserDefaultLocaleNameProc = nullptr; |
| HRESULT hr = SkGetGetUserDefaultLocaleNameProc(&getUserDefaultLocaleNameProc); |
| if (nullptr == getUserDefaultLocaleNameProc) { |
| SK_TRACEHR(hr, "Could not get GetUserDefaultLocaleName."); |
| } else { |
| int size = getUserDefaultLocaleNameProc(localeNameStorage, LOCALE_NAME_MAX_LENGTH); |
| if (size) { |
| localeName = localeNameStorage; |
| localeNameLen = size; |
| } |
| } |
| |
| return sk_make_sp<SkFontMgr_DirectWrite>(factory, collection, fallback, |
| localeName, localeNameLen, |
| defaultFamilyName, defaultFamilyNameLen); |
| } |
| |
| #include "include/ports/SkFontMgr_indirect.h" |
| SK_API sk_sp<SkFontMgr> SkFontMgr_New_DirectWriteRenderer(sk_sp<SkRemotableFontMgr> proxy) { |
| sk_sp<SkFontMgr> impl(SkFontMgr_New_DirectWrite()); |
| if (!impl) { |
| return nullptr; |
| } |
| return sk_make_sp<SkFontMgr_Indirect>(std::move(impl), std::move(proxy)); |
| } |
| #endif//defined(SK_BUILD_FOR_WIN) |
