SkTypeface.h

Go to the documentation of this file.

/*
 * Copyright 2006 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.
 */
 
#ifndef SkTypeface_DEFINED
#define SkTypeface_DEFINED
 
#include "include/core/SkFontArguments.h"
#include "include/core/SkFontParameters.h"
#include "include/core/SkFontStyle.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkString.h"
#include "include/core/SkTypes.h"
#include "include/private/SkWeakRefCnt.h"
#include "include/private/base/SkOnce.h"
 
#include <cstddef>
#include <cstdint>
#include <memory>
 
class SkData;
class SkDescriptor;
class SkFontMgr;
class SkFontDescriptor;
class SkScalerContext;
class SkStream;
class SkStreamAsset;
class SkWStream;
enum class SkTextEncoding;
struct SkAdvancedTypefaceMetrics;
struct SkScalerContextEffects;
struct SkScalerContextRec;
 
using SkTypefaceID = uint32_t;
 
typedef uint32_t SkFontTableTag;
 
class SK_API SkTypeface : public SkWeakRefCnt {
public:
    SkFontStyle fontStyle() const {
        return fStyle;
    }
 
    bool isBold() const { return fStyle.weight() >= SkFontStyle::kSemiBold_Weight; }
 
    bool isItalic() const { return fStyle.slant() != SkFontStyle::kUpright_Slant; }
 
    bool isFixedPitch() const { return fIsFixedPitch; }
 
    int getVariationDesignPosition(SkFontArguments::VariationPosition::Coordinate coordinates[],
                                   int coordinateCount) const;
 
    int getVariationDesignParameters(SkFontParameters::Variation::Axis parameters[],
                                     int parameterCount) const;
 
    SkTypefaceID uniqueID() const { return fUniqueID; }
 
    static bool Equal(const SkTypeface* facea, const SkTypeface* faceb);
 
#if !defined(SK_DISABLE_LEGACY_DEFAULT_TYPEFACE)
    static sk_sp<SkTypeface> MakeDefault();
#endif
    static sk_sp<SkTypeface> MakeEmpty();
 
#if !defined(SK_DISABLE_LEGACY_FONTMGR_REFDEFAULT)
    static sk_sp<SkTypeface> MakeFromName(const char familyName[], SkFontStyle fontStyle);
#endif
 
#if !defined(SK_DISABLE_LEGACY_FONTMGR_REFDEFAULT)
    static sk_sp<SkTypeface> MakeFromFile(const char path[], int index = 0);
#endif
 
#if !defined(SK_DISABLE_LEGACY_FONTMGR_REFDEFAULT)
    static sk_sp<SkTypeface> MakeFromStream(std::unique_ptr<SkStreamAsset> stream, int index = 0);
#endif
 
#if !defined(SK_DISABLE_LEGACY_FONTMGR_REFDEFAULT)
    static sk_sp<SkTypeface> MakeFromData(sk_sp<SkData>, int index = 0);
#endif
 
    sk_sp<SkTypeface> makeClone(const SkFontArguments&) const;
 
    enum class SerializeBehavior {
        kDoIncludeData,
        kDontIncludeData,
        kIncludeDataIfLocal,
    };
 
    void serialize(SkWStream*, SerializeBehavior = SerializeBehavior::kIncludeDataIfLocal) const;
 
    sk_sp<SkData> serialize(SerializeBehavior = SerializeBehavior::kIncludeDataIfLocal) const;
 
#if !defined(SK_DISABLE_LEGACY_FONTMGR_REFDEFAULT)
    static sk_sp<SkTypeface> MakeDeserialize(SkStream*);
#endif
    static sk_sp<SkTypeface> MakeDeserialize(SkStream*, sk_sp<SkFontMgr> lastResortMgr);
 
    void unicharsToGlyphs(const SkUnichar uni[], int count, SkGlyphID glyphs[]) const;
 
    int textToGlyphs(const void* text, size_t byteLength, SkTextEncoding encoding,
                     SkGlyphID glyphs[], int maxGlyphCount) const;
 
    SkGlyphID unicharToGlyph(SkUnichar unichar) const;
 
    int countGlyphs() const;
 
    // Table getters -- may fail if the underlying font format is not organized
    // as 4-byte tables.
 
    int countTables() const;
 
    int getTableTags(SkFontTableTag tags[]) const;
 
    size_t getTableSize(SkFontTableTag) const;
 
    size_t getTableData(SkFontTableTag tag, size_t offset, size_t length,
                        void* data) const;
 
    sk_sp<SkData> copyTableData(SkFontTableTag tag) const;
 
    int getUnitsPerEm() const;
 
    bool getKerningPairAdjustments(const SkGlyphID glyphs[], int count,
                                   int32_t adjustments[]) const;
 
    struct LocalizedString {
        SkString fString;
        SkString fLanguage;
    };
    class LocalizedStrings {
    public:
        LocalizedStrings() = default;
        virtual ~LocalizedStrings() { }
        virtual bool next(LocalizedString* localizedString) = 0;
        void unref() { delete this; }
 
    private:
        LocalizedStrings(const LocalizedStrings&) = delete;
        LocalizedStrings& operator=(const LocalizedStrings&) = delete;
    };
    LocalizedStrings* createFamilyNameIterator() const;
 
    void getFamilyName(SkString* name) const;
 
    bool getPostScriptName(SkString* name) const;
 
    std::unique_ptr<SkStreamAsset> openStream(int* ttcIndex) const;
 
    std::unique_ptr<SkStreamAsset> openExistingStream(int* ttcIndex) const;
 
