/* * Copyright 2011 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 "include/core/SkFontMetrics.h" #include "include/core/SkFontMgr.h" #include "include/core/SkStream.h" #include "include/core/SkTypeface.h" #include "include/private/SkMutex.h" #include "include/private/SkOnce.h" #include "src/core/SkAdvancedTypefaceMetrics.h" #include "src/core/SkEndian.h" #include "src/core/SkFontDescriptor.h" #include "src/core/SkMakeUnique.h" #include "src/core/SkSurfacePriv.h" #include "src/core/SkTypefaceCache.h" #include "src/sfnt/SkOTTable_OS_2.h" SkTypeface::SkTypeface(const SkFontStyle& style, bool isFixedPitch) : fUniqueID(SkTypefaceCache::NewFontID()), fStyle(style), fIsFixedPitch(isFixedPitch) { } SkTypeface::~SkTypeface() { } #ifdef SK_WHITELIST_SERIALIZED_TYPEFACES extern void WhitelistSerializeTypeface(const SkTypeface*, SkWStream* ); #define SK_TYPEFACE_DELEGATE WhitelistSerializeTypeface #else #define SK_TYPEFACE_DELEGATE nullptr #endif void (*gSerializeTypefaceDelegate)(const SkTypeface*, SkWStream* ) = SK_TYPEFACE_DELEGATE; sk_sp (*gDeserializeTypefaceDelegate)(SkStream* ) = nullptr; /////////////////////////////////////////////////////////////////////////////// namespace { class SkEmptyTypeface : public SkTypeface { public: static sk_sp Make() { return sk_sp(new SkEmptyTypeface); } protected: SkEmptyTypeface() : SkTypeface(SkFontStyle(), true) { } std::unique_ptr onOpenStream(int* ttcIndex) const override { return nullptr; } sk_sp onMakeClone(const SkFontArguments& args) const override { return sk_ref_sp(this); } SkScalerContext* onCreateScalerContext(const SkScalerContextEffects&, const SkDescriptor*) const override { return nullptr; } void onFilterRec(SkScalerContextRec*) const override { } std::unique_ptr onGetAdvancedMetrics() const override { return nullptr; } void onGetFontDescriptor(SkFontDescriptor*, bool*) const override { } void onCharsToGlyphs(const SkUnichar* chars, int count, SkGlyphID glyphs[]) const override { sk_bzero(glyphs, count * sizeof(glyphs[0])); } int onCountGlyphs() const override { return 0; } void getPostScriptGlyphNames(SkString*) const override {} void getGlyphToUnicodeMap(SkUnichar*) const override {} int onGetUPEM() const override { return 0; } class EmptyLocalizedStrings : public SkTypeface::LocalizedStrings { public: bool next(SkTypeface::LocalizedString*) override { return false; } }; void onGetFamilyName(SkString* familyName) const override { familyName->reset(); } SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override { return new EmptyLocalizedStrings; } int onGetVariationDesignPosition(SkFontArguments::VariationPosition::Coordinate coordinates[], int coordinateCount) const override { return 0; } int onGetVariationDesignParameters(SkFontParameters::Variation::Axis parameters[], int parameterCount) const override { return 0; } int onGetTableTags(SkFontTableTag tags[]) const override { return 0; } size_t onGetTableData(SkFontTableTag, size_t, size_t, void*) const override { return 0; } }; } // namespace SkFontStyle SkTypeface::FromOldStyle(Style oldStyle) { return SkFontStyle((oldStyle & SkTypeface::kBold) ? SkFontStyle::kBold_Weight : SkFontStyle::kNormal_Weight, SkFontStyle::kNormal_Width, (oldStyle & SkTypeface::kItalic) ? SkFontStyle::kItalic_Slant : SkFontStyle::kUpright_Slant); } SkTypeface* SkTypeface::GetDefaultTypeface(Style style) { static SkOnce once[4]; static sk_sp defaults[4]; SkASSERT((int)style < 4); once[style]([style] { sk_sp fm(SkFontMgr::RefDefault()); auto t = fm->legacyMakeTypeface(nullptr, FromOldStyle(style)); defaults[style] = t ? t : SkEmptyTypeface::Make(); }); return defaults[style].get(); } sk_sp SkTypeface::MakeDefault() { return sk_ref_sp(GetDefaultTypeface()); } uint32_t SkTypeface::UniqueID(const SkTypeface* face) { if (nullptr == face) { face = GetDefaultTypeface(); } return face->uniqueID(); } bool SkTypeface::Equal(const SkTypeface* facea, const SkTypeface* faceb) { return facea == faceb || SkTypeface::UniqueID(facea) == SkTypeface::UniqueID(faceb); } /////////////////////////////////////////////////////////////////////////////// sk_sp SkTypeface::MakeFromName(const char name[], SkFontStyle fontStyle) { if (nullptr == name && (fontStyle.slant() == SkFontStyle::kItalic_Slant || fontStyle.slant() == SkFontStyle::kUpright_Slant) && (fontStyle.weight() == SkFontStyle::kBold_Weight || fontStyle.weight() == SkFontStyle::kNormal_Weight)) { return sk_ref_sp(GetDefaultTypeface(static_cast( (fontStyle.slant() == SkFontStyle::kItalic_Slant ? SkTypeface::kItalic : SkTypeface::kNormal) | (fontStyle.weight() == SkFontStyle::kBold_Weight ? SkTypeface::kBold : SkTypeface::kNormal)))); } return SkFontMgr::RefDefault()->legacyMakeTypeface(name, fontStyle); } sk_sp SkTypeface::MakeFromStream(std::unique_ptr stream, int index) { if (!stream) { return nullptr; } return SkFontMgr::RefDefault()->makeFromStream(std::move(stream), index); } sk_sp SkTypeface::MakeFromData(sk_sp data, int index) { if (!data) { return nullptr; } return SkFontMgr::RefDefault()->makeFromData(std::move(data), index); } sk_sp SkTypeface::MakeFromFontData(std::unique_ptr data) { return SkFontMgr::RefDefault()->makeFromFontData(std::move(data)); } sk_sp SkTypeface::MakeFromFile(const char path[], int index) { return SkFontMgr::RefDefault()->makeFromFile(path, index); } sk_sp SkTypeface::makeClone(const SkFontArguments& args) const { return this->onMakeClone(args); } /////////////////////////////////////////////////////////////////////////////// void SkTypeface::serialize(SkWStream* wstream, SerializeBehavior behavior) const { if (gSerializeTypefaceDelegate) { (*gSerializeTypefaceDelegate)(this, wstream); return; } bool isLocalData = false; SkFontDescriptor desc; this->onGetFontDescriptor(&desc, &isLocalData); bool shouldSerializeData = false; switch (behavior) { case SerializeBehavior::kDoIncludeData: shouldSerializeData = true; break; case SerializeBehavior::kDontIncludeData: shouldSerializeData = false; break; case SerializeBehavior::kIncludeDataIfLocal: shouldSerializeData = isLocalData; break; } // TODO: why do we check hasFontData() and allow the data to pass through even if the caller // has said they don't want the fontdata? Does this actually happen (getDescriptor returns // fontdata as well?) if (shouldSerializeData && !desc.hasFontData()) { desc.setFontData(this->onMakeFontData()); } desc.serialize(wstream); } sk_sp SkTypeface::serialize(SerializeBehavior behavior) const { SkDynamicMemoryWStream stream; this->serialize(&stream, behavior); return stream.detachAsData(); } sk_sp SkTypeface::MakeDeserialize(SkStream* stream) { if (gDeserializeTypefaceDelegate) { return (*gDeserializeTypefaceDelegate)(stream); } SkFontDescriptor desc; if (!SkFontDescriptor::Deserialize(stream, &desc)) { return nullptr; } std::unique_ptr data = desc.detachFontData(); if (data) { sk_sp typeface(SkTypeface::MakeFromFontData(std::move(data))); if (typeface) { return typeface; } } return SkTypeface::MakeFromName(desc.getFamilyName(), desc.getStyle()); } /////////////////////////////////////////////////////////////////////////////// int SkTypeface::getVariationDesignPosition( SkFontArguments::VariationPosition::Coordinate coordinates[], int coordinateCount) const { return this->onGetVariationDesignPosition(coordinates, coordinateCount); } int SkTypeface::getVariationDesignParameters( SkFontParameters::Variation::Axis parameters[], int parameterCount) const { return this->onGetVariationDesignParameters(parameters, parameterCount); } int SkTypeface::countTables() const { return this->onGetTableTags(nullptr); } int SkTypeface::getTableTags(SkFontTableTag tags[]) const { return this->onGetTableTags(tags); } size_t SkTypeface::getTableSize(SkFontTableTag tag) const { return this->onGetTableData(tag, 0, ~0U, nullptr); } size_t SkTypeface::getTableData(SkFontTableTag tag, size_t offset, size_t length, void* data) const { return this->onGetTableData(tag, offset, length, data); } sk_sp SkTypeface::copyTableData(SkFontTableTag tag) const { return this->onCopyTableData(tag); } sk_sp SkTypeface::onCopyTableData(SkFontTableTag tag) const { size_t size = this->getTableSize(tag); if (size) { sk_sp data = SkData::MakeUninitialized(size); (void)this->getTableData(tag, 0, size, data->writable_data()); return data; } return nullptr; } std::unique_ptr SkTypeface::openStream(int* ttcIndex) const { int ttcIndexStorage; if (nullptr == ttcIndex) { // So our subclasses don't need to check for null param ttcIndex = &ttcIndexStorage; } return this->onOpenStream(ttcIndex); } std::unique_ptr SkTypeface::makeFontData() const { return this->onMakeFontData(); } // This implementation is temporary until this method can be made pure virtual. std::unique_ptr SkTypeface::onMakeFontData() const { int index; std::unique_ptr stream(this->onOpenStream(&index)); if (!stream) { return nullptr; } return skstd::make_unique(std::move(stream), index, nullptr, 0); }; void SkTypeface::unicharsToGlyphs(const SkUnichar uni[], int count, SkGlyphID glyphs[]) const { if (count > 0 && glyphs && uni) { this->onCharsToGlyphs(uni, count, glyphs); } } SkGlyphID SkTypeface::unicharToGlyph(SkUnichar uni) const { SkGlyphID glyphs[1] = { 0 }; this->onCharsToGlyphs(&uni, 1, glyphs); return glyphs[0]; } int SkTypeface::countGlyphs() const { return this->onCountGlyphs(); } int SkTypeface::getUnitsPerEm() const { // should we try to cache this in the base-class? return this->onGetUPEM(); } bool SkTypeface::getKerningPairAdjustments(const uint16_t glyphs[], int count, int32_t adjustments[]) const { SkASSERT(count >= 0); // check for the only legal way to pass a nullptr.. everything is 0 // in which case they just want to know if this face can possibly support // kerning (true) or never (false). if (nullptr == glyphs || nullptr == adjustments) { SkASSERT(nullptr == glyphs); SkASSERT(0 == count); SkASSERT(nullptr == adjustments); } return this->onGetKerningPairAdjustments(glyphs, count, adjustments); } SkTypeface::LocalizedStrings* SkTypeface::createFamilyNameIterator() const { return this->onCreateFamilyNameIterator(); } void SkTypeface::getFamilyName(SkString* name) const { SkASSERT(name); this->onGetFamilyName(name); } void SkTypeface::getGlyphToUnicodeMap(SkUnichar* dst) const { sk_bzero(dst, sizeof(SkUnichar) * this->countGlyphs()); } std::unique_ptr SkTypeface::getAdvancedMetrics() const { std::unique_ptr result = this->onGetAdvancedMetrics(); if (result && result->fPostScriptName.isEmpty()) { result->fPostScriptName = result->fFontName; } if (result && result->fType == SkAdvancedTypefaceMetrics::kTrueType_Font) { SkOTTableOS2::Version::V2::Type::Field fsType; constexpr SkFontTableTag os2Tag = SkTEndian_SwapBE32(SkOTTableOS2::TAG); constexpr size_t fsTypeOffset = offsetof(SkOTTableOS2::Version::V2, fsType); if (this->getTableData(os2Tag, fsTypeOffset, sizeof(fsType), &fsType) == sizeof(fsType)) { if (fsType.Bitmap || (fsType.Restricted && !(fsType.PreviewPrint || fsType.Editable))) { result->fFlags |= SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag; } if (fsType.NoSubsetting) { result->fFlags |= SkAdvancedTypefaceMetrics::kNotSubsettable_FontFlag; } } } return result; } bool SkTypeface::onGetKerningPairAdjustments(const uint16_t glyphs[], int count, int32_t adjustments[]) const { return false; } /////////////////////////////////////////////////////////////////////////////// #include "include/core/SkPaint.h" #include "src/core/SkDescriptor.h" SkRect SkTypeface::getBounds() const { fBoundsOnce([this] { if (!this->onComputeBounds(&fBounds)) { fBounds.setEmpty(); } }); return fBounds; } bool SkTypeface::onComputeBounds(SkRect* bounds) const { // we use a big size to ensure lots of significant bits from the scalercontext. // then we scale back down to return our final answer (at 1-pt) const SkScalar textSize = 2048; const SkScalar invTextSize = 1 / textSize; SkFont font; font.setTypeface(sk_ref_sp(const_cast(this))); font.setSize(textSize); font.setLinearMetrics(true); SkScalerContextRec rec; SkScalerContextEffects effects; SkScalerContext::MakeRecAndEffectsFromFont(font, &rec, &effects); SkAutoDescriptor ad; SkScalerContextEffects noeffects; SkScalerContext::AutoDescriptorGivenRecAndEffects(rec, noeffects, &ad); std::unique_ptr ctx = this->createScalerContext(noeffects, ad.getDesc(), true); if (!ctx) { return false; } SkFontMetrics fm; ctx->getFontMetrics(&fm); bounds->set(fm.fXMin * invTextSize, fm.fTop * invTextSize, fm.fXMax * invTextSize, fm.fBottom * invTextSize); return true; } std::unique_ptr SkTypeface::onGetAdvancedMetrics() const { SkDEBUGFAIL("Typefaces that need to work with PDF backend must override this."); return nullptr; }