Basic support for Type3 Fonts in Pdf + various refactorings

experimental/PdfViewer/SkPdfFont.cpp

 #include "SkPdfFont.h"
 
 std::map<std::string, SkPdfStandardFontEntry>& getStandardFonts() {
     static std::map<std::string, SkPdfStandardFontEntry> gPdfStandardFonts;
 
     // TODO (edisonn): , vs - ? what does it mean?
     // TODO (edisonn): MT, PS, Oblique=italic?, ... what does it mean?
     if (gPdfStandardFonts.empty()) {
         gPdfStandardFonts["Arial"] = {"Arial", false, false};
         gPdfStandardFonts["Arial,Bold"] = {"Arial", true, false};
@@ skipping 52 matching lines @@
         gPdfStandardFonts["TimesNewRomanPS-Italic"] = {"Times New Roman", false, true};
         gPdfStandardFonts["TimesNewRomanPS-ItalicMT"] = {"Times New Roman", false, true};
         gPdfStandardFonts["TimesNewRomanPSMT"] = {"Times New Roman", false, false};
         gPdfStandardFonts["Symbol"] = {"Symbol", false, false};
         gPdfStandardFonts["ZapfDingbats"] = {"ZapfDingbats", false, false};
 
         // TODO(edisonn): these are hacks. Load Post Script font name.
         // see FT_Get_Postscript_Name
         // Font config is not using it, yet.
         //https://bugs.freedesktop.org/show_bug.cgi?id=18095
+
         gPdfStandardFonts["Arial-Black"] = {"Arial", true, false};
         gPdfStandardFonts["DejaVuSans"] = {"DejaVu Sans", false, false};
         gPdfStandardFonts["DejaVuSansMono"] = {"DejaVuSans Mono", false, false};
         gPdfStandardFonts["DejaVuSansMono-Bold"] = {"DejaVuSans Mono", true, false};
         gPdfStandardFonts["DejaVuSansMono-Oblique"] = {"DejaVuSans Mono", false, true};
         gPdfStandardFonts["Georgia-Bold"] = {"Georgia", true, false};
         gPdfStandardFonts["Georgia-BoldItalic"] = {"Georgia", true, true};
         gPdfStandardFonts["Georgia-Italic"] = {"Georgia", false, true};
         gPdfStandardFonts["TrebuchetMS"] = {"Trebuchet MS", false, false};
         gPdfStandardFonts["TrebuchetMS-Bold"] = {"Trebuchet MS", true, false};
         gPdfStandardFonts["Verdana-Bold"] = {"Verdana", true, false};
         gPdfStandardFonts["WenQuanYiMicroHei"] = {"WenQuanYi Micro Hei", false, false};
+
+        // TODO(edisonn): list all phonts available, builf post script name as in pdf spec
+        /*
+         * The PostScript name for the value of BaseFontis determined in one of two ways:
+• Use the PostScript name that is an optional entry in the “name” table of the
+TrueType font itself.
+• In the absence of such an entry in the “name” table, derive a PostScript name
+from the name by which the font is known in the host operating system: on a
+Windows system, it is based on the lfFaceName field in a LOGFONT structure; in
+the Mac OS, it is based on the name of the FONDresource. If the name contains
+any spaces, the spaces are removed.
+If the font in a source document uses a bold or italic style, but there is no font
+data for that style, the host operating system will synthesize the style. In this case,
+a comma and the style name (one of Bold, Italic, or BoldItalic) are appended to the
+font name. For example, for a TrueType font that is a bold variant of the New
+         */
+
+        /*
+         * If the value of Subtype is MMType1.
+• If the PostScript name of the instance contains spaces, the spaces are replaced
+by underscores in the value of BaseFont. For instance, as illustrated in Example
+5.7, the name “MinionMM 366 465 11 ” (which ends with a space character)
+becomes /MinionMM_366_465_11_.
+         */
+
+        // might not work on all oses ?
+        //
+
     }
 
     return gPdfStandardFonts;
 }
 
 SkTypeface* SkTypefaceFromPdfStandardFont(const char* fontName, bool bold, bool italic) {
     std::map<std::string, SkPdfStandardFontEntry>& standardFontMap = getStandardFonts();
 
     SkTypeface* typeface = NULL;
     if (standardFontMap.find(fontName) != standardFontMap.end()) {
@@ skipping 76 matching lines @@
     }
 
     return new SkPdfType1Font(dict);
 }
 
 SkPdfType3Font* SkPdfFont::fontFromType3FontDictionary(SkPdfType3FontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
+
+
     return new SkPdfType3Font(dict);
 }
 
 SkPdfTrueTypeFont* SkPdfFont::fontFromTrueTypeFontDictionary(SkPdfTrueTypeFontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
     return new SkPdfTrueTypeFont(dict);
 }
