SkPDFFont Class Reference

#include <SkPDFFont.h>

Public Member Functions
	~SkPDFFont ()
	SkPDFFont (SkPDFFont &&)
SkPDFFont &	operator= (SkPDFFont &&)
SkTypeface *	typeface () const
SkAdvancedTypefaceMetrics::FontType	getType () const
bool	multiByteGlyphs () const
bool	hasGlyph (SkGlyphID gid)
SkGlyphID	glyphToPDFFontEncoding (SkGlyphID gid) const
void	noteGlyphUsage (SkGlyphID glyph)
SkPDFIndirectReference	indirectReference () const
void	emitSubset (SkPDFDocument *) const
SkGlyphID	firstGlyphID () const
SkGlyphID	lastGlyphID () const
const SkPDFGlyphUse &	glyphUsage () const
sk_sp< SkTypeface >	refTypeface () const

Static Public Member Functions
static SkAdvancedTypefaceMetrics::FontType	FontType (const SkTypeface &, const SkAdvancedTypefaceMetrics &)
static void	GetType1GlyphNames (const SkTypeface &, SkString *)
static bool	IsMultiByte (SkAdvancedTypefaceMetrics::FontType type)
static SkPDFFont *	GetFontResource (SkPDFDocument *doc, const SkGlyph *glyphs, SkTypeface *typeface)
static const SkAdvancedTypefaceMetrics *	GetMetrics (const SkTypeface *typeface, SkPDFDocument *canon)
static const std::vector< SkUnichar > &	GetUnicodeMap (const SkTypeface *typeface, SkPDFDocument *canon)
static void	PopulateCommonFontDescriptor (SkPDFDict *descriptor, const SkAdvancedTypefaceMetrics &, uint16_t emSize, int16_t defaultWidth)
static bool	CanEmbedTypeface (SkTypeface *, SkPDFDocument *)

Detailed Description

A PDF Object class representing a font. The font may have resources attached to it in order to embed the font. SkPDFFonts are canonicalized so that resource deduplication will only include one copy of a font. This class uses the same pattern as SkPDFGraphicState, a static weak reference to each instantiated class.

Definition at line 30 of file SkPDFFont.h.

Constructor & Destructor Documentation

~SkPDFFont()

SkPDFFont::~SkPDFFont ( )

default

SkPDFFont()

SkPDFFont::SkPDFFont ( SkPDFFont &&  )

default

Member Function Documentation

CanEmbedTypeface()

bool SkPDFFont::CanEmbedTypeface ( SkTypeface *  typeface, SkPDFDocument *  doc  )

static

Return false iff the typeface has its NotEmbeddable flag set. typeface is not nullptr

Definition at line 753 of file SkPDFFont.cpp.

                                                                         {
    const SkAdvancedTypefaceMetrics* metrics = SkPDFFont::GetMetrics(typeface, doc);
    return metrics && can_embed(*metrics);
}

emitSubset()

void SkPDFFont::emitSubset

(

SkPDFDocument *

doc

)

const

Definition at line 736 of file SkPDFFont.cpp.

                                                   {
    switch (fFontType) {
        case SkAdvancedTypefaceMetrics::kType1CID_Font:
        case SkAdvancedTypefaceMetrics::kTrueType_Font:
        case SkAdvancedTypefaceMetrics::kCFF_Font:
            return emit_subset_type0(*this, doc);
#ifndef SK_PDF_DO_NOT_SUPPORT_TYPE_1_FONTS
        case SkAdvancedTypefaceMetrics::kType1_Font:
            return SkPDFEmitType1Font(*this, doc);
#endif
        default:
            return emit_subset_type3(*this, doc);
    }
}

firstGlyphID()

SkGlyphID SkPDFFont::firstGlyphID ( ) const

inline

Definition at line 118 of file SkPDFFont.h.

{ return fGlyphUsage.firstNonZero(); }

FontType()

SkAdvancedTypefaceMetrics::FontType SkPDFFont::FontType ( const SkTypeface &  typeface, const SkAdvancedTypefaceMetrics &  metrics  )

static

