Basic support for Type3 Fonts in Pdf + various refactorings

experimental/PdfViewer/SkPdfFont.h

 #ifndef __DEFINED__SkPdfFont
 #define __DEFINED__SkPdfFont
 
 #include "SkPdfHeaders_autogen.h"
 #include "SkPdfPodofoMapper_autogen.h"
 
 #include <map>
 #include <string>
 
 #include "SkUtils.h"
+#include "SkPdfBasics.h"
+#include "SkPdfUtils.h"
+
 
 class SkPdfType0Font;
 class SkPdfType1Font;
 class SkPdfType3Font;
 class SkPdfTrueTypeFont;
 class SkPdfCIDFont;
 class SkPdfMultiMasterFont;
 class SkPdfFont;
 
 
@@ skipping 14 matching lines @@
 public:
     SkUnencodedText(const SkPdfObject* obj) {
         text = (void*)obj->podofo()->GetString().GetString();
         len = obj->podofo()->GetString().GetLength();
     }
 };
 
 struct SkDecodedText {
     uint16_t* text;
     int len;
+public:
+    unsigned int operator[](int i) const { return text[i]; }
+    int size() const { return len; }
 };
 
 struct SkUnicodeText {
     uint16_t* text;
     int len;
 
 public:
     unsigned int operator[](int i) const { return text[i]; }
     int size() const { return len; }
 };
 
 class SkPdfEncoding {
 public:
     virtual bool decodeText(const SkUnencodedText& textIn, SkDecodedText* textOut) const = 0;
+    static SkPdfEncoding* fromName(const char* name);
 };
 
+std::map<std::string, SkPdfEncoding*>& getStandardEncodings();
+
+class SkPdfToUnicode {
+    // TODO(edisonn): hide public members
+public:
+    unsigned short* fCMapEncoding;
+    unsigned char* fCMapEncodingFlag;
+
+    SkPdfToUnicode(const SkPdfStream* stream);
+};
+
+
 class SkPdfIdentityHEncoding : public SkPdfEncoding {
 public:
     virtual bool decodeText(const SkUnencodedText& textIn, SkDecodedText* textOut) const {
         // TODO(edisonn): SkASSERT(textIn.len % 2 == 0); or report error?
 
         uint16_t* text = (uint16_t*)textIn.text;
         textOut->text = new uint16_t[textIn.len / 2];
         textOut->len = textIn.len / 2;
 
         for (int i = 0; i < textOut->len; i++) {
             textOut->text[i] = ((text[i] << 8) & 0xff00) | ((text[i] >> 8) & 0x00ff);
         }
 
         return true;
     }
 
     static SkPdfIdentityHEncoding* instance() {
         static SkPdfIdentityHEncoding* inst = new SkPdfIdentityHEncoding();
         return inst;
     }
 };
 
