refactor CPDF_Font and subclasses

core/include/fpdfapi/fpdf_resource.h

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #ifndef CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_
 #define CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_
 
 #include <map>
@@ skipping 64 matching lines @@
       --m_nCount;
   }
   size_t use_count() const { return m_nCount; }
 
  protected:
   size_t m_nCount;
   T* m_pObj;
 };
 using CPDF_CountedColorSpace = CPDF_CountedObject<CPDF_ColorSpace>;
 using CPDF_CountedPattern = CPDF_CountedObject<CPDF_Pattern>;
-#define PDFFONT_TYPE1 1
-#define PDFFONT_TRUETYPE 2
-#define PDFFONT_TYPE3 3
-#define PDFFONT_CIDFONT 4
+
 #define PDFFONT_FIXEDPITCH 1
 #define PDFFONT_SERIF 2
 #define PDFFONT_SYMBOLIC 4
 #define PDFFONT_SCRIPT 8
 #define PDFFONT_NONSYMBOLIC 32
 #define PDFFONT_ITALIC 64
 #define PDFFONT_ALLCAP 0x10000
 #define PDFFONT_SMALLCAP 0x20000
 #define PDFFONT_FORCEBOLD 0x40000
 #define PDFFONT_USEEXTERNATTR 0x80000
+
 class CPDF_Font {
  public:
   static CPDF_Font* CreateFontF(CPDF_Document* pDoc,
                                 CPDF_Dictionary* pFontDict);
   static CPDF_Font* GetStockFont(CPDF_Document* pDoc,
                                  const CFX_ByteStringC& fontname);
   static const FX_DWORD kInvalidCharCode = static_cast<FX_DWORD>(-1);
 
   virtual ~CPDF_Font();
 
-  bool IsFontType(int fonttype) const { return fonttype == m_FontType; }
-  int GetFontType() const { return m_FontType; }
+  // virtual Type GetFontType() const = 0;
+  virtual bool IsType1Font() const { return false; }
+  virtual bool IsTrueTypeFont() const { return false; }
+  virtual bool IsType3Font() const { return false; }
+  virtual bool IsCIDFont() const { return false; }
+  virtual const CPDF_Type1Font* AsType1Font() const { return nullptr; }
+  virtual CPDF_Type1Font* AsType1Font() { return nullptr; }
+  virtual const CPDF_TrueTypeFont* AsTrueTypeFont() const { return nullptr; }
+  virtual CPDF_TrueTypeFont* AsTrueTypeFont() { return nullptr; }
+  virtual const CPDF_Type3Font* AsType3Font() const { return nullptr; }
+  virtual CPDF_Type3Font* AsType3Font() { return nullptr; }
+  virtual const CPDF_CIDFont* AsCIDFont() const { return nullptr; }
+  virtual CPDF_CIDFont* AsCIDFont() { return nullptr; }
+
+  virtual FX_BOOL IsVertWriting() const;
+  virtual FX_BOOL IsUnicodeCompatible() const { return FALSE; }
+  virtual FX_DWORD GetNextChar(const FX_CHAR* pString,
+                               int nStrLen,
+                               int& offset) const;
+  virtual int CountChar(const FX_CHAR* pString, int size) const { return size; }
+  virtual int AppendChar(FX_CHAR* buf, FX_DWORD charcode) const;
+  virtual int GetCharSize(FX_DWORD charcode) const { return 1; }
+  virtual int GlyphFromCharCode(FX_DWORD charcode,
+                                FX_BOOL* pVertGlyph = NULL) = 0;
 
   CFX_ByteString GetFontTypeName() const;
-
   const CFX_ByteString& GetBaseFont() const { return m_BaseFont; }
-
   const CFX_SubstFont* GetSubstFont() const { return m_Font.GetSubstFont(); }
-
   FX_DWORD GetFlags() const { return m_Flags; }
-
-  virtual FX_BOOL IsVertWriting() const;
-
-  CPDF_Type1Font* GetType1Font() const {
-    return m_FontType == PDFFONT_TYPE1 ? (CPDF_Type1Font*)(void*)this : NULL;
-  }
-
-  CPDF_TrueTypeFont* GetTrueTypeFont() const {
-    return m_FontType == PDFFONT_TRUETYPE ? (CPDF_TrueTypeFont*)(void*)this
-                                          : NULL;
-  }
-
-  CPDF_CIDFont* GetCIDFont() const {
-    return (m_FontType == PDFFONT_CIDFONT) ? (CPDF_CIDFont*)(void*)this : NULL;
-  }
-
-  CPDF_Type3Font* GetType3Font() const {
-    return (m_FontType == PDFFONT_TYPE3) ? (CPDF_Type3Font*)(void*)this : NULL;
-  }
-
-  FX_BOOL IsEmbedded() const {
-    return m_FontType == PDFFONT_TYPE3 || m_pFontFile != NULL;
-  }
-
-  virtual FX_BOOL IsUnicodeCompatible() const { return FALSE; }
-
+  FX_BOOL IsEmbedded() const { return IsType3Font() || m_pFontFile != NULL; }
   CPDF_StreamAcc* GetFontFile() const { return m_pFontFile; }
-
   CPDF_Dictionary* GetFontDict() const { return m_pFontDict; }
-
   FX_BOOL IsStandardFont() const;
-
   FXFT_Face GetFace() const { return m_Font.GetFace(); }
 
-  virtual FX_DWORD GetNextChar(const FX_CHAR* pString,
-                               int nStrLen,
-                               int& offset) const {
-    if (offset < 0 || nStrLen < 1) {
-      return 0;
-    }
-    uint8_t ch = offset < nStrLen ? pString[offset++] : pString[nStrLen - 1];
-    return static_cast<FX_DWORD>(ch);
-  }
-
-  virtual int CountChar(const FX_CHAR* pString, int size) const { return size; }
-
   void AppendChar(CFX_ByteString& str, FX_DWORD charcode) const;
-
-  virtual int AppendChar(FX_CHAR* buf, FX_DWORD charcode) const {
-    *buf = (FX_CHAR)charcode;
-    return 1;
-  }
-
-  virtual int GetCharSize(FX_DWORD charcode) const { return 1; }
-
-  virtual int GlyphFromCharCode(FX_DWORD charcode,
-                                FX_BOOL* pVertGlyph = NULL) = 0;
-  virtual int GlyphFromCharCodeExt(FX_DWORD charcode) {
-    return GlyphFromCharCode(charcode);
-  }
-
   CFX_WideString UnicodeFromCharCode(FX_DWORD charcode) const;
-
   FX_DWORD CharCodeFromUnicode(FX_WCHAR Unicode) const;
 
   void GetFontBBox(FX_RECT& rect) const { rect = m_FontBBox; }
-
   int GetTypeAscent() const { return m_Ascent; }
-
   int GetTypeDescent() const { return m_Descent; }
-
   int GetItalicAngle() const { return m_ItalicAngle; }
-
   int GetStemV() const { return m_StemV; }
-
   int GetStringWidth(const FX_CHAR* pString, int size);
 
   virtual int GetCharWidthF(FX_DWORD charcode, int level = 0) = 0;
-
-  virtual int GetCharTypeWidth(FX_DWORD charcode);
-
   virtual void GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0) = 0;
 
   CPDF_Document* m_pDocument;