Definition at line 173 of file SkPDFFont.cpp.

                                                                                                  {
    if (SkToBool(metrics.fFlags & SkAdvancedTypefaceMetrics::kVariable_FontFlag) ||
        // PDF is actually interested in the encoding of the data, not just the logical format.
        // If the TrueType is actually wOFF or wOF2 then it should not be directly embedded in PDF.
        // For now export these as Type3 until the subsetter can handle table based fonts.
        // See https://github.com/harfbuzz/harfbuzz/issues/3609 and
        // https://skia-review.googlesource.com/c/skia/+/543485
        SkToBool(metrics.fFlags & SkAdvancedTypefaceMetrics::kAltDataFormat_FontFlag) ||
        SkToBool(metrics.fFlags & SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag)) {
        // force Type3 fallback.
        return SkAdvancedTypefaceMetrics::kOther_Font;
    }
    if (typeface.getTableSize(kCOLRTableTag)) {
        // https://bugs.chromium.org/p/skia/issues/detail?id=12650
        // Don't embed COLRv0 / COLRv1 fonts, fall back to bitmaps.
        return SkAdvancedTypefaceMetrics::kOther_Font;
    }
    return metrics.fType;
}

GetFontResource()

SkPDFFont * SkPDFFont::GetFontResource ( SkPDFDocument *  doc, const SkGlyph *  glyphs, SkTypeface *  typeface  )

static

Get the font resource for the passed typeface and glyphID. The reference count of the object is incremented and it is the caller's responsibility to unreference it when done. This is needed to accommodate the weak reference pattern used when the returned object is new and has no other references.

Parameters

typeface	The typeface to find, not nullptr.
glyphID	Specify which section of a large font is of interest.

Definition at line 198 of file SkPDFFont.cpp.

                                                        {
    SkASSERT(doc);
    SkASSERT(face);  // All SkPDFDevice::internalDrawText ensures this.
    const SkAdvancedTypefaceMetrics* fontMetrics = SkPDFFont::GetMetrics(face, doc);
    SkASSERT(fontMetrics);  // SkPDFDevice::internalDrawText ensures the typeface is good.
                            // GetMetrics only returns null to signify a bad typeface.
    const SkAdvancedTypefaceMetrics& metrics = *fontMetrics;
    SkAdvancedTypefaceMetrics::FontType type = SkPDFFont::FontType(*face, metrics);
    if (!(glyph->isEmpty() || glyph->path())) {
        type = SkAdvancedTypefaceMetrics::kOther_Font;
    }
    bool multibyte = SkPDFFont::IsMultiByte(type);
    SkGlyphID subsetCode =
            multibyte ? 0 : first_nonzero_glyph_for_single_byte_encoding(glyph->getGlyphID());
    uint64_t typefaceID = (static_cast<uint64_t>(face->uniqueID()) << 16) | subsetCode;
 
    if (SkPDFFont* found = doc->fFontMap.find(typefaceID)) {
        SkASSERT(multibyte == found->multiByteGlyphs());
        return found;
    }
 
    sk_sp<SkTypeface> typeface(sk_ref_sp(face));
    SkASSERT(typeface);
 
    SkGlyphID lastGlyph = SkToU16(typeface->countGlyphs() - 1);
 
    // should be caught by SkPDFDevice::internalDrawText
    SkASSERT(glyph->getGlyphID() <= lastGlyph);
 
    SkGlyphID firstNonZeroGlyph;
    if (multibyte) {
        firstNonZeroGlyph = 1;
    } else {
        firstNonZeroGlyph = subsetCode;
        lastGlyph = SkToU16(std::min<int>((int)lastGlyph, 254 + (int)subsetCode));
    }
    auto ref = doc->reserveRef();
    return doc->fFontMap.set(
            typefaceID, SkPDFFont(std::move(typeface), firstNonZeroGlyph, lastGlyph, type, ref));
}

GetMetrics()

const SkAdvancedTypefaceMetrics * SkPDFFont::GetMetrics ( const SkTypeface *  typeface, SkPDFDocument *  canon  )

static

Gets SkAdvancedTypefaceMetrics, and caches the result.

Parameters

typeface

can not be nullptr.

Returns

nullptr only when typeface is bad.

