| /* |
| * 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 "include/core/SkPaint.h" |
| #include "include/core/SkPath.h" |
| #include "include/core/SkTypeface.h" |
| #include "include/private/SkTemplates.h" |
| #include "include/private/SkTo.h" |
| #include "src/core/SkDraw.h" |
| #include "src/core/SkFontPriv.h" |
| #include "src/core/SkPaintDefaults.h" |
| #include "src/core/SkScalerContext.h" |
| #include "src/core/SkStrike.h" |
| #include "src/core/SkStrikeCache.h" |
| #include "src/core/SkStrikeSpec.h" |
| #include "src/core/SkTLazy.h" |
| #include "src/core/SkUtils.h" |
| #include "src/utils/SkUTF.h" |
| |
| #define kDefault_Size SkPaintDefaults_TextSize |
| #define kDefault_Flags SkFont::kBaselineSnap_PrivFlag |
| #define kDefault_Edging SkFont::Edging::kAntiAlias |
| #define kDefault_Hinting SkPaintDefaults_Hinting |
| |
| static inline SkScalar valid_size(SkScalar size) { |
| return SkTMax<SkScalar>(0, size); |
| } |
| |
| SkFont::SkFont(sk_sp<SkTypeface> face, SkScalar size, SkScalar scaleX, SkScalar skewX) |
| : fTypeface(std::move(face)) |
| , fSize(valid_size(size)) |
| , fScaleX(scaleX) |
| , fSkewX(skewX) |
| , fFlags(kDefault_Flags) |
| , fEdging(static_cast<unsigned>(kDefault_Edging)) |
| , fHinting(static_cast<unsigned>(kDefault_Hinting)) |
| {} |
| |
| SkFont::SkFont(sk_sp<SkTypeface> face, SkScalar size) : SkFont(std::move(face), size, 1, 0) {} |
| |
| SkFont::SkFont(sk_sp<SkTypeface> face) : SkFont(std::move(face), kDefault_Size, 1, 0) {} |
| |
| SkFont::SkFont() : SkFont(nullptr, kDefault_Size) {} |
| |
| bool SkFont::operator==(const SkFont& b) const { |
| return fTypeface.get() == b.fTypeface.get() && |
| fSize == b.fSize && |
| fScaleX == b.fScaleX && |
| fSkewX == b.fSkewX && |
| fFlags == b.fFlags && |
| fEdging == b.fEdging && |
| fHinting == b.fHinting; |
| } |
| |
| void SkFont::dump() const { |
| SkDebugf("typeface %p\n", fTypeface.get()); |
| SkDebugf("size %g\n", fSize); |
| SkDebugf("skewx %g\n", fSkewX); |
| SkDebugf("scalex %g\n", fScaleX); |
| SkDebugf("flags 0x%X\n", fFlags); |
| SkDebugf("edging %d\n", (unsigned)fEdging); |
| SkDebugf("hinting %d\n", (unsigned)fHinting); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static inline uint32_t set_clear_mask(uint32_t bits, bool cond, uint32_t mask) { |
| return cond ? bits | mask : bits & ~mask; |
| } |
| |
| void SkFont::setForceAutoHinting(bool predicate) { |
| fFlags = set_clear_mask(fFlags, predicate, kForceAutoHinting_PrivFlag); |
| } |
| void SkFont::setEmbeddedBitmaps(bool predicate) { |
| fFlags = set_clear_mask(fFlags, predicate, kEmbeddedBitmaps_PrivFlag); |
| } |
| void SkFont::setSubpixel(bool predicate) { |
| fFlags = set_clear_mask(fFlags, predicate, kSubpixel_PrivFlag); |
| } |
| void SkFont::setLinearMetrics(bool predicate) { |
| fFlags = set_clear_mask(fFlags, predicate, kLinearMetrics_PrivFlag); |
| } |
| void SkFont::setEmbolden(bool predicate) { |
| fFlags = set_clear_mask(fFlags, predicate, kEmbolden_PrivFlag); |
| } |
| void SkFont::setBaselineSnap(bool predicate) { |
| fFlags = set_clear_mask(fFlags, predicate, kBaselineSnap_PrivFlag); |
| } |
| void SkFont::setEdging(Edging e) { |
| fEdging = SkToU8(e); |
| } |
| |
| void SkFont::setHinting(SkFontHinting h) { |
| fHinting = SkToU8(h); |
| } |
| |
| void SkFont::setSize(SkScalar size) { |
| fSize = valid_size(size); |
| } |
| void SkFont::setScaleX(SkScalar scale) { |
| fScaleX = scale; |
| } |
| void SkFont::setSkewX(SkScalar skew) { |
| fSkewX = skew; |
| } |
| |
| SkFont SkFont::makeWithSize(SkScalar newSize) const { |
| SkFont font = *this; |
| font.setSize(newSize); |
| return font; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| SkScalar SkFont::setupForAsPaths(SkPaint* paint) { |
| constexpr uint32_t flagsToIgnore = kEmbeddedBitmaps_PrivFlag | |
| kForceAutoHinting_PrivFlag; |
| |
| fFlags = (fFlags & ~flagsToIgnore) | kSubpixel_PrivFlag; |
| this->setHinting(SkFontHinting::kNone); |
| |
| if (this->getEdging() == Edging::kSubpixelAntiAlias) { |
| this->setEdging(Edging::kAntiAlias); |
| } |
| |
| if (paint) { |
| paint->setStyle(SkPaint::kFill_Style); |
| paint->setPathEffect(nullptr); |
| } |
| SkScalar textSize = fSize; |
| this->setSize(SkIntToScalar(SkFontPriv::kCanonicalTextSizeForPaths)); |
| return textSize / SkFontPriv::kCanonicalTextSizeForPaths; |
| } |
| |
| bool SkFont::hasSomeAntiAliasing() const { |
| Edging edging = this->getEdging(); |
| return edging == SkFont::Edging::kAntiAlias |
| || edging == SkFont::Edging::kSubpixelAntiAlias; |
| } |
| |
| SkGlyphID SkFont::unicharToGlyph(SkUnichar uni) const { |
| return this->getTypefaceOrDefault()->unicharToGlyph(uni); |
| } |
| |
| void SkFont::unicharsToGlyphs(const SkUnichar uni[], int count, SkGlyphID glyphs[]) const { |
| this->getTypefaceOrDefault()->unicharsToGlyphs(uni, count, glyphs); |
| } |
| |
| class SkConvertToUTF32 { |
| public: |
| SkConvertToUTF32() {} |
| |
| const SkUnichar* convert(const void* text, size_t byteLength, SkTextEncoding encoding) { |
| const SkUnichar* uni; |
| switch (encoding) { |
| case SkTextEncoding::kUTF8: { |
| uni = fStorage.reset(byteLength); |
| const char* ptr = (const char*)text; |
| const char* end = ptr + byteLength; |
| for (int i = 0; ptr < end; ++i) { |
| fStorage[i] = SkUTF::NextUTF8(&ptr, end); |
| } |
| } break; |
| case SkTextEncoding::kUTF16: { |
| uni = fStorage.reset(byteLength); |
| const uint16_t* ptr = (const uint16_t*)text; |
| const uint16_t* end = ptr + (byteLength >> 1); |
| for (int i = 0; ptr < end; ++i) { |
| fStorage[i] = SkUTF::NextUTF16(&ptr, end); |
| } |
| } break; |
| case SkTextEncoding::kUTF32: |
| uni = (const SkUnichar*)text; |
| break; |
| default: |
| SK_ABORT("unexpected enum"); |
| } |
| return uni; |
| } |
| |
| private: |
| SkAutoSTMalloc<256, SkUnichar> fStorage; |
| }; |
| |
| int SkFont::textToGlyphs(const void* text, size_t byteLength, SkTextEncoding encoding, |
| SkGlyphID glyphs[], int maxGlyphCount) const { |
| if (0 == byteLength) { |
| return 0; |
| } |
| |
| SkASSERT(text); |
| |
| int count = SkFontPriv::CountTextElements(text, byteLength, encoding); |
| if (!glyphs || count > maxGlyphCount) { |
| return count; |
| } |
| |
| if (encoding == SkTextEncoding::kGlyphID) { |
| memcpy(glyphs, text, count << 1); |
| return count; |
| } |
| |
| SkConvertToUTF32 storage; |
| const SkUnichar* uni = storage.convert(text, byteLength, encoding); |
| |
| this->getTypefaceOrDefault()->unicharsToGlyphs(uni, count, glyphs); |
| return count; |
| } |
| |
| SkScalar SkFont::measureText(const void* text, size_t length, SkTextEncoding encoding, |
| SkRect* bounds, const SkPaint* paint) const { |
| |
| SkAutoToGlyphs atg(*this, text, length, encoding); |
| const int glyphCount = atg.count(); |
| if (glyphCount == 0) { |
| if (bounds) { |
| bounds->setEmpty(); |
| } |
| return 0; |
| } |
| const SkGlyphID* glyphIDs = atg.glyphs(); |
| |
| SkStrikeSpec strikeSpec = SkStrikeSpec::MakeCanonicalized(*this, paint); |
| SkBulkGlyphMetrics metrics{strikeSpec}; |
| SkSpan<const SkGlyph*> glyphs = metrics.glyphs(SkMakeSpan(glyphIDs, glyphCount)); |
| |
| SkScalar width = 0; |
| if (bounds) { |
| *bounds = glyphs[0]->rect(); |
| width = glyphs[0]->advanceX(); |
| for (int i = 1; i < glyphCount; ++i) { |
| SkRect r = glyphs[i]->rect(); |
| r.offset(width, 0); |
| bounds->join(r); |
| width += glyphs[i]->advanceX(); |
| } |
| } else { |
| for (auto glyph : glyphs) { |
| width += glyph->advanceX(); |
| } |
| } |
| |
| const SkScalar scale = strikeSpec.strikeToSourceRatio(); |
| if (scale != 1) { |
| width *= scale; |
| if (bounds) { |
| bounds->fLeft *= scale; |
| bounds->fTop *= scale; |
| bounds->fRight *= scale; |
| bounds->fBottom *= scale; |
| } |
| } |
| |
| return width; |
| } |
| |
| void SkFont::getWidthsBounds(const SkGlyphID glyphIDs[], |
| int count, |
| SkScalar widths[], |
| SkRect bounds[], |
| const SkPaint* paint) const { |
| SkStrikeSpec strikeSpec = SkStrikeSpec::MakeCanonicalized(*this, paint); |
| SkBulkGlyphMetrics metrics{strikeSpec}; |
| SkSpan<const SkGlyph*> glyphs = metrics.glyphs(SkMakeSpan(glyphIDs, count)); |
| |
| SkScalar scale = strikeSpec.strikeToSourceRatio(); |
| |
| if (bounds) { |
| SkMatrix scaleMat = SkMatrix::MakeScale(scale); |
| SkRect* cursor = bounds; |
| for (auto glyph : glyphs) { |
| scaleMat.mapRectScaleTranslate(cursor++, glyph->rect()); |
| } |
| } |
| |
| if (widths) { |
| SkScalar* cursor = widths; |
| for (auto glyph : glyphs) { |
| *cursor++ = glyph->advanceX() * scale; |
| } |
| } |
| } |
| |
| void SkFont::getPos(const SkGlyphID glyphIDs[], int count, SkPoint pos[], SkPoint origin) const { |
| SkStrikeSpec strikeSpec = SkStrikeSpec::MakeCanonicalized(*this); |
| SkBulkGlyphMetrics metrics{strikeSpec}; |
| SkSpan<const SkGlyph*> glyphs = metrics.glyphs(SkMakeSpan(glyphIDs, count)); |
| |
| SkPoint sum = origin; |
| for (auto glyph : glyphs) { |
| *pos++ = sum; |
| sum += glyph->advanceVector() * strikeSpec.strikeToSourceRatio(); |
| } |
| } |
| |
| void SkFont::getXPos( |
| const SkGlyphID glyphIDs[], int count, SkScalar xpos[], SkScalar origin) const { |
| |
| SkStrikeSpec strikeSpec = SkStrikeSpec::MakeCanonicalized(*this); |
| SkBulkGlyphMetrics metrics{strikeSpec}; |
| SkSpan<const SkGlyph*> glyphs = metrics.glyphs(SkMakeSpan(glyphIDs, count)); |
| |
| SkScalar loc = origin; |
| SkScalar* cursor = xpos; |
| for (auto glyph : glyphs) { |
| *cursor++ = loc; |
| loc += glyph->advanceX() * strikeSpec.strikeToSourceRatio(); |
| } |
| } |
| |
| void SkFont::getPaths(const SkGlyphID glyphIDs[], int count, |
| void (*proc)(const SkPath*, const SkMatrix&, void*), void* ctx) const { |
| SkFont font(*this); |
| SkScalar scale = font.setupForAsPaths(nullptr); |
| const SkMatrix mx = SkMatrix::MakeScale(scale); |
| |
| SkStrikeSpec strikeSpec = SkStrikeSpec::MakeWithNoDevice(font); |
| SkBulkGlyphMetricsAndPaths paths{strikeSpec}; |
| SkSpan<const SkGlyph*> glyphs = paths.glyphs(SkMakeSpan(glyphIDs, count)); |
| |
| for (auto glyph : glyphs) { |
| proc(glyph->path(), mx, ctx); |
| } |
| } |
| |
| bool SkFont::getPath(SkGlyphID glyphID, SkPath* path) const { |
| struct Pair { |
| SkPath* fPath; |
| bool fWasSet; |
| } pair = { path, false }; |
| |
| this->getPaths(&glyphID, 1, [](const SkPath* orig, const SkMatrix& mx, void* ctx) { |
| Pair* pair = static_cast<Pair*>(ctx); |
| if (orig) { |
| orig->transform(mx, pair->fPath); |
| pair->fWasSet = true; |
| } |
| }, &pair); |
| return pair.fWasSet; |
| } |
| |
| SkScalar SkFont::getMetrics(SkFontMetrics* metrics) const { |
| |
| SkStrikeSpec strikeSpec = SkStrikeSpec::MakeCanonicalized(*this, nullptr); |
| |
| SkFontMetrics storage; |
| if (nullptr == metrics) { |
| metrics = &storage; |
| } |
| |
| auto cache = strikeSpec.findOrCreateExclusiveStrike(); |
| *metrics = cache->getFontMetrics(); |
| |
| if (strikeSpec.strikeToSourceRatio() != 1) { |
| SkFontPriv::ScaleFontMetrics(metrics, strikeSpec.strikeToSourceRatio()); |
| } |
| return metrics->fDescent - metrics->fAscent + metrics->fLeading; |
| } |
| |
| SkTypeface* SkFont::getTypefaceOrDefault() const { |
| return fTypeface ? fTypeface.get() : SkTypeface::GetDefaultTypeface(); |
| } |
| |
| sk_sp<SkTypeface> SkFont::refTypefaceOrDefault() const { |
| return fTypeface ? fTypeface : SkTypeface::MakeDefault(); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void SkFontPriv::ScaleFontMetrics(SkFontMetrics* metrics, SkScalar scale) { |
| metrics->fTop *= scale; |
| metrics->fAscent *= scale; |
| metrics->fDescent *= scale; |
| metrics->fBottom *= scale; |
| metrics->fLeading *= scale; |
| metrics->fAvgCharWidth *= scale; |
| metrics->fMaxCharWidth *= scale; |
| metrics->fXMin *= scale; |
| metrics->fXMax *= scale; |
| metrics->fXHeight *= scale; |
| metrics->fCapHeight *= scale; |
| metrics->fUnderlineThickness *= scale; |
| metrics->fUnderlinePosition *= scale; |
| metrics->fStrikeoutThickness *= scale; |
| metrics->fStrikeoutPosition *= scale; |
| } |
| |
| SkRect SkFontPriv::GetFontBounds(const SkFont& font) { |
| SkMatrix m; |
| m.setScale(font.getSize() * font.getScaleX(), font.getSize()); |
| m.postSkew(font.getSkewX(), 0); |
| |
| SkTypeface* typeface = font.getTypefaceOrDefault(); |
| |
| SkRect bounds; |
| m.mapRect(&bounds, typeface->getBounds()); |
| return bounds; |
| } |
| |
| int SkFontPriv::CountTextElements(const void* text, size_t byteLength, SkTextEncoding encoding) { |
| switch (encoding) { |
| case SkTextEncoding::kUTF8: |
| return SkUTF::CountUTF8(reinterpret_cast<const char*>(text), byteLength); |
| case SkTextEncoding::kUTF16: |
| return SkUTF::CountUTF16(reinterpret_cast<const uint16_t*>(text), byteLength); |
| case SkTextEncoding::kUTF32: |
| return byteLength >> 2; |
| case SkTextEncoding::kGlyphID: |
| return byteLength >> 1; |
| } |
| SkASSERT(false); |
| return 0; |
| } |
| |
| void SkFontPriv::GlyphsToUnichars(const SkFont& font, const SkGlyphID glyphs[], int count, |
| SkUnichar text[]) { |
| if (count <= 0) { |
| return; |
| } |
| |
| auto typeface = font.getTypefaceOrDefault(); |
| const unsigned numGlyphsInTypeface = typeface->countGlyphs(); |
| SkAutoTArray<SkUnichar> unichars(numGlyphsInTypeface); |
| typeface->getGlyphToUnicodeMap(unichars.get()); |
| |
| for (int i = 0; i < count; ++i) { |
| unsigned id = glyphs[i]; |
| text[i] = (id < numGlyphsInTypeface) ? unichars[id] : 0xFFFD; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| #include "src/core/SkReadBuffer.h" |
| #include "src/core/SkWriteBuffer.h" |
| |
| // packed int at the beginning of the serialized font: |
| // |
| // control_bits:8 size_as_byte:8 flags:12 edging:2 hinting:2 |
| |
| enum { |
| kSize_Is_Byte_Bit = 1 << 31, |
| kHas_ScaleX_Bit = 1 << 30, |
| kHas_SkewX_Bit = 1 << 29, |
| kHas_Typeface_Bit = 1 << 28, |
| |
| kShift_for_Size = 16, |
| kMask_For_Size = 0xFF, |
| |
| kShift_For_Flags = 4, |
| kMask_For_Flags = 0xFFF, |
| |
| kShift_For_Edging = 2, |
| kMask_For_Edging = 0x3, |
| |
| kShift_For_Hinting = 0, |
| kMask_For_Hinting = 0x3 |
| }; |
| |
| static bool scalar_is_byte(SkScalar x) { |
| int ix = (int)x; |
| return ix == x && ix >= 0 && ix <= kMask_For_Size; |
| } |
| |
| void SkFontPriv::Flatten(const SkFont& font, SkWriteBuffer& buffer) { |
| SkASSERT(font.fFlags <= SkFont::kAllFlags); |
| SkASSERT((font.fFlags & ~kMask_For_Flags) == 0); |
| SkASSERT((font.fEdging & ~kMask_For_Edging) == 0); |
| SkASSERT((font.fHinting & ~kMask_For_Hinting) == 0); |
| |
| uint32_t packed = 0; |
| packed |= font.fFlags << kShift_For_Flags; |
| packed |= font.fEdging << kShift_For_Edging; |
| packed |= font.fHinting << kShift_For_Hinting; |
| |
| if (scalar_is_byte(font.fSize)) { |
| packed |= kSize_Is_Byte_Bit; |
| packed |= (int)font.fSize << kShift_for_Size; |
| } |
| if (font.fScaleX != 1) { |
| packed |= kHas_ScaleX_Bit; |
| } |
| if (font.fSkewX != 0) { |
| packed |= kHas_SkewX_Bit; |
| } |
| if (font.fTypeface) { |
| packed |= kHas_Typeface_Bit; |
| } |
| |
| buffer.write32(packed); |
| if (!(packed & kSize_Is_Byte_Bit)) { |
| buffer.writeScalar(font.fSize); |
| } |
| if (packed & kHas_ScaleX_Bit) { |
| buffer.writeScalar(font.fScaleX); |
| } |
| if (packed & kHas_SkewX_Bit) { |
| buffer.writeScalar(font.fSkewX); |
| } |
| if (packed & kHas_Typeface_Bit) { |
| buffer.writeTypeface(font.fTypeface.get()); |
| } |
| } |
| |
| bool SkFontPriv::Unflatten(SkFont* font, SkReadBuffer& buffer) { |
| const uint32_t packed = buffer.read32(); |
| |
| if (packed & kSize_Is_Byte_Bit) { |
| font->fSize = (packed >> kShift_for_Size) & kMask_For_Size; |
| } else { |
| font->fSize = buffer.readScalar(); |
| } |
| if (packed & kHas_ScaleX_Bit) { |
| font->fScaleX = buffer.readScalar(); |
| } |
| if (packed & kHas_SkewX_Bit) { |
| font->fSkewX = buffer.readScalar(); |
| } |
| if (packed & kHas_Typeface_Bit) { |
| font->fTypeface = buffer.readTypeface(); |
| } |
| |
| SkASSERT(SkFont::kAllFlags <= kMask_For_Flags); |
| // we & with kAllFlags, to clear out any unknown flag bits |
| font->fFlags = SkToU8((packed >> kShift_For_Flags) & SkFont::kAllFlags); |
| |
| unsigned edging = (packed >> kShift_For_Edging) & kMask_For_Edging; |
| if (edging > (unsigned)SkFont::Edging::kSubpixelAntiAlias) { |
| edging = 0; |
| } |
| font->fEdging = SkToU8(edging); |
| |
| unsigned hinting = (packed >> kShift_For_Hinting) & kMask_For_Hinting; |
| if (hinting > (unsigned)SkFontHinting::kFull) { |
| hinting = 0; |
| } |
| font->fHinting = SkToU8(hinting); |
| |
| return buffer.isValid(); |
| } |
