Home | History | Annotate | Download | only in pdf
      1 
      2 /*
      3  * Copyright 2011 Google Inc.
      4  *
      5  * Use of this source code is governed by a BSD-style license that can be
      6  * found in the LICENSE file.
      7  */
      8 
      9 
     10 #ifndef SkPDFFont_DEFINED
     11 #define SkPDFFont_DEFINED
     12 
     13 #include "SkAdvancedTypefaceMetrics.h"
     14 #include "SkBitSet.h"
     15 #include "SkPDFTypes.h"
     16 #include "SkTDArray.h"
     17 #include "SkThread.h"
     18 #include "SkTypeface.h"
     19 
     20 class SkPaint;
     21 class SkPDFCatalog;
     22 class SkPDFFont;
     23 
     24 class SkPDFGlyphSet : public SkNoncopyable {
     25 public:
     26     SkPDFGlyphSet();
     27 
     28     void set(const uint16_t* glyphIDs, int numGlyphs);
     29     bool has(uint16_t glyphID) const;
     30     void merge(const SkPDFGlyphSet& usage);
     31     void exportTo(SkTDArray<uint32_t>* glyphIDs) const;
     32 
     33 private:
     34     SkBitSet fBitSet;
     35 };
     36 
     37 class SkPDFGlyphSetMap : public SkNoncopyable {
     38 public:
     39     struct FontGlyphSetPair {
     40         FontGlyphSetPair(SkPDFFont* font, SkPDFGlyphSet* glyphSet);
     41 
     42         SkPDFFont* fFont;
     43         SkPDFGlyphSet* fGlyphSet;
     44     };
     45 
     46     SkPDFGlyphSetMap();
     47     ~SkPDFGlyphSetMap();
     48 
     49     class F2BIter {
     50     public:
     51         explicit F2BIter(const SkPDFGlyphSetMap& map);
     52         FontGlyphSetPair* next() const;
     53         void reset(const SkPDFGlyphSetMap& map);
     54 
     55     private:
     56         const SkTDArray<FontGlyphSetPair>* fMap;
     57         mutable int fIndex;
     58     };
     59 
     60     void merge(const SkPDFGlyphSetMap& usage);
     61     void reset();
     62 
     63     void noteGlyphUsage(SkPDFFont* font, const uint16_t* glyphIDs,
     64                         int numGlyphs);
     65 
     66 private:
     67     SkPDFGlyphSet* getGlyphSetForFont(SkPDFFont* font);
     68 
     69     SkTDArray<FontGlyphSetPair> fMap;
     70 };
     71 
     72 
     73 /** \class SkPDFFont
     74     A PDF Object class representing a font.  The font may have resources
     75     attached to it in order to embed the font.  SkPDFFonts are canonicalized
     76     so that resource deduplication will only include one copy of a font.
     77     This class uses the same pattern as SkPDFGraphicState, a static weak
     78     reference to each instantiated class.
     79 */
     80 class SkPDFFont : public SkPDFDict {
     81 public:
     82     virtual ~SkPDFFont();
     83 
     84     virtual void getResources(SkTDArray<SkPDFObject*>* resourceList);
     85 
     86     /** Returns the typeface represented by this class. Returns NULL for the
     87      *  default typeface.
     88      */
     89     SkTypeface* typeface();
     90 
     91     /** Returns the font type represented in this font.  For Type0 fonts,
     92      *  returns the type of the decendant font.
     93      */
     94     virtual SkAdvancedTypefaceMetrics::FontType getType();
     95 
     96     /** Returns true if this font encoding supports glyph IDs above 255.
     97      */
     98     virtual bool multiByteGlyphs() const = 0;
     99 
    100     /** Return true if this font has an encoding for the passed glyph id.
    101      */
    102     bool hasGlyph(uint16_t glyphID);
    103 
    104     /** Convert (in place) the input glyph IDs into the font encoding.  If the
    105      *  font has more glyphs than can be encoded (like a type 1 font with more
    106      *  than 255 glyphs) this method only converts up to the first out of range
    107      *  glyph ID.
    108      *  @param glyphIDs       The input text as glyph IDs.
    109      *  @param numGlyphs      The number of input glyphs.
    110      *  @return               Returns the number of glyphs consumed.
    111      */
    112     size_t glyphsToPDFFontEncoding(uint16_t* glyphIDs, size_t numGlyphs);
    113 
    114     /** Get the font resource for the passed typeface and glyphID. The
    115      *  reference count of the object is incremented and it is the caller's
    116      *  responsibility to unreference it when done.  This is needed to
    117      *  accommodate the weak reference pattern used when the returned object
    118      *  is new and has no other references.
    119      *  @param typeface  The typeface to find.
    120      *  @param glyphID   Specify which section of a large font is of interest.
    121      */
    122     static SkPDFFont* GetFontResource(SkTypeface* typeface,
    123                                              uint16_t glyphID);
    124 
    125     /** Subset the font based on usage set. Returns a SkPDFFont instance with
    126      *  subset.
    127      *  @param usage  Glyph subset requested.
    128      *  @return       NULL if font does not support subsetting, a new instance
    129      *                of SkPDFFont otherwise.
    130      */
    131     virtual SkPDFFont* getFontSubset(const SkPDFGlyphSet* usage);
    132 
    133 protected:
    134     // Common constructor to handle common members.
    135     SkPDFFont(SkAdvancedTypefaceMetrics* fontInfo, SkTypeface* typeface,
    136               uint16_t glyphID, bool descendantFont);
    137 
    138     // Accessors for subclass.
    139     SkAdvancedTypefaceMetrics* fontInfo();
    140     void setFontInfo(SkAdvancedTypefaceMetrics* info);
    141     uint16_t firstGlyphID() const;
    142     uint16_t lastGlyphID() const;
    143     void setLastGlyphID(uint16_t glyphID);
    144 
    145     // Add object to resource list.
    146     void addResource(SkPDFObject* object);
    147 
    148     // Accessors for FontDescriptor associated with this object.
    149     SkPDFDict* getFontDescriptor();
    150     void setFontDescriptor(SkPDFDict* descriptor);
    151 
    152     // Add common entries to FontDescriptor.
    153     bool addCommonFontDescriptorEntries(int16_t defaultWidth);
    154 
    155     /** Set fFirstGlyphID and fLastGlyphID to span at most 255 glyphs,
    156      *  including the passed glyphID.
    157      */
    158     void adjustGlyphRangeForSingleByteEncoding(int16_t glyphID);
    159 
    160     // Generate ToUnicode table according to glyph usage subset.
    161     // If subset is NULL, all available glyph ids will be used.
    162     void populateToUnicodeTable(const SkPDFGlyphSet* subset);
    163 
    164     // Create instances of derived types based on fontInfo.
    165     static SkPDFFont* Create(SkAdvancedTypefaceMetrics* fontInfo,
    166                              SkTypeface* typeface, uint16_t glyphID,
    167                              SkPDFDict* fontDescriptor);
    168 
    169     static bool Find(uint32_t fontID, uint16_t glyphID, int* index);
    170 
    171 private:
    172     class FontRec {
    173     public:
    174         SkPDFFont* fFont;
    175         uint32_t fFontID;
    176         uint16_t fGlyphID;
    177 
    178         // A fGlyphID of 0 with no fFont always matches.
    179         bool operator==(const FontRec& b) const;
    180         FontRec(SkPDFFont* font, uint32_t fontID, uint16_t fGlyphID);
    181     };
    182 
    183     SkAutoTUnref<SkTypeface> fTypeface;
    184 
    185     // The glyph IDs accessible with this font.  For Type1 (non CID) fonts,
    186     // this will be a subset if the font has more than 255 glyphs.
    187     uint16_t fFirstGlyphID;
    188     uint16_t fLastGlyphID;
    189     // The font info is only kept around after construction for large
    190     // Type1 (non CID) fonts that need multiple "fonts" to access all glyphs.
    191     SkAutoTUnref<SkAdvancedTypefaceMetrics> fFontInfo;
    192     SkTDArray<SkPDFObject*> fResources;
    193     SkAutoTUnref<SkPDFDict> fDescriptor;
    194 
    195     SkAdvancedTypefaceMetrics::FontType fFontType;
    196 
    197     // This should be made a hash table if performance is a problem.
    198     static SkTDArray<FontRec>& CanonicalFonts();
    199     static SkBaseMutex& CanonicalFontsMutex();
    200 };
    201 
    202 #endif
    203