Definition at line 108 of file SkPDFFont.cpp.

                                                                             {
    SkASSERT(typeface);
    SkTypefaceID id = typeface->uniqueID();
    if (std::unique_ptr<SkAdvancedTypefaceMetrics>* ptr = canon->fTypefaceMetrics.find(id)) {
        return ptr->get();  // canon retains ownership.
    }
    int count = typeface->countGlyphs();
    if (count <= 0 || count > 1 + SkTo<int>(UINT16_MAX)) {
        // Cache nullptr to skip this check.  Use SkSafeUnref().
        canon->fTypefaceMetrics.set(id, nullptr);
        return nullptr;
    }
    std::unique_ptr<SkAdvancedTypefaceMetrics> metrics = typeface->getAdvancedMetrics();
    if (!metrics) {
        metrics = std::make_unique<SkAdvancedTypefaceMetrics>();
    }
 
    if (0 == metrics->fStemV || 0 == metrics->fCapHeight) {
        SkFont font;
        font.setHinting(SkFontHinting::kNone);
        font.setTypeface(sk_ref_sp(typeface));
        font.setSize(1000);  // glyph coordinate system
        if (0 == metrics->fStemV) {
            // Figure out a good guess for StemV - Min width of i, I, !, 1.
            // This probably isn't very good with an italic font.
            int16_t stemV = SHRT_MAX;
            for (char c : {'i', 'I', '!', '1'}) {
                uint16_t g = font.unicharToGlyph(c);
                SkRect bounds;
                font.getBounds(&g, 1, &bounds, nullptr);
                stemV = std::min(stemV, SkToS16(SkScalarRoundToInt(bounds.width())));
            }
            metrics->fStemV = stemV;
        }
        if (0 == metrics->fCapHeight) {
            // Figure out a good guess for CapHeight: average the height of M and X.
            SkScalar capHeight = 0;
            for (char c : {'M', 'X'}) {
                uint16_t g = font.unicharToGlyph(c);
                SkRect bounds;
                font.getBounds(&g, 1, &bounds, nullptr);
                capHeight += bounds.height();
            }
            metrics->fCapHeight = SkToS16(SkScalarRoundToInt(capHeight / 2));
        }
    }
    // Fonts are always subset, so always prepend the subset tag.
    metrics->fPostScriptName.prepend(canon->nextFontSubsetTag());
    return canon->fTypefaceMetrics.set(id, std::move(metrics))->get();
}

getType()

SkAdvancedTypefaceMetrics::FontType SkPDFFont::getType ( ) const

inline

Returns the font type represented in this font. For Type0 fonts, returns the type of the descendant font.

Definition at line 44 of file SkPDFFont.h.

{ return fFontType; }

GetType1GlyphNames()

void SkPDFFont::GetType1GlyphNames ( const SkTypeface &  face, SkString *  dst  )

static

Definition at line 53 of file SkPDFFont.cpp.

                                                                        {
    face.getPostScriptGlyphNames(dst);
}

GetUnicodeMap()

const std::vector< SkUnichar > & SkPDFFont::GetUnicodeMap ( const SkTypeface *  typeface, SkPDFDocument *  canon  )

static

Definition at line 160 of file SkPDFFont.cpp.

                                                                             {
    SkASSERT(typeface);
    SkASSERT(canon);
    SkTypefaceID id = typeface->uniqueID();
    if (std::vector<SkUnichar>* ptr = canon->fToUnicodeMap.find(id)) {
        return *ptr;
    }
    std::vector<SkUnichar> buffer(typeface->countGlyphs());
    typeface->getGlyphToUnicodeMap(buffer.data());
    return *canon->fToUnicodeMap.set(id, std::move(buffer));
}

glyphToPDFFontEncoding()

SkGlyphID SkPDFFont::glyphToPDFFontEncoding ( SkGlyphID  gid ) const

inline

Convert the input glyph ID into the font encoding.

Definition at line 67 of file SkPDFFont.h.

                                                          {
        if (this->multiByteGlyphs() || gid == 0) {
            return gid;
        }
        SkASSERT(gid >= this->firstGlyphID() && gid <= this->lastGlyphID());
        SkASSERT(this->firstGlyphID() > 0);
        return gid - this->firstGlyphID() + 1;
    }

glyphUsage()