-
-  class CFX_PathData* LoadGlyphPath(FX_DWORD charcode, int dest_width = 0);
-
   CFX_Font m_Font;
 
  protected:
-  explicit CPDF_Font(int fonttype);
+  CPDF_Font();
+
+  virtual FX_BOOL _Load() = 0;
+  virtual FX_WCHAR _UnicodeFromCharCode(FX_DWORD charcode) const = 0;
+  virtual FX_DWORD _CharCodeFromUnicode(FX_WCHAR Unicode) const = 0;
 
   FX_BOOL Initialize();
-
   FX_BOOL Load();
-
-  virtual FX_BOOL _Load() = 0;
-
-  virtual FX_WCHAR _UnicodeFromCharCode(FX_DWORD charcode) const = 0;
-
-  virtual FX_DWORD _CharCodeFromUnicode(FX_WCHAR Unicode) const = 0;
-
   void LoadUnicodeMap();
-
   void LoadPDFEncoding(CPDF_Object* pEncoding,
                        int& iBaseEncoding,
                        CFX_ByteString*& pCharNames,
                        FX_BOOL bEmbedded,
                        FX_BOOL bTrueType);
-
   void LoadFontDescriptor(CPDF_Dictionary*);
-
-  void LoadCharWidths(FX_WORD* pWidths);
-
   void CheckFontMetrics();
 
   CFX_ByteString m_BaseFont;
