pdfviewer: debug code for drawText (show magenta background for text, to show text even when we fai…

experimental/PdfViewer/SkPdfFont.cpp

 #include "SkPdfFont.h"
 
 #include "SkStream.h"
 #include "SkTypeface.h"
 #include "SkPdfNativeTokenizer.h"
 
 std::map<std::string, SkPdfStandardFontEntry>& getStandardFonts() {
     static std::map<std::string, SkPdfStandardFontEntry> gPdfStandardFonts;
 
     // TODO (edisonn): , vs - ? what does it mean?
@@ skipping 130 matching lines @@
             fontName,
             SkTypeface::kNormal);
     }
 
     if (typeface) {
         typeface->ref();
     }
     return typeface;
 }
 
-SkPdfFont* SkPdfFont::fontFromFontDescriptor(SkNativeParsedPDF* doc, SkPdfFontDescriptorDictionary* fd, bool loadFromName) {
+SkPdfFont* SkPdfFont::fontFromFontDescriptor(SkPdfNativeDoc* doc, SkPdfFontDescriptorDictionary* fd, bool loadFromName) {
     // TODO(edisonn): partial implementation ... also const handling ...
     // Only one, at most be available
     SkPdfStream* pdfStream = NULL;
     if (fd->has_FontFile()) {
         pdfStream = fd->FontFile(doc);
     } else if (fd->has_FontFile2()) {
         pdfStream = fd->FontFile2(doc);
     } if (fd->has_FontFile3()) {
         pdfStream = fd->FontFile3(doc);
     } else {
@@ skipping 19 matching lines @@
     if (face == NULL) {
         // TODO(edisonn): report warning to be used in testing.
         return NULL;
     }
 
     face->ref();
 
     return new SkPdfStandardFont(face);
 }
 
-SkPdfFont* fontFromName(SkNativeParsedPDF* doc, SkPdfObject* obj, const char* fontName) {
+SkPdfFont* fontFromName(SkPdfNativeDoc* doc, SkPdfNativeObject* obj, const char* fontName) {
     SkTypeface* typeface = SkTypefaceFromPdfStandardFont(fontName, false, false);
     if (typeface != NULL) {
         return new SkPdfStandardFont(typeface);
     }
 
     // TODO(edisonn): perf - make a map
     for (unsigned int i = 0 ; i < doc->objects(); i++) {
-        SkPdfObject* obj = doc->object(i);
+        SkPdfNativeObject* obj = doc->object(i);
         if (!obj || !obj->isDictionary()) {
             continue;
         }
 
         SkPdfFontDescriptorDictionary* fd = obj->asDictionary()->asFontDescriptorDictionary();
 
         if (!fd->valid()) {
             continue;
         }
 
         if (fd->has_FontName() && fd->FontName(doc) == fontName) {
             SkPdfFont* font = SkPdfFont::fontFromFontDescriptor(doc, fd, false);
             if (font) {
                 return font;
             } else {
                 // failed to load font descriptor
                 break;
             }
         }
     }
 
     // TODO(edisonn): warning/report issue
     return SkPdfFont::Default();
 }
 
-SkPdfFont* SkPdfFont::fontFromPdfDictionaryOnce(SkNativeParsedPDF* doc, SkPdfFontDictionary* dict) {
-    // TODO(edisonn): keep the type in a smart way in the SkPdfObject
+SkPdfFont* SkPdfFont::fontFromPdfDictionaryOnce(SkPdfNativeDoc* doc, SkPdfFontDictionary* dict) {
+    // TODO(edisonn): keep the type in a smart way in the SkPdfNativeObject
     // 1) flag, isResolved (1bit): reset at reset, add/remove/update (array) and set(dict)
     // in a tree like structure, 3-4 bits for all the datatypes inheriting from obj (int, real, ...)
     // if is a dict, reserveve a few bytes to encode type of dict, and so on like in a tree
     // issue: type can be determined from context! atribute night be missing/wrong
     switch (doc->mapper()->mapFontDictionary(dict)) {
-        case kType0FontDictionary_SkPdfObjectType:
+        case kType0FontDictionary_SkPdfNativeObjectType:
             return fontFromType0FontDictionary(doc, dict->asType0FontDictionary());
 
-        case kTrueTypeFontDictionary_SkPdfObjectType:
+        case kTrueTypeFontDictionary_SkPdfNativeObjectType:
             return fontFromTrueTypeFontDictionary(doc, dict->asTrueTypeFontDictionary());
 
-        case kType1FontDictionary_SkPdfObjectType:
+        case kType1FontDictionary_SkPdfNativeObjectType:
             return fontFromType1FontDictionary(doc, dict->asType1FontDictionary());
 
-        case kMultiMasterFontDictionary_SkPdfObjectType:
+        case kMultiMasterFontDictionary_SkPdfNativeObjectType:
             return fontFromMultiMasterFontDictionary(doc, dict->asMultiMasterFontDictionary());
 
-        case kType3FontDictionary_SkPdfObjectType:
+        case kType3FontDictionary_SkPdfNativeObjectType:
             return fontFromType3FontDictionary(doc, dict->asType3FontDictionary());
 
         default:
             // TODO(edisonn): report error?
             return NULL;
     }
 }
 
-SkPdfFont* SkPdfFont::fontFromPdfDictionary(SkNativeParsedPDF* doc, SkPdfFontDictionary* dict) {
+SkPdfFont* SkPdfFont::fontFromPdfDictionary(SkPdfNativeDoc* doc, SkPdfFontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // TODO(edisonn): report default one?
     }
 
-    if (!dict->hasData(SkPdfObject::kFont_Data)) {
-        dict->setData(fontFromPdfDictionaryOnce(doc, dict), SkPdfObject::kFont_Data);
+    if (!dict->hasData(SkPdfNativeObject::kFont_Data)) {
+        dict->setData(fontFromPdfDictionaryOnce(doc, dict), SkPdfNativeObject::kFont_Data);
     }
-    return (SkPdfFont*)dict->data(SkPdfObject::kFont_Data);
+    return (SkPdfFont*)dict->data(SkPdfNativeObject::kFont_Data);
 }
 
 
 
-SkPdfType0Font* SkPdfFont::fontFromType0FontDictionary(SkNativeParsedPDF* doc, SkPdfType0FontDictionary* dict) {
+SkPdfType0Font* SkPdfFont::fontFromType0FontDictionary(SkPdfNativeDoc* doc, SkPdfType0FontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
     return new SkPdfType0Font(doc, dict);
 }
 
-SkPdfType1Font* SkPdfFont:: fontFromType1FontDictionary(SkNativeParsedPDF* doc, SkPdfType1FontDictionary* dict) {
+SkPdfType1Font* SkPdfFont:: fontFromType1FontDictionary(SkPdfNativeDoc* doc, SkPdfType1FontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
     return new SkPdfType1Font(doc, dict);
 }
 
-SkPdfType3Font* SkPdfFont::fontFromType3FontDictionary(SkNativeParsedPDF* doc, SkPdfType3FontDictionary* dict) {
+SkPdfType3Font* SkPdfFont::fontFromType3FontDictionary(SkPdfNativeDoc* doc, SkPdfType3FontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
 
 
     return new SkPdfType3Font(doc, dict);
 }
 
-SkPdfTrueTypeFont* SkPdfFont::fontFromTrueTypeFontDictionary(SkNativeParsedPDF* doc, SkPdfTrueTypeFontDictionary* dict) {
+SkPdfTrueTypeFont* SkPdfFont::fontFromTrueTypeFontDictionary(SkPdfNativeDoc* doc, SkPdfTrueTypeFontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
     return new SkPdfTrueTypeFont(doc, dict);
 }
 
-SkPdfMultiMasterFont* SkPdfFont::fontFromMultiMasterFontDictionary(SkNativeParsedPDF* doc, SkPdfMultiMasterFontDictionary* dict) {
+SkPdfMultiMasterFont* SkPdfFont::fontFromMultiMasterFontDictionary(SkPdfNativeDoc* doc, SkPdfMultiMasterFontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
     return new SkPdfMultiMasterFont(doc, dict);
 }
 
-static int skstoi(const SkPdfObject* str) {
+static int skstoi(const SkPdfNativeObject* str) {
     // TODO(edisonn): report err of it is not a (hex) string
     int ret = 0;
     for (unsigned int i = 0 ; i < str->lenstr(); i++) {
         ret = (ret << 8) + ((unsigned char*)str->c_str())[i];
     }
     // TODO(edisonn): character larger than 0x0000ffff not supported right now.
     return ret & 0x0000ffff;
 }
 
 #define tokenIsKeyword(token,keyword) (token.fType == kKeyword_TokenType && token.fKeywordLength==sizeof(keyword)-1 && strncmp(token.fKeyword, keyword, sizeof(keyword)-1) == 0)
 
-SkPdfToUnicode::SkPdfToUnicode(SkNativeParsedPDF* parsed, SkPdfStream* stream) : fParsed(parsed) {
+SkPdfToUnicode::SkPdfToUnicode(SkPdfNativeDoc* parsed, SkPdfStream* stream) : fParsed(parsed) {
     fCMapEncoding = NULL;
     fCMapEncodingFlag = NULL;
 
     if (stream) {
         // Since font will be cached, the font has to sit in the per doc allocator, not to be
         // freed after the page is done drawing.
         SkPdfNativeTokenizer* tokenizer = fParsed->tokenizerOfStream(stream, parsed->allocator());
         PdfToken token;
 
         fCMapEncoding = new unsigned short[256 * 256];
@@ skipping 75 matching lines @@
 
                     //fCMapEncodingFlag[from] = 1;
                     //fCMapEncoding[from] = to;
                 }
             }
         }
     }
 }
 
 
-SkPdfType0Font::SkPdfType0Font(SkNativeParsedPDF* doc, SkPdfType0FontDictionary* dict) {
+SkPdfType0Font::SkPdfType0Font(SkPdfNativeDoc* doc, SkPdfType0FontDictionary* dict) {
     fBaseFont = fontFromName(doc, dict, dict->BaseFont(doc).c_str());
     fEncoding = NULL;
 
     if (dict->has_Encoding()) {
         if (dict->isEncodingAName(doc)) {
             fEncoding = SkPdfEncoding::fromName(dict->getEncodingAsName(doc).c_str());
         } else if (dict->isEncodingAStream(doc)) {
             //fEncoding = loadEncodingFromStream(dict->getEncodingAsStream());
         } else {
             // TODO(edisonn): error ... warning .. assert?
@@ skipping 18 matching lines @@
 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;
 }