SkTypeface::LocalizedStrings* DWriteFontTypeface::onCreateFamilyNameIterator() const {
SkTypeface::LocalizedStrings* nameIter =
SkOTUtils::LocalizedStrings_NameTable::CreateForFamilyNames(*this);
if (nullptr == nameIter) {
SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
HRNM(fDWriteFontFamily->GetFamilyNames(&familyNames), "Could not obtain family names.");
nameIter = new LocalizedStrings_IDWriteLocalizedStrings(familyNames.release());
}
return nameIter;
}
HRESULT StreamFontFileLoader::CreateStreamFromKey(
void const* fontFileReferenceKey,
UINT32 fontFileReferenceKeySize,
IDWriteFontFileStream** fontFileStream)
{
SkTScopedComPtr<SkDWriteFontFileStreamWrapper> stream;
HR(SkDWriteFontFileStreamWrapper::Create(fStream->duplicate(), &stream));
*fontFileStream = stream.release();
return S_OK;
}
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;
}
HRESULT 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;
}
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;
}
void DWriteFontTypeface::onGetFontDescriptor(SkFontDescriptor* desc,
bool* isLocalStream) const {
// Get the family name.
SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
HRV(fDWriteFontFamily->GetFamilyNames(&familyNames));
SkString utf8FamilyName;
sk_get_locale_string(familyNames.get(), nullptr/*fMgr->fLocaleName.get()*/, &utf8FamilyName);
desc->setFamilyName(utf8FamilyName.c_str());
*isLocalStream = SkToBool(fDWriteFontFileLoader.get());
}
void SkFontStyleSet_DirectWrite::getStyle(int index, SkFontStyle* fs, SkString* styleName) {
SkTScopedComPtr<IDWriteFont> font;
HRVM(fFontFamily->GetFont(index, &font), "Could not get font.");
if (fs) {
SkFontStyle::Slant slant;
switch (font->GetStyle()) {
case DWRITE_FONT_STYLE_NORMAL:
slant = SkFontStyle::kUpright_Slant;
break;
case DWRITE_FONT_STYLE_OBLIQUE:
case DWRITE_FONT_STYLE_ITALIC:
slant = SkFontStyle::kItalic_Slant;
break;
default:
SkASSERT(false);
}
int weight = font->GetWeight();
int width = font->GetStretch();
*fs = SkFontStyle(weight, width, slant);
}
if (styleName) {
SkTScopedComPtr<IDWriteLocalizedStrings> faceNames;
if (SUCCEEDED(font->GetFaceNames(&faceNames))) {
sk_get_locale_string(faceNames.get(), fFontMgr->fLocaleName.get(), styleName);
}
}
}
HRESULT SkScalerContext_DW::getBoundingBox(SkGlyph* glyph,
DWRITE_RENDERING_MODE renderingMode,
DWRITE_TEXTURE_TYPE textureType,
RECT* bbox)
{
//Measure raster size.
fXform.dx = SkFixedToFloat(glyph->getSubXFixed());
fXform.dy = SkFixedToFloat(glyph->getSubYFixed());
FLOAT advance = 0;
UINT16 glyphId = glyph->getGlyphID();
DWRITE_GLYPH_OFFSET offset;
offset.advanceOffset = 0.0f;
offset.ascenderOffset = 0.0f;
DWRITE_GLYPH_RUN run;
run.glyphCount = 1;
run.glyphAdvances = &advance;
run.fontFace = fTypeface->fDWriteFontFace.get();
run.fontEmSize = SkScalarToFloat(fTextSizeRender);
run.bidiLevel = 0;
run.glyphIndices = &glyphId;
run.isSideways = FALSE;
run.glyphOffsets = &offset;
SkTScopedComPtr<IDWriteGlyphRunAnalysis> glyphRunAnalysis;
{
SkAutoExclusive l(DWriteFactoryMutex);
HRM(fTypeface->fFactory->CreateGlyphRunAnalysis(
&run,
1.0f, // pixelsPerDip,
&fXform,
renderingMode,
fMeasuringMode,
0.0f, // baselineOriginX,
0.0f, // baselineOriginY,
&glyphRunAnalysis),
"Could not create glyph run analysis.");
}
{
Shared l(DWriteFactoryMutex);
HRM(glyphRunAnalysis->GetAlphaTextureBounds(textureType, bbox),
"Could not get texture bounds.");
}
return S_OK;
}
SkTypeface* SkFontStyleSet_DirectWrite::matchStyle(const SkFontStyle& pattern) {
DWRITE_FONT_STYLE slant;
switch (pattern.slant()) {
case SkFontStyle::kUpright_Slant:
slant = DWRITE_FONT_STYLE_NORMAL;
break;
case SkFontStyle::kItalic_Slant:
slant = DWRITE_FONT_STYLE_ITALIC;
break;
default:
SkASSERT(false);
}
DWRITE_FONT_WEIGHT weight = (DWRITE_FONT_WEIGHT)pattern.weight();
DWRITE_FONT_STRETCH width = (DWRITE_FONT_STRETCH)pattern.width();
SkTScopedComPtr<IDWriteFont> font;
// TODO: perhaps use GetMatchingFonts and get the least simulated?
HRNM(fFontFamily->GetFirstMatchingFont(weight, width, slant, &font),
"Could not match font in family.");
SkTScopedComPtr<IDWriteFontFace> fontFace;
HRNM(font->CreateFontFace(&fontFace), "Could not create font face.");
return fFontMgr->createTypefaceFromDWriteFont(fontFace.get(), font.get(),
fFontFamily.get());
}
SkStreamAsset* DWriteFontTypeface::onOpenStream(int* ttcIndex) const {
*ttcIndex = fDWriteFontFace->GetIndex();
UINT32 numFiles;
HRNM(fDWriteFontFace->GetFiles(&numFiles, nullptr),
"Could not get number of font files.");
if (numFiles != 1) {
return nullptr;
}
SkTScopedComPtr<IDWriteFontFile> fontFile;
HRNM(fDWriteFontFace->GetFiles(&numFiles, &fontFile), "Could not get font files.");
const void* fontFileKey;
UINT32 fontFileKeySize;
HRNM(fontFile->GetReferenceKey(&fontFileKey, &fontFileKeySize),
"Could not get font file reference key.");
SkTScopedComPtr<IDWriteFontFileLoader> fontFileLoader;
HRNM(fontFile->GetLoader(&fontFileLoader), "Could not get font file loader.");
SkTScopedComPtr<IDWriteFontFileStream> fontFileStream;
HRNM(fontFileLoader->CreateStreamFromKey(fontFileKey, fontFileKeySize,
&fontFileStream),
"Could not create font file stream.");
return new SkDWriteFontFileStream(fontFileStream.get());
}
HRESULT 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;
}
void DWriteFontTypeface::onGetFontDescriptor(SkFontDescriptor* desc,
bool* isLocalStream) const {
// Get the family name.
SkTScopedComPtr<IDWriteLocalizedStrings> dwFamilyNames;
HRV(fDWriteFontFamily->GetFamilyNames(&dwFamilyNames));
UINT32 dwFamilyNamesLength;
HRV(dwFamilyNames->GetStringLength(0, &dwFamilyNamesLength));
SkSMallocWCHAR dwFamilyNameChar(dwFamilyNamesLength+1);
HRV(dwFamilyNames->GetString(0, dwFamilyNameChar.get(), dwFamilyNamesLength+1));
SkString utf8FamilyName;
HRV(sk_wchar_to_skstring(dwFamilyNameChar.get(), &utf8FamilyName));
desc->setFamilyName(utf8FamilyName.c_str());
*isLocalStream = SkToBool(fDWriteFontFileLoader.get());
}
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->createTypefaceFromDWriteFont(fontFace.get(), font.get(), fFontFamily.get());
}
// IDWriteTextRenderer methods
virtual HRESULT STDMETHODCALLTYPE 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
{
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->createTypefaceFromDWriteFont(glyphRun->fontFace,
font.get(),
fontFamily.get());
}
return S_OK;
}
SkFontStyleSet* SkFontMgr_DirectWrite::onMatchFamily(const char familyName[]) const {
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);
}
bool SkImageGeneratorWIC::onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
SkPMColor ctable[], int* ctableCount) {
if (kN32_SkColorType != info.colorType()) {
return false;
}
// Create a format converter.
SkTScopedComPtr<IWICFormatConverter> formatConverter;
HRESULT hr = fImagingFactory->CreateFormatConverter(&formatConverter);
if (FAILED(hr)) {
return false;
}
GUID format = GUID_WICPixelFormat32bppPBGRA;
if (kUnpremul_SkAlphaType == info.alphaType()) {
format = GUID_WICPixelFormat32bppBGRA;
}
hr = formatConverter->Initialize(fImageSource.get(), format, WICBitmapDitherTypeNone, nullptr,
0.0, WICBitmapPaletteTypeCustom);
if (FAILED(hr)) {
return false;
}
// Treat the format converter as an image source.
SkTScopedComPtr<IWICBitmapSource> formatConverterSrc;
hr = formatConverter->QueryInterface(IID_PPV_ARGS(&formatConverterSrc));
if (FAILED(hr)) {
return false;
}
// Set the destination pixels.
hr = formatConverterSrc->CopyPixels(nullptr, (UINT) rowBytes, (UINT) rowBytes * info.height(),
(BYTE*) pixels);
return SUCCEEDED(hr);
}
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->createTypefaceFromDWriteFont(fontFace.get(), font.get(),
fFontFamily.get());
}
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();
}
WCHAR localeNameStorage[LOCALE_NAME_MAX_LENGTH];
WCHAR* localeName = nullptr;
int localeNameLen = 0;
// 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 {
localeNameLen = getUserDefaultLocaleNameProc(localeNameStorage, LOCALE_NAME_MAX_LENGTH);
if (localeNameLen) {
localeName = localeNameStorage;
};
}
return sk_make_sp<SkFontMgr_DirectWrite>(factory, collection, fallback,
localeName, localeNameLen);
}
SkTypeface* SkFontMgr_DirectWrite::createTypefaceFromDWriteFont(
IDWriteFontFace* fontFace,
IDWriteFont* font,
IDWriteFontFamily* fontFamily) const {
SkAutoMutexAcquire ama(fTFCacheMutex);
ProtoDWriteTypeface spec = { fontFace, font, fontFamily };
SkTypeface* face = fTFCache.findByProcAndRef(FindByDWriteFont, &spec);
if (nullptr == face) {
face = DWriteFontTypeface::Create(fFactory.get(), fontFace, font, fontFamily);
if (face) {
fTFCache.add(face);
}
}
return face;
}
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);
}
}
}
int SkFontMgr_DirectWrite::onCountFamilies() const {
return fFontCollection->GetFontFamilyCount();
}
int SkFontStyleSet_DirectWrite::count() {
return fFontFamily->GetFontCount();
}
SkTypeface* SkFontMgr_DirectWrite::onLegacyCreateTypeface(const char familyName[],
SkFontStyle style) const {
SkTScopedComPtr<IDWriteFontFamily> fontFamily;
if (familyName) {
SkSMallocWCHAR wideFamilyName;
if (SUCCEEDED(sk_cstring_to_wchar(familyName, &wideFamilyName))) {
this->getByFamilyName(wideFamilyName, &fontFamily);
}
}
if (nullptr == fontFamily.get()) {
// No family with given name, try default.
this->getDefaultFontFamily(&fontFamily);
}
if (nullptr == fontFamily.get()) {
// Could not obtain the default font.
HRNM(fFontCollection->GetFontFamily(0, &fontFamily),
"Could not get default-default font family.");
}
SkTScopedComPtr<IDWriteFont> font;
DWriteStyle dwStyle(style);
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->createTypefaceFromDWriteFont(fontFace.get(), font.get(), fontFamily.get());
}
void DWriteFontTypeface::onGetFamilyName(SkString* familyName) const {
SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
HRV(fDWriteFontFamily->GetFamilyNames(&familyNames));
sk_get_locale_string(familyNames.get(), nullptr/*fMgr->fLocaleName.get()*/, familyName);
}
SkTypeface* SkFontMgr_DirectWrite::onCreateFromStream(SkStreamAsset* stream, int ttcIndex) const {
SkTScopedComPtr<StreamFontFileLoader> fontFileLoader;
// This transfers ownership of stream to the new object.
HRN(StreamFontFileLoader::Create(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));
UINT32 faceIndex = fontFace->GetIndex();
if (faceIndex == ttcIndex) {
return DWriteFontTypeface::Create(fFactory.get(),
fontFace.get(), font.get(), fontFamily.get(),
autoUnregisterFontFileLoader.detatch(),
autoUnregisterFontCollectionLoader.detatch());
}
}
}
return nullptr;
}
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;
}
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 (fFactory2.get()) {
SkTScopedComPtr<IDWriteFontFallback> systemFontFallback;
IDWriteFontFallback* fontFallback = fFontFallback.get();
if (!fontFallback) {
HRNM(fFactory2->GetSystemFontFallback(&systemFontFallback),
"Could not get system fallback.");
fontFallback = systemFontFallback.get();
}
SkTScopedComPtr<IDWriteNumberSubstitution> numberSubstitution;
HRNM(fFactory2->CreateNumberSubstitution(DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE, nullptr, 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 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->createTypefaceFromDWriteFont(fontFace.get(), font.get(), fontFamily.get());
}
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.");
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(nullptr, fontFallbackRenderer.get(), 50.0f, 50.0f),
"Could not draw layout with renderer.");
return fontFallbackRenderer->FallbackTypeface();
}
SkAdvancedTypefaceMetrics* DWriteFontTypeface::onGetAdvancedTypefaceMetrics(
PerGlyphInfo perGlyphInfo,
const uint32_t* glyphIDs,
uint32_t glyphIDsCount) const {
SkAdvancedTypefaceMetrics* info = nullptr;
HRESULT hr = S_OK;
const unsigned glyphCount = fDWriteFontFace->GetGlyphCount();
DWRITE_FONT_METRICS dwfm;
fDWriteFontFace->GetMetrics(&dwfm);
info = new SkAdvancedTypefaceMetrics;
info->fEmSize = dwfm.designUnitsPerEm;
info->fLastGlyphID = SkToU16(glyphCount - 1);
info->fAscent = SkToS16(dwfm.ascent);
info->fDescent = SkToS16(dwfm.descent);
info->fCapHeight = SkToS16(dwfm.capHeight);
// SkAdvancedTypefaceMetrics::fFontName is in theory supposed to be
// the PostScript name of the font. However, due to the way it is currently
// used, it must actually be a family name.
SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
hr = fDWriteFontFamily->GetFamilyNames(&familyNames);
UINT32 familyNameLen;
hr = familyNames->GetStringLength(0, &familyNameLen);
SkSMallocWCHAR familyName(familyNameLen+1);
hr = familyNames->GetString(0, familyName.get(), familyNameLen+1);
hr = sk_wchar_to_skstring(familyName.get(), familyNameLen, &info->fFontName);
if (perGlyphInfo & kToUnicode_PerGlyphInfo) {
populate_glyph_to_unicode(fDWriteFontFace.get(), glyphCount, &(info->fGlyphToUnicode));
}
DWRITE_FONT_FACE_TYPE fontType = fDWriteFontFace->GetType();
if (fontType != DWRITE_FONT_FACE_TYPE_TRUETYPE &&
fontType != DWRITE_FONT_FACE_TYPE_TRUETYPE_COLLECTION)
{
return info;
}
// Simulated fonts aren't really TrueType fonts.
if (fDWriteFontFace->GetSimulations() == DWRITE_FONT_SIMULATIONS_NONE) {
info->fType = SkAdvancedTypefaceMetrics::kTrueType_Font;
}
AutoTDWriteTable<SkOTTableHead> headTable(fDWriteFontFace.get());
AutoTDWriteTable<SkOTTablePostScript> postTable(fDWriteFontFace.get());
AutoTDWriteTable<SkOTTableHorizontalHeader> hheaTable(fDWriteFontFace.get());
AutoTDWriteTable<SkOTTableOS2> os2Table(fDWriteFontFace.get());
if (!headTable.fExists || !postTable.fExists || !hheaTable.fExists || !os2Table.fExists) {
return info;
}
//There exist CJK fonts which set the IsFixedPitch and Monospace bits,
//but have full width, latin half-width, and half-width kana.
bool fixedWidth = (postTable->isFixedPitch &&
(1 == SkEndian_SwapBE16(hheaTable->numberOfHMetrics)));
//Monospace
if (fixedWidth) {
info->fStyle |= SkAdvancedTypefaceMetrics::kFixedPitch_Style;
}
//Italic
if (os2Table->version.v0.fsSelection.field.Italic) {
info->fStyle |= SkAdvancedTypefaceMetrics::kItalic_Style;
}
//Serif
using SerifStyle = SkPanose::Data::TextAndDisplay::SerifStyle;
SerifStyle serifStyle = os2Table->version.v0.panose.data.textAndDisplay.bSerifStyle;
if (SkPanose::FamilyType::TextAndDisplay == os2Table->version.v0.panose.bFamilyType) {
if (SerifStyle::Cove == serifStyle ||
SerifStyle::ObtuseCove == serifStyle ||
SerifStyle::SquareCove == serifStyle ||
SerifStyle::ObtuseSquareCove == serifStyle ||
SerifStyle::Square == serifStyle ||
SerifStyle::Thin == serifStyle ||
SerifStyle::Bone == serifStyle ||
SerifStyle::Exaggerated == serifStyle ||
SerifStyle::Triangle == serifStyle)
{
info->fStyle |= SkAdvancedTypefaceMetrics::kSerif_Style;
}
//Script
} else if (SkPanose::FamilyType::Script == os2Table->version.v0.panose.bFamilyType) {
info->fStyle |= SkAdvancedTypefaceMetrics::kScript_Style;
}
info->fItalicAngle = SkEndian_SwapBE32(postTable->italicAngle) >> 16;
info->fBBox = SkIRect::MakeLTRB((int32_t)SkEndian_SwapBE16((uint16_t)headTable->xMin),
(int32_t)SkEndian_SwapBE16((uint16_t)headTable->yMax),
(int32_t)SkEndian_SwapBE16((uint16_t)headTable->xMax),
(int32_t)SkEndian_SwapBE16((uint16_t)headTable->yMin));
return info;
}
static bool FindByDWriteFont(SkTypeface* cached, void* ctx) {
DWriteFontTypeface* cshFace = reinterpret_cast<DWriteFontTypeface*>(cached);
ProtoDWriteTypeface* ctxFace = reinterpret_cast<ProtoDWriteTypeface*>(ctx);
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;
}
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());
}
bool SkImageDecoder_WIC::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
//Initialize COM.
AutoCoInitialize scopedCo;
HRESULT hr = scopedCo.getHR();
//Create Windows Imaging Component ImagingFactory.
SkTScopedComPtr<IWICImagingFactory> piImagingFactory;
if (SUCCEEDED(hr)) {
hr = CoCreateInstance(
CLSID_WICImagingFactory
, NULL
, CLSCTX_INPROC_SERVER
, IID_PPV_ARGS(&piImagingFactory)
);
}
//Convert SkStream to IStream.
SkTScopedComPtr<IStream> piStream;
if (SUCCEEDED(hr)) {
hr = SkIStream::CreateFromSkStream(stream, false, &piStream);
}
//Make sure we're at the beginning of the stream.
if (SUCCEEDED(hr)) {
LARGE_INTEGER liBeginning = { 0 };
hr = piStream->Seek(liBeginning, STREAM_SEEK_SET, NULL);
}
//Create the decoder from the stream content.
SkTScopedComPtr<IWICBitmapDecoder> piBitmapDecoder;
if (SUCCEEDED(hr)) {
hr = piImagingFactory->CreateDecoderFromStream(
piStream.get() //Image to be decoded
, NULL //No particular vendor
, WICDecodeMetadataCacheOnDemand //Cache metadata when needed
, &piBitmapDecoder //Pointer to the decoder
);
}
//Get the first frame from the decoder.
SkTScopedComPtr<IWICBitmapFrameDecode> piBitmapFrameDecode;
if (SUCCEEDED(hr)) {
hr = piBitmapDecoder->GetFrame(0, &piBitmapFrameDecode);
}
//Get the BitmapSource interface of the frame.
SkTScopedComPtr<IWICBitmapSource> piBitmapSourceOriginal;
if (SUCCEEDED(hr)) {
hr = piBitmapFrameDecode->QueryInterface(
IID_PPV_ARGS(&piBitmapSourceOriginal)
);
}
//Get the size of the bitmap.
UINT width;
UINT height;
if (SUCCEEDED(hr)) {
hr = piBitmapSourceOriginal->GetSize(&width, &height);
}
//Exit early if we're only looking for the bitmap bounds.
if (SUCCEEDED(hr)) {
bm->setConfig(SkBitmap::kARGB_8888_Config, width, height);
if (SkImageDecoder::kDecodeBounds_Mode == mode) {
return true;
}
if (!this->allocPixelRef(bm, NULL)) {
return false;
}
}
//Create a format converter.
SkTScopedComPtr<IWICFormatConverter> piFormatConverter;
if (SUCCEEDED(hr)) {
hr = piImagingFactory->CreateFormatConverter(&piFormatConverter);
}
if (SUCCEEDED(hr)) {
hr = piFormatConverter->Initialize(
piBitmapSourceOriginal.get() //Input bitmap to convert
, GUID_WICPixelFormat32bppPBGRA //Destination pixel format
, WICBitmapDitherTypeNone //Specified dither patterm
, NULL //Specify a particular palette
, 0.f //Alpha threshold
, WICBitmapPaletteTypeCustom //Palette translation type
);
}
//Get the BitmapSource interface of the format converter.
SkTScopedComPtr<IWICBitmapSource> piBitmapSourceConverted;
if (SUCCEEDED(hr)) {
hr = piFormatConverter->QueryInterface(
IID_PPV_ARGS(&piBitmapSourceConverted)
);
}
//Copy the pixels into the bitmap.
if (SUCCEEDED(hr)) {
bm->lockPixels();
bm->eraseColor(0);
const int stride = bm->rowBytes();
hr = piBitmapSourceConverted->CopyPixels(
NULL, //Get all the pixels
stride,
stride * height,
reinterpret_cast<BYTE *>(bm->getPixels())
);
bm->unlockPixels();
}
return SUCCEEDED(hr);
}