+  CPDF_StreamAcc* m_pFontFile;
+  CPDF_Dictionary* m_pFontDict;
+  CPDF_ToUnicodeMap* m_pToUnicodeMap;
+  FX_BOOL m_bToUnicodeLoaded;
+  int m_Flags;
+  FX_RECT m_FontBBox;
+  int m_StemV;
+  int m_Ascent;
+  int m_Descent;
+  int m_ItalicAngle;
+};
 
-  CPDF_StreamAcc* m_pFontFile;
-
-  CPDF_Dictionary* m_pFontDict;
-
-  CPDF_ToUnicodeMap* m_pToUnicodeMap;
-
-  FX_BOOL m_bToUnicodeLoaded;
-
-  int m_Flags;
-
-  FX_RECT m_FontBBox;
-
-  int m_StemV;
-
-  int m_Ascent;
-
-  int m_Descent;
-
-  int m_ItalicAngle;
-
- private:
-  const int m_FontType;
-};
 #define PDFFONT_ENCODING_BUILTIN 0
 #define PDFFONT_ENCODING_WINANSI 1
 #define PDFFONT_ENCODING_MACROMAN 2
 #define PDFFONT_ENCODING_MACEXPERT 3
 #define PDFFONT_ENCODING_STANDARD 4
 #define PDFFONT_ENCODING_ADOBE_SYMBOL 5
 #define PDFFONT_ENCODING_ZAPFDINGBATS 6
 #define PDFFONT_ENCODING_PDFDOC 7
 #define PDFFONT_ENCODING_MS_SYMBOL 8
 #define PDFFONT_ENCODING_UNICODE 9
+
 class CPDF_FontEncoding {
  public:
   CPDF_FontEncoding();
 
   CPDF_FontEncoding(int PredefinedEncoding);
 
   void LoadEncoding(CPDF_Object* pEncoding);
 
   FX_BOOL IsIdentical(CPDF_FontEncoding* pAnother) const;
 
   FX_WCHAR UnicodeFromCharCode(uint8_t charcode) const {
     return m_Unicodes[charcode];
   }
 
   int CharCodeFromUnicode(FX_WCHAR unicode) const;
 
   void SetUnicode(uint8_t charcode, FX_WCHAR unicode) {
     m_Unicodes[charcode] = unicode;
   }
 
   CPDF_Object* Realize();
 
  public:
   FX_WCHAR m_Unicodes[256];
 };
 
 class CPDF_SimpleFont : public CPDF_Font {
  public:
-  explicit CPDF_SimpleFont(int fonttype);
+  CPDF_SimpleFont();
   ~CPDF_SimpleFont() override;
 
-  CPDF_FontEncoding* GetEncoding() { return &m_Encoding; }
+  // CPDF_Font:
   int GetCharWidthF(FX_DWORD charcode, int level = 0) override;
   void GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0) override;
   int GlyphFromCharCode(FX_DWORD charcode, FX_BOOL* pVertGlyph = NULL) override;
   FX_BOOL IsUnicodeCompatible() const override;
 