const SkPDFGlyphUse & SkPDFFont::glyphUsage ( ) const

inline

Definition at line 120 of file SkPDFFont.h.

{ return fGlyphUsage; }

hasGlyph()

bool SkPDFFont::hasGlyph ( SkGlyphID  gid )

inline

Return true if this font has an encoding for the passed glyph id.

Definition at line 62 of file SkPDFFont.h.

                                 {
        return (gid >= this->firstGlyphID() && gid <= this->lastGlyphID()) || gid == 0;
    }

indirectReference()

SkPDFIndirectReference SkPDFFont::indirectReference ( ) const

inline

Definition at line 81 of file SkPDFFont.h.

{ return fIndirectReference; }

IsMultiByte()

static bool SkPDFFont::IsMultiByte ( SkAdvancedTypefaceMetrics::FontType  type )

inlinestatic

Definition at line 50 of file SkPDFFont.h.

                                                                    {
        return type == SkAdvancedTypefaceMetrics::kType1CID_Font ||
               type == SkAdvancedTypefaceMetrics::kTrueType_Font ||
               type == SkAdvancedTypefaceMetrics::kCFF_Font;
    }

lastGlyphID()

SkGlyphID SkPDFFont::lastGlyphID ( ) const

inline

Definition at line 119 of file SkPDFFont.h.

{ return fGlyphUsage.lastGlyph(); }

multiByteGlyphs()

bool SkPDFFont::multiByteGlyphs ( ) const

inline

Returns true if this font encoding supports glyph IDs above 255.

Definition at line 58 of file SkPDFFont.h.

{ return SkPDFFont::IsMultiByte(this->getType()); }

noteGlyphUsage()

void SkPDFFont::noteGlyphUsage ( SkGlyphID  glyph )

inline

Definition at line 76 of file SkPDFFont.h.

                                         {
        SkASSERT(this->hasGlyph(glyph));
        fGlyphUsage.set(glyph);
    }

operator=()

SkPDFFont & SkPDFFont::operator= ( SkPDFFont &&  )

default

PopulateCommonFontDescriptor()

void SkPDFFont::PopulateCommonFontDescriptor ( SkPDFDict *  descriptor, const SkAdvancedTypefaceMetrics &  metrics, uint16_t  emSize, int16_t  defaultWidth  )

static

Definition at line 255 of file SkPDFFont.cpp.

                                                                   {
    descriptor->insertName("FontName", metrics.fPostScriptName);
    descriptor->insertInt("Flags", (size_t)(metrics.fStyle | kPdfSymbolic));
    descriptor->insertScalar("Ascent",
            scaleFromFontUnits(metrics.fAscent, emSize));
    descriptor->insertScalar("Descent",
            scaleFromFontUnits(metrics.fDescent, emSize));
    descriptor->insertScalar("StemV",
            scaleFromFontUnits(metrics.fStemV, emSize));
    descriptor->insertScalar("CapHeight",
            scaleFromFontUnits(metrics.fCapHeight, emSize));
    descriptor->insertInt("ItalicAngle", metrics.fItalicAngle);
    descriptor->insertObject("FontBBox",
                             SkPDFMakeArray(scaleFromFontUnits(metrics.fBBox.left(), emSize),
                                            scaleFromFontUnits(metrics.fBBox.bottom(), emSize),
                                            scaleFromFontUnits(metrics.fBBox.right(), emSize),
                                            scaleFromFontUnits(metrics.fBBox.top(), emSize)));
    if (defaultWidth > 0) {
        descriptor->insertScalar("MissingWidth",
                scaleFromFontUnits(defaultWidth, emSize));
    }
}

refTypeface()

sk_sp< SkTypeface > SkPDFFont::refTypeface ( ) const

inline

Definition at line 121 of file SkPDFFont.h.

{ return fTypeface; }

typeface()

SkTypeface * SkPDFFont::typeface ( ) const

inline

Returns the typeface represented by this class. Returns nullptr for the default typeface.

Definition at line 39 of file SkPDFFont.h.

{ return fTypeface.get(); }

---

The documentation for this class was generated from the following files:

• third_party/skia/src/pdf/SkPDFFont.h
• third_party/skia/src/pdf/SkPDFFont.cpp