SkFont.h

Go to the documentation of this file.

/*
 * Copyright 2014 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#ifndef SkFont_DEFINED
#define SkFont_DEFINED
 
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkTo.h"
#include "include/private/base/SkTypeTraits.h"
 
#include <cstddef>
#include <cstdint>
#include <type_traits>
#include <utility>
#include <vector>
 
class SkMatrix;
class SkPaint;
class SkPath;
enum class SkFontHinting;
enum class SkTextEncoding;
struct SkFontMetrics;
struct SkPoint;
 
class SK_API SkFont {
public:
    enum class Edging {
        kAlias,              
        kAntiAlias,          
        kSubpixelAntiAlias,  
    };
 
    SkFont();
 
    SkFont(sk_sp<SkTypeface> typeface, SkScalar size);
 
    explicit SkFont(sk_sp<SkTypeface> typeface);
 
 
    SkFont(sk_sp<SkTypeface> typeface, SkScalar size, SkScalar scaleX, SkScalar skewX);
 
 
    bool operator==(const SkFont& font) const;
 
    bool operator!=(const SkFont& font) const { return !(*this == font); }
 
    bool isForceAutoHinting() const { return SkToBool(fFlags & kForceAutoHinting_PrivFlag); }
 
    bool isEmbeddedBitmaps() const { return SkToBool(fFlags & kEmbeddedBitmaps_PrivFlag); }
 
    bool isSubpixel() const { return SkToBool(fFlags & kSubpixel_PrivFlag); }
 
    bool isLinearMetrics() const { return SkToBool(fFlags & kLinearMetrics_PrivFlag); }
 
    bool isEmbolden() const { return SkToBool(fFlags & kEmbolden_PrivFlag); }
 
    bool isBaselineSnap() const { return SkToBool(fFlags & kBaselineSnap_PrivFlag); }
 
    void setForceAutoHinting(bool forceAutoHinting);
 
    void setEmbeddedBitmaps(bool embeddedBitmaps);
 
    void setSubpixel(bool subpixel);
 
    void setLinearMetrics(bool linearMetrics);
 
    void setEmbolden(bool embolden);
 
    void setBaselineSnap(bool baselineSnap);
 
    Edging getEdging() const { return (Edging)fEdging; }
 
    void setEdging(Edging edging);
 
    void setHinting(SkFontHinting hintingLevel);
 
    SkFontHinting getHinting() const { return (SkFontHinting)fHinting; }
 
    SkFont makeWithSize(SkScalar size) const;
 
    SkTypeface* getTypeface() const {return fTypeface.get(); }
 
    SkScalar    getSize() const { return fSize; }
 
    SkScalar    getScaleX() const { return fScaleX; }
 
    SkScalar    getSkewX() const { return fSkewX; }
 
    sk_sp<SkTypeface> refTypeface() const { return fTypeface; }
 
    void setTypeface(sk_sp<SkTypeface> tf) { fTypeface = std::move(tf); }
 
    void setSize(SkScalar textSize);
 
    void setScaleX(SkScalar scaleX);
 
    void setSkewX(SkScalar skewX);
 
    int textToGlyphs(const void* text, size_t byteLength, SkTextEncoding encoding,
                     SkGlyphID glyphs[], int maxGlyphCount) const;
 
    SkGlyphID unicharToGlyph(SkUnichar uni) const;
 
    void unicharsToGlyphs(const SkUnichar uni[], int count, SkGlyphID glyphs[]) const;
 
    int countText(const void* text, size_t byteLength, SkTextEncoding encoding) const {
        return this->textToGlyphs(text, byteLength, encoding, nullptr, 0);
    }
 
    SkScalar measureText(const void* text, size_t byteLength, SkTextEncoding encoding,
                         SkRect* bounds = nullptr) const {
        return this->measureText(text, byteLength, encoding, bounds, nullptr);
    }
 
    SkScalar measureText(const void* text, size_t byteLength, SkTextEncoding encoding,
                         SkRect* bounds, const SkPaint* paint) const;
 
    void getWidths(const SkGlyphID glyphs[], int count, SkScalar widths[], SkRect bounds[]) const {
        this->getWidthsBounds(glyphs, count, widths, bounds, nullptr);
    }
 
    // DEPRECATED
    void getWidths(const SkGlyphID glyphs[], int count, SkScalar widths[], std::nullptr_t) const {
        this->getWidths(glyphs, count, widths);
    }
 
    void getWidths(const SkGlyphID glyphs[], int count, SkScalar widths[]) const {
        this->getWidthsBounds(glyphs, count, widths, nullptr, nullptr);
    }
 
    void getWidthsBounds(const SkGlyphID glyphs[], int count, SkScalar widths[], SkRect bounds[],
                         const SkPaint* paint) const;
 
 
    void getBounds(const SkGlyphID glyphs[], int count, SkRect bounds[],
                   const SkPaint* paint) const {
        this->getWidthsBounds(glyphs, count, nullptr, bounds, paint);
    }
 
    void getPos(const SkGlyphID glyphs[], int count, SkPoint pos[], SkPoint origin = {0, 0}) const;
 
    void getXPos(const SkGlyphID glyphs[], int count, SkScalar xpos[], SkScalar origin = 0) const;
 
    std::vector<SkScalar> getIntercepts(const SkGlyphID glyphs[], int count, const SkPoint pos[],
                                        SkScalar top, SkScalar bottom,
                                        const SkPaint* = nullptr) const;
 
    bool getPath(SkGlyphID glyphID, SkPath* path) const;
 
    void getPaths(const SkGlyphID glyphIDs[], int count,
                  void (*glyphPathProc)(const SkPath* pathOrNull, const SkMatrix& mx, void* ctx),
                  void* ctx) const;
 
    SkScalar getMetrics(SkFontMetrics* metrics) const;
 
    SkScalar getSpacing() const { return this->getMetrics(nullptr); }
 
    void dump() const;
 
    using sk_is_trivially_relocatable = std::true_type;
 
private:
    enum PrivFlags {
        kForceAutoHinting_PrivFlag      = 1 << 0,
        kEmbeddedBitmaps_PrivFlag       = 1 << 1,
        kSubpixel_PrivFlag              = 1 << 2,
        kLinearMetrics_PrivFlag         = 1 << 3,
        kEmbolden_PrivFlag              = 1 << 4,
        kBaselineSnap_PrivFlag          = 1 << 5,
    };
 
    static constexpr unsigned kAllFlags = kForceAutoHinting_PrivFlag
                                        | kEmbeddedBitmaps_PrivFlag
                                        | kSubpixel_PrivFlag
                                        | kLinearMetrics_PrivFlag
                                        | kEmbolden_PrivFlag
                                        | kBaselineSnap_PrivFlag;
 
    sk_sp<SkTypeface> fTypeface;
    SkScalar    fSize;
    SkScalar    fScaleX;
    SkScalar    fSkewX;
    uint8_t     fFlags;
    uint8_t     fEdging;
    uint8_t     fHinting;
 
    static_assert(::sk_is_trivially_relocatable<decltype(fTypeface)>::value);
 
    SkScalar setupForAsPaths(SkPaint*);
    bool hasSomeAntiAliasing() const;
 
    friend class SkFontPriv;
    friend class SkGlyphRunListPainterCPU;
    friend class SkStrikeSpec;
    friend class SkRemoteGlyphCacheTest;
 
    sk_sp<SkTypeface> refTypefaceOrDefault() const;
    SkTypeface* getTypefaceOrDefault() const;
};
 
#endif