+
+class SkPdfCIDToGIDMapIdentityEncoding : public SkPdfEncoding {
+public:
+    virtual bool decodeText(const SkUnencodedText& textIn, SkDecodedText* textOut) const {
+        // TODO(edisonn): SkASSERT(textIn.len % 2 == 0); or report error?
+
+        unsigned char* text = (unsigned char*)textIn.text;
+        textOut->text = new uint16_t[textIn.len];
+        textOut->len = textIn.len;
+
+        for (int i = 0; i < textOut->len; i++) {
+            textOut->text[i] = text[i];
+        }
+
+        return true;
+    }
+
+    static SkPdfCIDToGIDMapIdentityEncoding* instance() {
+        static SkPdfCIDToGIDMapIdentityEncoding* inst = new SkPdfCIDToGIDMapIdentityEncoding();
+        return inst;
+    }
+};
+
 class SkPdfFont {
 public:
     SkPdfFont* fBaseFont;
     SkPdfEncoding* fEncoding;
+    SkPdfToUnicode* fToUnicode;
+
 
 public:
-    SkPdfFont() : fBaseFont(NULL), fEncoding(SkPdfIdentityHEncoding::instance()) {}
+    SkPdfFont() : fBaseFont(NULL), fEncoding(NULL), fToUnicode(NULL) {}
 
     const SkPdfEncoding* encoding() const {return fEncoding;}
 
-    void drawText(const SkUnicodeText& text, SkPaint* paint, SkCanvas* canvas, SkMatrix* matrix) {
+    void drawText(const SkDecodedText& text, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas, SkMatrix* matrix) {
         for (int i = 0 ; i < text.size(); i++) {
-            drawOneChar(text[i], paint, canvas, matrix);
+            drawOneChar(text[i], paint, pdfContext, canvas, matrix);
         }
     }
 
-    virtual void ToUnicode(const SkDecodedText& textIn, SkUnicodeText* textOut) const {
-        textOut->text = textIn.text;
-        textOut->len = textIn.len;
+    void ToUnicode(const SkDecodedText& textIn, SkUnicodeText* textOut) const {
+        if (fToUnicode) {
+            textOut->text = new uint16_t[textIn.len];
+            textOut->len = textIn.len;
+            for (int i = 0; i < textIn.len; i++) {
+                textOut->text[i] = fToUnicode->fCMapEncoding[textIn.text[i]];
+            }
+        } else {
+            textOut->text = textIn.text;
+            textOut->len = textIn.len;
+        }
+    };
+
+    inline unsigned int ToUnicode(unsigned int ch) const {
+        if (fToUnicode) {
+            return fToUnicode->fCMapEncoding[ch];
+        } else {
+            return ch;
+        }
     };
 
     static SkPdfFont* fontFromPdfDictionary(SkPdfFontDictionary* dict);
     static SkPdfFont* Default() {return SkPdfFontFromName(NULL, "TimesNewRoman");}
 
     static SkPdfType0Font* fontFromType0FontDictionary(SkPdfType0FontDictionary* dict);
     static SkPdfType1Font* fontFromType1FontDictionary(SkPdfType1FontDictionary* dict);
     static SkPdfType3Font* fontFromType3FontDictionary(SkPdfType3FontDictionary* dict);
     static SkPdfTrueTypeFont* fontFromTrueTypeFontDictionary(SkPdfTrueTypeFontDictionary* dict);
     static SkPdfCIDFont* fontFromCIDFontDictionary(SkPdfCIDFontDictionary* dict);
     static SkPdfMultiMasterFont* fontFromMultiMasterFontDictionary(SkPdfMultiMasterFontDictionary* dict);
 
 public:
-    virtual void drawOneChar(unsigned int ch, SkPaint* paint, SkCanvas* canvas, SkMatrix* matrix) = 0;
+    virtual void drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas, SkMatrix* matrix) = 0;
     virtual void afterChar(SkPaint* paint, SkMatrix* matrix) = 0;
     virtual void afterWord(SkPaint* paint, SkMatrix* matrix) = 0;
 };
 
 class SkPdfStandardFont : public SkPdfFont {
     SkTypeface* fTypeface;
 
 public:
     SkPdfStandardFont(SkTypeface* typeface) : fTypeface(typeface) {}
 
 public:
-    virtual void drawOneChar(unsigned int ch, SkPaint* paint, SkCanvas* canvas, SkMatrix* matrix) {
+    virtual void drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas, SkMatrix* matrix) {
         paint->setTypeface(fTypeface);
         paint->setTextEncoding(SkPaint::kUTF8_TextEncoding);
 
         unsigned long ch4 = ch;
         char utf8[10];
         int len = SkUTF8_FromUnichar(ch4, utf8);
 
         canvas->drawText(utf8, len, SkDoubleToScalar(0), SkDoubleToScalar(0), *paint);
 
         SkScalar textWidth = paint->measureText(utf8, len);
         matrix->preTranslate(textWidth, SkDoubleToScalar(0.0));
     }
 
     virtual void afterChar(SkPaint* paint, SkMatrix* matrix) {}
     virtual void afterWord(SkPaint* paint, SkMatrix* matrix) {}
 };
 
-
 class SkPdfType0Font : public SkPdfFont {
-    unsigned short* fCMapEncoding;
-    unsigned char* fCMapEncodingFlag;
 public:
     SkPdfType0Font(SkPdfType0FontDictionary* dict);
 
 public:
-    virtual void ToUnicode(const SkDecodedText& textIn, SkUnicodeText* textOut) const {
-        textOut->text = new uint16_t[textIn.len];
-        textOut->len = textIn.len;
-        for (int i = 0; i < textIn.len; i++) {
-            textOut->text[i] = fCMapEncoding[textIn.text[i]];
-        }
-    };
 
-    virtual void drawOneChar(unsigned int ch, SkPaint* paint, SkCanvas* canvas, SkMatrix* matrix) {
-        fBaseFont->drawOneChar(ch, paint, canvas, matrix);
+    virtual void drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas, SkMatrix* matrix) {
+        fBaseFont->drawOneChar(ToUnicode(ch), paint, pdfContext, canvas, matrix);
     }
 
     virtual void afterChar(SkPaint* paint, SkMatrix* matrix) {
 
     }
 
     virtual void afterWord(SkPaint* paint, SkMatrix* matrix) {
-
     }
 };
 
 class SkPdfTrueTypeFont : public SkPdfFont {
 public:
     SkPdfTrueTypeFont(SkPdfTrueTypeFontDictionary* dict) {
         fBaseFont = SkPdfFontFromName(dict, dict->BaseFont().c_str());
     }
 
 public:
-    virtual void drawOneChar(unsigned int ch, SkPaint* paint, SkCanvas* canvas, SkMatrix* matrix) {
+    virtual void drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas, SkMatrix* matrix) {
 
     }
 
     virtual void afterChar(SkPaint* paint, SkMatrix* matrix) {
 
     }
 
     virtual void afterWord(SkPaint* paint, SkMatrix* matrix) {
 
     }
 };
 
 
 class SkPdfType1Font : public SkPdfFont {
 public:
     SkPdfType1Font(SkPdfType1FontDictionary* dict) {
         fBaseFont = SkPdfFontFromName(dict, dict->BaseFont().c_str());
     }
 
 
 public:
-      virtual void drawOneChar(unsigned int ch, SkPaint* paint, SkCanvas* canvas, SkMatrix* matrix) {
+      virtual void drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas, SkMatrix* matrix) {
 
       }
 
       virtual void afterChar(SkPaint* paint, SkMatrix* matrix) {
 
       }
 
       virtual void afterWord(SkPaint* paint, SkMatrix* matrix) {
 
       }
  };
 
 
 class SkPdfCIDFont : public SkPdfFont {
 public:
     SkPdfCIDFont(SkPdfCIDFontDictionary* dict) {
         fBaseFont = SkPdfFontFromName(dict, dict->BaseFont().c_str());
     }
 
 public:
-    virtual void drawOneChar(unsigned int ch, SkPaint* paint, SkCanvas* canvas, SkMatrix* matrix) {
+    virtual void drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas, SkMatrix* matrix) {
 
     }
 
     virtual void afterChar(SkPaint* paint, SkMatrix* matrix) {
 
     }
 
     virtual void afterWord(SkPaint* paint, SkMatrix* matrix) {
 
     }
 };
 
 class SkPdfMultiMasterFont : public SkPdfFont {
 public:
     SkPdfMultiMasterFont(SkPdfMultiMasterFontDictionary* dict) {
         fBaseFont = SkPdfFontFromName(dict, dict->BaseFont().c_str());
     }
 
 public:
-    virtual void drawOneChar(unsigned int ch, SkPaint* paint, SkCanvas* canvas, SkMatrix* matrix) {
+    virtual void drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas, SkMatrix* matrix) {
 
     }
 
     virtual void afterChar(SkPaint* paint, SkMatrix* matrix) {
 
     }
 
     virtual void afterWord(SkPaint* paint, SkMatrix* matrix) {
 
     }
 };
+/*
+class CIDToGIDMap {
+    virtual unsigned int map(unsigned int cid) = 0;
+    static CIDToGIDMap* fromName(const char* name);
+};
+
+class CIDToGIDMap_Identity {
+    virtual unsigned int map(unsigned int cid) { return cid; }
+
+    static CIDToGIDMap_Identity* instance() {
+        static CIDToGIDMap_Identity* inst = new CIDToGIDMap_Identity();
+        return inst;
+    }
+};
+
+CIDToGIDMap* CIDToGIDMap::fromName(const char* name) {
+    // The only one supported right now is Identity
+    if (strcmp(name, "Identity") == 0) {
+        return CIDToGIDMap_Identity::instance();
+    }
+
+#ifdef PDF_TRACE
+    // TODO(edisonn): warning/report
+    printf("Unknown CIDToGIDMap: %s\n", name);
+#endif
+    return NULL;
+}
+CIDToGIDMap* fCidToGid;
+*/
 
 class SkPdfType3Font : public SkPdfFont {
+    struct Type3FontChar {
+        SkPdfObject* fObj;
+        double fWidth;
+    };
+
+    SkPdfDictionary* fCharProcs;
+    SkPdfEncodingDictionary* fEncodingDict;
+    unsigned int fFirstChar;
+    unsigned int fLastChar;
+
+    SkRect fFontBBox;
+    SkMatrix fFonMatrix;
+
+    Type3FontChar* fChars;
+
 public:
     SkPdfType3Font(SkPdfType3FontDictionary* dict) {
         fBaseFont = SkPdfFontFromName(dict, dict->BaseFont().c_str());
+
+        if (dict->has_Encoding()) {
+            if (dict->isEncodingAName()) {
+                 fEncoding = SkPdfEncoding::fromName(dict->getEncodingAsName().c_str());
+            } else if (dict->isEncodingAEncodingdictionary()) {
+                 // technically, there is no encoding.
+                 fEncoding = SkPdfCIDToGIDMapIdentityEncoding::instance();
+                 fEncodingDict = dict->getEncodingAsEncodingdictionary();
+            }
+        }
+
+        // null?
+        fCharProcs = dict->CharProcs();
+
+        fToUnicode = NULL;
+        if (dict->has_ToUnicode()) {
+            fToUnicode = new SkPdfToUnicode(dict->ToUnicode());
+        }
+
+        fFirstChar = dict->FirstChar();
+        fLastChar = dict->LastChar();
+        fFonMatrix = dict->has_FontMatrix() ? *dict->FontMatrix() : SkMatrix::I();
+
+        if (dict->FontBBox()) {
+            fFontBBox = *dict->FontBBox();
+        }
+
+        fChars = new Type3FontChar[fLastChar - fFirstChar + 1];
+
+        memset(fChars, 0, sizeof(fChars[0]) * (fLastChar - fFirstChar + 1));
+
+
+        SkPdfArray* widths = dict->Widths();
+        for (int i = 0 ; i < widths->size(); i++) {
+            if ((fFirstChar + i) < fFirstChar || (fFirstChar + i) > fLastChar) {
+                printf("break; error 1\n");
+            }
+            fChars[i].fWidth = (*widths)[i]->asNumber()->value();
+        }
+
+        SkPdfArray* diffs = fEncodingDict->Differences();
+        int j = fFirstChar;
+        for (int i = 0 ; i < diffs->size(); i++) {
+            if ((*diffs)[i]->asInteger()) {
+                j = (*diffs)[i]->asInteger()->value();
+            } else if ((*diffs)[i]->asName()) {
+                if (j < fFirstChar || j > fLastChar) {
+                    printf("break; error 2\n");
+                }
+                fChars[j - fFirstChar].fObj = fCharProcs->get((*diffs)[i]->asName()->value().c_str());
+                j++;
+            } else {
+                // err
+            }
+        }
     }
 
 public:
-    virtual void drawOneChar(unsigned int ch, SkPaint* paint, SkCanvas* canvas, SkMatrix* matrix) {
+    virtual void drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas, SkMatrix* matrix) {
+        if (ch < fFirstChar || ch > fLastChar || !fChars[ch - fFirstChar].fObj) {
+            fBaseFont->drawOneChar(ToUnicode(ch), paint, pdfContext, canvas, matrix);
+            return;
+        }
 
+#ifdef PDF_TRACE
+        printf("Type 3 char to unicode: %c\n", ToUnicode(ch));
+        if (ToUnicode(ch) == 'A') {
+            printf("break;\n");
+        }
+#endif
+
+        doType3Char(pdfContext, canvas, fChars[ch - fFirstChar].fObj, fFontBBox, fFonMatrix, pdfContext->fGraphicsState.fCurFontSize);
     }
 
     virtual void afterChar(SkPaint* paint, SkMatrix* matrix) {
-
     }
 
     virtual void afterWord(SkPaint* paint, SkMatrix* matrix) {
 
     }
 };
 
 #endif  // __DEFINED__SkPdfFont