+  CPDF_FontEncoding* GetEncoding() { return &m_Encoding; }
+
  protected:
-  FX_BOOL LoadCommon();
-
-  void LoadSubstFont();
-
-  void LoadFaceMetrics();
-
   virtual void LoadGlyphMap() = 0;
 
-  FX_WCHAR _UnicodeFromCharCode(FX_DWORD charcode) const override {
-    return m_Encoding.UnicodeFromCharCode((uint8_t)charcode);
-  }
+  FX_BOOL LoadCommon();
+  void LoadSubstFont();
+  void LoadFaceMetrics();
+  void LoadCharMetrics(int charcode);
 
-  FX_DWORD _CharCodeFromUnicode(FX_WCHAR Unicode) const override {
-    return m_Encoding.CharCodeFromUnicode(Unicode);
-  }
-
-  void LoadCharMetrics(int charcode);
+  // CPDF_Font:
+  FX_WCHAR _UnicodeFromCharCode(FX_DWORD charcode) const override;
+  FX_DWORD _CharCodeFromUnicode(FX_WCHAR Unicode) const override;
 
   CPDF_FontEncoding m_Encoding;
   FX_WORD m_GlyphIndex[256];
   FX_WORD m_ExtGID[256];
   CFX_ByteString* m_pCharNames;
   int m_BaseEncoding;
   FX_WORD m_CharWidth[256];
   FX_SMALL_RECT m_CharBBox[256];
   FX_BOOL m_bUseFontWidth;
 };
 
 class CPDF_Type1Font : public CPDF_SimpleFont {
  public:
   CPDF_Type1Font();
 
-  int GetBase14Font() { return m_Base14Font; }
+  // CPDF_Font:
+  bool IsType1Font() const override { return true; }
+  const CPDF_Type1Font* AsType1Font() const override { return this; }
+  CPDF_Type1Font* AsType1Font() override { return this; }
+
+  int GetBase14Font() const { return m_Base14Font; }
 
  protected:
+  // CPDF_Font:
+  FX_BOOL _Load() override;
+
   // CPDF_SimpleFont:
-  int GlyphFromCharCodeExt(FX_DWORD charcode) override;
-  FX_BOOL _Load() override;
   void LoadGlyphMap() override;
 
   int m_Base14Font;
 };
+
 class CPDF_TrueTypeFont : public CPDF_SimpleFont {
  public:
   CPDF_TrueTypeFont();
 
+  // CPDF_Font

[Lei Zhang, 2016/02/25 01:54:02]

nit: add a colon, ditto below.

[Wei Li, 2016/02/25 18:48:42]

Done.

+  bool IsTrueTypeFont() const override { return true; }
+  const CPDF_TrueTypeFont* AsTrueTypeFont() const override { return this; }
+  CPDF_TrueTypeFont* AsTrueTypeFont() override { return this; }
+
  protected:
+  // CPDF_Font:
+  FX_BOOL _Load() override;
+
   // CPDF_SimpleFont:
-  FX_BOOL _Load() override;
   void LoadGlyphMap() override;
 };
 
 class CPDF_Type3Char {
  public:
   // Takes ownership of |pForm|.
   explicit CPDF_Type3Char(CPDF_Form* pForm);
   ~CPDF_Type3Char();
 
   FX_BOOL LoadBitmap(CPDF_RenderContext* pContext);
 
   CPDF_Form* m_pForm;
   CFX_DIBitmap* m_pBitmap;
   FX_BOOL m_bColored;
   int m_Width;
   CFX_Matrix m_ImageMatrix;
   FX_RECT m_BBox;
 };
 
 class CPDF_Type3Font : public CPDF_SimpleFont {
  public:
   CPDF_Type3Font();
   ~CPDF_Type3Font() override;
 
+  // CPDF_Font
+  bool IsType3Font() const override { return true; }
+  const CPDF_Type3Font* AsType3Font() const override { return this; }
+  CPDF_Type3Font* AsType3Font() override { return this; }
+  int GetCharWidthF(FX_DWORD charcode, int level = 0) override;
+  void GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0) override;
+
   void SetPageResources(CPDF_Dictionary* pResources) {
     m_pPageResources = pResources;
   }
   CPDF_Type3Char* LoadChar(FX_DWORD charcode, int level = 0);