@@ skipping 15 matching lines @@
 }
 
 static int skstoi(const SkPdfString* str) {
     int ret = 0;
     for (int i = 0 ; i < str->podofo()->GetString().GetLength(); i++) {
         ret = (ret << 8) + ((unsigned char*)str->podofo()->GetString().GetString())[i];
     }
     return ret;
 }
 
-SkPdfType0Font::SkPdfType0Font(SkPdfType0FontDictionary* dict) {
-    fBaseFont = SkPdfFontFromName(dict, dict->BaseFont().c_str());
-
-    // TODO(edisonn): load encoding, let it now to be Identity-H by default
-    if (dict->has_Encoding()) {
-        if (dict->isEncodingAName()) {
-            //report encoding not supported
-            //fEncoding = loadEncodingFromName(dict->getEncodingAsName().c_str());
-        } else if (dict->isEncodingAStream()) {
-            //fEncoding = loadEncodingFromStream(dict->getEncodingAsStream());
-        } else {
-            // error
-        }
-    }
-
+SkPdfToUnicode::SkPdfToUnicode(const SkPdfStream* stream) {
     fCMapEncoding = NULL;
     fCMapEncodingFlag = NULL;
 
-    if (dict->has_ToUnicode()) {
-        const SkPdfStream* stream = dict->ToUnicode();
+    if (stream) {
         SkPdfTokenizer tokenizer(stream);
         PdfToken token;
 
         fCMapEncoding = new unsigned short[256 * 256];
         fCMapEncodingFlag = new unsigned char[256 * 256];
         for (int i = 0 ; i < 256 * 256; i++) {
             fCMapEncoding[i] = i;
             fCMapEncodingFlag[i] = 0;
         }
 
@@ skipping 65 matching lines @@
                         // read array
                     }
 
                     //fCMapEncodingFlag[from] = 1;
                     //fCMapEncoding[from] = to;
                 }
             }
         }
     }
 }
+
+
+SkPdfType0Font::SkPdfType0Font(SkPdfType0FontDictionary* dict) {
+    fBaseFont = SkPdfFontFromName(dict, dict->BaseFont().c_str());
+    fEncoding = NULL;
+
+    if (dict->has_Encoding()) {
+        if (dict->isEncodingAName()) {
+            fEncoding = SkPdfEncoding::fromName(dict->getEncodingAsName().c_str());
+        } else if (dict->isEncodingAStream()) {
+            //fEncoding = loadEncodingFromStream(dict->getEncodingAsStream());
+        } else {
+            // TODO(edisonn): error ... warning .. assert?
+        }
+    }
+
+    if (dict->has_ToUnicode()) {
+        fToUnicode = new SkPdfToUnicode(dict->ToUnicode());
+    }
+}
+
+std::map<std::string, SkPdfEncoding*>& getStandardEncodings() {
+    static std::map<std::string, SkPdfEncoding*> encodings;
+    if (encodings.empty()) {
+        encodings["Identity-H"] = SkPdfIdentityHEncoding::instance();
+    }
+
+    return encodings;
+}
+
+
+SkPdfEncoding* SkPdfEncoding::fromName(const char* name) {
+    SkPdfEncoding* encoding = getStandardEncodings()[name];
+
+#ifdef PDF_TRACE
+    if (encoding == NULL) {
+        printf("Encoding not found: %s\n", name);
+    }
+#endif
+    return encoding;
+}