    std::unique_ptr<SkScalerContext> createScalerContext(const SkScalerContextEffects&,
                                                         const SkDescriptor*) const;
 
    SkRect getBounds() const;
 
    // PRIVATE / EXPERIMENTAL -- do not call
    void filterRec(SkScalerContextRec* rec) const {
        this->onFilterRec(rec);
    }
    // PRIVATE / EXPERIMENTAL -- do not call
    void getFontDescriptor(SkFontDescriptor* desc, bool* isLocal) const {
        this->onGetFontDescriptor(desc, isLocal);
    }
    // PRIVATE / EXPERIMENTAL -- do not call
    void* internal_private_getCTFontRef() const {
        return this->onGetCTFontRef();
    }
 
    /* Skia reserves all tags that begin with a lower case letter and 0 */
    using FactoryId = SkFourByteTag;
    static void Register(
            FactoryId id,
            sk_sp<SkTypeface> (*make)(std::unique_ptr<SkStreamAsset>, const SkFontArguments&));
 
protected:
    explicit SkTypeface(const SkFontStyle& style, bool isFixedPitch = false);
    ~SkTypeface() override;
 
    virtual sk_sp<SkTypeface> onMakeClone(const SkFontArguments&) const = 0;
 
    void setIsFixedPitch(bool isFixedPitch) { fIsFixedPitch = isFixedPitch; }
    void setFontStyle(SkFontStyle style) { fStyle = style; }
 
    // Must return a valid scaler context. It can not return nullptr.
    virtual std::unique_ptr<SkScalerContext> onCreateScalerContext(const SkScalerContextEffects&,
                                                                   const SkDescriptor*) const = 0;
    virtual void onFilterRec(SkScalerContextRec*) const = 0;
    friend class SkScalerContext;  // onFilterRec
 
    //  Subclasses *must* override this method to work with the PDF backend.
    virtual std::unique_ptr<SkAdvancedTypefaceMetrics> onGetAdvancedMetrics() const = 0;
    // For type1 postscript fonts only, set the glyph names for each glyph.
    // destination array is non-null, and points to an array of size this->countGlyphs().
    // Backends that do not suport type1 fonts should not override.
    virtual void getPostScriptGlyphNames(SkString*) const = 0;
 
    // The mapping from glyph to Unicode; array indices are glyph ids.
    // For each glyph, give the default Unicode value, if it exists.
    // dstArray is non-null, and points to an array of size this->countGlyphs().
    virtual void getGlyphToUnicodeMap(SkUnichar* dstArray) const = 0;
 
    virtual std::unique_ptr<SkStreamAsset> onOpenStream(int* ttcIndex) const = 0;
 
    virtual std::unique_ptr<SkStreamAsset> onOpenExistingStream(int* ttcIndex) const;
 
    virtual bool onGlyphMaskNeedsCurrentColor() const = 0;
 
    virtual int onGetVariationDesignPosition(
        SkFontArguments::VariationPosition::Coordinate coordinates[],
        int coordinateCount) const = 0;
 
    virtual int onGetVariationDesignParameters(
        SkFontParameters::Variation::Axis parameters[], int parameterCount) const = 0;
 
    virtual void onGetFontDescriptor(SkFontDescriptor*, bool* isLocal) const = 0;
 
    virtual void onCharsToGlyphs(const SkUnichar* chars, int count, SkGlyphID glyphs[]) const = 0;
    virtual int onCountGlyphs() const = 0;
 
    virtual int onGetUPEM() const = 0;
    virtual bool onGetKerningPairAdjustments(const SkGlyphID glyphs[], int count,
                                             int32_t adjustments[]) const;
 
    virtual void onGetFamilyName(SkString* familyName) const = 0;
    virtual bool onGetPostScriptName(SkString*) const = 0;
 
    virtual LocalizedStrings* onCreateFamilyNameIterator() const = 0;
 
    virtual int onGetTableTags(SkFontTableTag tags[]) const = 0;
    virtual size_t onGetTableData(SkFontTableTag, size_t offset,
                                  size_t length, void* data) const = 0;
    virtual sk_sp<SkData> onCopyTableData(SkFontTableTag) const;
 
    virtual bool onComputeBounds(SkRect*) const;
 
    virtual void* onGetCTFontRef() const { return nullptr; }
 
private:
    bool glyphMaskNeedsCurrentColor() const;
    friend class SkStrikeServerImpl;  // glyphMaskNeedsCurrentColor
    friend class SkTypefaceProxyPrototype;  // glyphMaskNeedsCurrentColor
 
    std::unique_ptr<SkAdvancedTypefaceMetrics> getAdvancedMetrics() const;
    friend class SkRandomTypeface;   // getAdvancedMetrics
    friend class SkPDFFont;          // getAdvancedMetrics
 
    enum Style {
        kNormal = 0,
        kBold   = 0x01,
        kItalic = 0x02,
 
        // helpers
        kBoldItalic = 0x03
    };
    static SkFontStyle FromOldStyle(Style oldStyle);
    static SkTypeface* GetDefaultTypeface(Style style = SkTypeface::kNormal);
 
    friend class SkFontPriv;         // GetDefaultTypeface
    friend class SkPaintPriv;        // GetDefaultTypeface
    friend class SkFont;             // getGlyphToUnicodeMap
 
private:
    SkTypefaceID        fUniqueID;
    SkFontStyle         fStyle;
    mutable SkRect      fBounds;
    mutable SkOnce      fBoundsOnce;
    bool                fIsFixedPitch;
 
    using INHERITED = SkWeakRefCnt;
};
#endif