-  int GetCharWidthF(FX_DWORD charcode, int level = 0) override;
-  int GetCharTypeWidth(FX_DWORD charcode) override {
-    return GetCharWidthF(charcode);
-  }
-  void GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0) override;
+  void CheckType3FontMetrics();
+
   CFX_Matrix& GetFontMatrix() { return m_FontMatrix; }
-  void CheckType3FontMetrics();
 
  protected:
   CFX_Matrix m_FontMatrix;
 
  private:
+  // CPDF_Font:
   FX_BOOL _Load() override;
+
+  // CPDF_SimpleFont:
   void LoadGlyphMap() override {}
 
   int m_CharWidthL[256];
   CPDF_Dictionary* m_pCharProcs;
   CPDF_Dictionary* m_pPageResources;
   CPDF_Dictionary* m_pFontResources;
   std::map<FX_DWORD, CPDF_Type3Char*> m_CacheMap;
 };
 
 enum CIDSet {
   CIDSET_UNKNOWN,
   CIDSET_GB1,
   CIDSET_CNS1,
   CIDSET_JAPAN1,
   CIDSET_KOREA1,
   CIDSET_UNICODE,
   CIDSET_NUM_SETS
 };
 
 class CPDF_CIDFont : public CPDF_Font {
  public:
   CPDF_CIDFont();
-
   ~CPDF_CIDFont() override;
 
   static FX_FLOAT CIDTransformToFloat(uint8_t ch);
 
   // CPDF_Font:
+  bool IsCIDFont() const override { return true; }
+  const CPDF_CIDFont* AsCIDFont() const override { return this; }
+  CPDF_CIDFont* AsCIDFont() override { return this; }
   int GlyphFromCharCode(FX_DWORD charcode, FX_BOOL* pVertGlyph = NULL) override;
   int GetCharWidthF(FX_DWORD charcode, int level = 0) override;
   void GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0) override;
   FX_DWORD GetNextChar(const FX_CHAR* pString,
                        int nStrLen,
                        int& offset) const override;
   int CountChar(const FX_CHAR* pString, int size) const override;
   int AppendChar(FX_CHAR* str, FX_DWORD charcode) const override;
   int GetCharSize(FX_DWORD charcode) const override;
   FX_BOOL IsVertWriting() const override;
   FX_BOOL IsUnicodeCompatible() const override;
   FX_BOOL _Load() override;
   FX_WCHAR _UnicodeFromCharCode(FX_DWORD charcode) const override;
   FX_DWORD _CharCodeFromUnicode(FX_WCHAR Unicode) const override;
 
   FX_BOOL LoadGB2312();
   FX_WORD CIDFromCharCode(FX_DWORD charcode) const;
-  FX_BOOL IsTrueType() const { return !m_bType1; }
   const uint8_t* GetCIDTransform(FX_WORD CID) const;
   short GetVertWidth(FX_WORD CID) const;
   void GetVertOrigin(FX_WORD CID, short& vx, short& vy) const;
   virtual FX_BOOL IsFontStyleFromCharCode(FX_DWORD charcode) const;
 
  protected:
   friend class CPDF_Font;
 
   int GetGlyphIndex(FX_DWORD unicodeb, FX_BOOL* pVertGlyph);
   void LoadMetricsArray(CPDF_Array* pArray,
@@ skipping 384 matching lines @@
 
   FX_BOOL m_bInterpolate;
 
   CPDF_Document* m_pDocument;
 
   CPDF_Dictionary* m_pOC;
   CPDF_Dictionary* InitJPEG(uint8_t* pData, FX_DWORD size);
 };
 
 #endif  // CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_