SkTypeface.h

/*
 * 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 "../private/SkBitmaskEnum.h"
#include "../private/SkOnce.h"
#include "../private/SkWeakRefCnt.h"
#include "SkFontStyle.h"
#include "SkRect.h"
#include "SkString.h"

class SkDescriptor;
class SkFontData;
class SkFontDescriptor;
class SkScalerContext;
struct SkScalerContextRec;
struct SkScalerContextEffects;
class SkStream;
class SkStreamAsset;
class SkAdvancedTypefaceMetrics;
class SkWStream;

typedef uint32_t SkFontID;
typedef uint32_t SkFontTableTag;

class SK_API SkTypeface : public SkWeakRefCnt {
public:
    enum Style {
        kNormal = 0,
        kBold   = 0x01,
        kItalic = 0x02,

        // helpers
        kBoldItalic = 0x03
    };

    SkFontStyle fontStyle() const {
        return fStyle;
    }

    Style style() const {
        return static_cast<Style>(
            (fStyle.weight() >= SkFontStyle::kSemiBold_Weight ? kBold : kNormal) |
            (fStyle.slant()  != SkFontStyle::kUpright_Slant ? kItalic : kNormal));
    }

    bool isBold() const { return fStyle.weight() >= SkFontStyle::kSemiBold_Weight; }

    bool isItalic() const { return fStyle.slant() != SkFontStyle::kUpright_Slant; }

    bool isFixedPitch() const { return fIsFixedPitch; }

    SkFontID uniqueID() const { return fUniqueID; }

    static SkFontID UniqueID(const SkTypeface* face);

    static bool Equal(const SkTypeface* facea, const SkTypeface* faceb);

    static sk_sp<SkTypeface> MakeDefault(Style style = SkTypeface::kNormal);
#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
    static SkTypeface* RefDefault(Style style = SkTypeface::kNormal) {
        return MakeDefault(style).release();
    }
#endif

  static sk_sp<SkTypeface> MakeFromName(const char familyName[], SkFontStyle fontStyle);

#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
    static SkTypeface* CreateFromName(const char familyName[], Style style) {
        return MakeFromName(familyName, SkFontStyle::FromOldStyle(style)).release();
    }
#endif

    static sk_sp<SkTypeface> MakeFromTypeface(SkTypeface* family, Style);

    static sk_sp<SkTypeface> MakeFromFile(const char path[], int index = 0);
#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
    static SkTypeface* CreateFromFile(const char path[], int index = 0) {
        return MakeFromFile(path, index).release();
    }
#endif

    static sk_sp<SkTypeface> MakeFromStream(SkStreamAsset* stream, int index = 0);
#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
    static SkTypeface* CreateFromStream(SkStreamAsset* stream, int index = 0) {
        return MakeFromStream(stream, index).release();
    }
#endif

    static sk_sp<SkTypeface> MakeFromFontData(SkFontData*);

    void serialize(SkWStream*) const;

    static sk_sp<SkTypeface> MakeDeserialize(SkStream*);

    enum Encoding {
        kUTF8_Encoding,
        kUTF16_Encoding,
        kUTF32_Encoding
    };

    int charsToGlyphs(const void* chars, Encoding encoding, SkGlyphID glyphs[],
                      int glyphCount) 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;

    int getUnitsPerEm() const;

    bool getKerningPairAdjustments(const SkGlyphID glyphs[], int count,
                                   int32_t adjustments[]) const;

    struct LocalizedString {
        SkString fString;
        SkString fLanguage;
    };
    class LocalizedStrings : ::SkNoncopyable {
    public:
        virtual ~LocalizedStrings() { }
        virtual bool next(LocalizedString* localizedString) = 0;
        void unref() { delete this; }
    };
    LocalizedStrings* createFamilyNameIterator() const;

    void getFamilyName(SkString* name) const;

    SkStreamAsset* openStream(int* ttcIndex) const;

    SkFontData* createFontData() const;

    SkScalerContext* createScalerContext(const SkScalerContextEffects&, const SkDescriptor*,
                                         bool allowFailure = false) 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);
    }

protected:
    // The type of advance data wanted.
    enum PerGlyphInfo {
        kNo_PerGlyphInfo         = 0x0, // Don't populate any per glyph info.
        kGlyphNames_PerGlyphInfo = 0x1, // Populate glyph names (Type 1 only).
        kToUnicode_PerGlyphInfo  = 0x2  // Populate ToUnicode table, ignored
                                        // for Type 1 fonts
    };

    SkTypeface(const SkFontStyle& style, bool isFixedPitch = false);
    virtual ~SkTypeface();

    void setIsFixedPitch(bool isFixedPitch) { fIsFixedPitch = isFixedPitch; }
    void setFontStyle(SkFontStyle style) { fStyle = style; }

    friend class SkScalerContext;
    static SkTypeface* GetDefaultTypeface(Style style = SkTypeface::kNormal);

    virtual SkScalerContext* onCreateScalerContext(const SkScalerContextEffects&,
                                                   const SkDescriptor*) const = 0;
    virtual void onFilterRec(SkScalerContextRec*) const = 0;
    virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
                        PerGlyphInfo,
                        const uint32_t* glyphIDs,
                        uint32_t glyphIDsCount) const = 0;

    virtual SkStreamAsset* onOpenStream(int* ttcIndex) const = 0;
    // TODO: make pure virtual.
    virtual SkFontData* onCreateFontData() const;

    virtual void onGetFontDescriptor(SkFontDescriptor*, bool* isLocal) const = 0;

    virtual int onCharsToGlyphs(const void* chars, Encoding, SkGlyphID glyphs[],
                                int glyphCount) 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 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 bool onComputeBounds(SkRect*) const;

private:
    friend class SkGTypeface;
    friend class SkRandomTypeface;
    friend class SkPDFFont;
    friend class GrPathRendering;
    friend class GrGLPathRendering;

    SkAdvancedTypefaceMetrics* getAdvancedTypefaceMetrics(
                          PerGlyphInfo,
                          const uint32_t* glyphIDs = NULL,
                          uint32_t glyphIDsCount = 0) const;

private:
    SkFontID            fUniqueID;
    SkFontStyle         fStyle;
    mutable SkRect      fBounds;
    mutable SkOnce      fBoundsOnce;
    bool                fIsFixedPitch;

    friend class SkPaint;
    friend class SkGlyphCache;  // GetDefaultTypeface

    typedef SkWeakRefCnt INHERITED;
};

namespace skstd {
template <> struct is_bitmask_enum<SkTypeface::PerGlyphInfo> : std::true_type {};
}

#endif