pdfviewer: 1) debug code for drawText (show magenta background for text, to show text even when we fail to load/show it), 2) some cleanup: refactor and rename classes and files
Review URL: https://codereview.chromium.org/23020003
git-svn-id: http://skia.googlecode.com/svn/trunk@10716 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/experimental/PdfViewer/SkPdfConfig.h b/experimental/PdfViewer/SkPdfConfig.h
index 3d24a86..014f089 100644
--- a/experimental/PdfViewer/SkPdfConfig.h
+++ b/experimental/PdfViewer/SkPdfConfig.h
@@ -3,38 +3,10 @@
//#define PDF_TRACE
//#define PDF_TRACE_READ_TOKEN
+//#define PDF_TRACE_DRAWTEXT
//#define PDF_TRACE_DIFF_IN_PNG
//#define PDF_DEBUG_NO_CLIPING
//#define PDF_DEBUG_NO_PAGE_CLIPING
//#define PDF_DEBUG_3X
-// TODO(edisonn): move in trace util.
-#ifdef PDF_TRACE
-void SkTraceMatrix(const SkMatrix& matrix, const char* sz);
-void SkTraceRect(const SkRect& rect, const char* sz);
-#else
-#define SkTraceMatrix(a,b)
-#define SkTraceRect(a,b)
-#endif
-
-struct NotOwnedString {
- const unsigned char* fBuffer;
- size_t fBytes;
-
- static void init(NotOwnedString* str) {
- str->fBuffer = NULL;
- str->fBytes = 0;
- }
-
- static void init(NotOwnedString* str, const char* sz) {
- str->fBuffer = (const unsigned char*)sz;
- str->fBytes = strlen(sz);
- }
-
- bool equals(const char* sz) {
- return strncmp((const char*)fBuffer, sz, fBytes) == 0 && fBytes == strlen(sz);
-
- }
-};
-
#endif // __DEFINED__SkPdfConfig
diff --git a/experimental/PdfViewer/SkPdfFont.cpp b/experimental/PdfViewer/SkPdfFont.cpp
index 5d8cfe6..46cbf57 100644
--- a/experimental/PdfViewer/SkPdfFont.cpp
+++ b/experimental/PdfViewer/SkPdfFont.cpp
@@ -148,7 +148,7 @@
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;
@@ -188,7 +188,7 @@
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);
@@ -196,7 +196,7 @@
// 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;
}
@@ -222,26 +222,26 @@
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:
@@ -250,20 +250,20 @@
}
}
-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?
}
@@ -271,7 +271,7 @@
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?
}
@@ -279,7 +279,7 @@
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?
}
@@ -289,7 +289,7 @@
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?
}
@@ -297,7 +297,7 @@
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?
}
@@ -305,7 +305,7 @@
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++) {
@@ -317,7 +317,7 @@
#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;
@@ -413,7 +413,7 @@
}
-SkPdfType0Font::SkPdfType0Font(SkNativeParsedPDF* doc, SkPdfType0FontDictionary* dict) {
+SkPdfType0Font::SkPdfType0Font(SkPdfNativeDoc* doc, SkPdfType0FontDictionary* dict) {
fBaseFont = fontFromName(doc, dict, dict->BaseFont(doc).c_str());
fEncoding = NULL;
diff --git a/experimental/PdfViewer/SkPdfFont.h b/experimental/PdfViewer/SkPdfFont.h
index bbbaa7a..386aaf5 100644
--- a/experimental/PdfViewer/SkPdfFont.h
+++ b/experimental/PdfViewer/SkPdfFont.h
@@ -9,7 +9,7 @@
#include "SkTypeface.h"
#include "SkUtils.h"
-#include "SkPdfBasics.h"
+#include "SkPdfGraphicsState.h"
#include "SkPdfUtils.h"
@@ -38,7 +38,7 @@
std::map<std::string, SkPdfStandardFontEntry>& getStandardFonts();
SkTypeface* SkTypefaceFromPdfStandardFont(const char* fontName, bool bold, bool italic);
-SkPdfFont* fontFromName(SkNativeParsedPDF* doc, SkPdfObject* obj, const char* fontName);
+SkPdfFont* fontFromName(SkPdfNativeDoc* doc, SkPdfNativeObject* obj, const char* fontName);
struct SkUnencodedText {
void* text;
@@ -77,13 +77,13 @@
std::map<std::string, SkPdfEncoding*>& getStandardEncodings();
class SkPdfToUnicode {
- SkNativeParsedPDF* fParsed;
+ SkPdfNativeDoc* fParsed;
// TODO(edisonn): hide public members
public:
unsigned short* fCMapEncoding;
unsigned char* fCMapEncodingFlag;
- SkPdfToUnicode(SkNativeParsedPDF* parsed, SkPdfStream* stream);
+ SkPdfToUnicode(SkPdfNativeDoc* parsed, SkPdfStream* stream);
};
@@ -170,7 +170,7 @@
const SkPdfEncoding* encoding() const {return fEncoding;}
- void drawText(const SkDecodedText& text, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas) {
+ void drawText(const SkDecodedText& text, SkPaint* paint, SkPdfContext* pdfContext, SkCanvas* canvas) {
for (int i = 0 ; i < text.size(); i++) {
canvas->setMatrix(pdfContext->fGraphicsState.fMatrixTm);
#ifdef PDF_TRACE
@@ -178,6 +178,16 @@
pdfContext->fGraphicsState.fMatrixTm.mapPoints(&point, 1);
printf("DrawText at (%f, %f)\n", SkScalarToDouble(point.x()), SkScalarToDouble(point.y()));
#endif // PDF_TRACE
+
+#ifdef PDF_TRACE_DRAWTEXT
+ SkPaint col;
+ col.setColor(SK_ColorMAGENTA);
+ SkRect rect = SkRect::MakeXYWH(SkDoubleToScalar(0.0), SkDoubleToScalar(0.0), SkDoubleToScalar(10.0), SkDoubleToScalar(10.0));
+ canvas->save();
+ canvas->setMatrix(pdfContext->fGraphicsState.fMatrixTm);
+ canvas->drawRect(rect, col);
+ canvas->restore();
+#endif
double width = drawOneChar(text[i], paint, pdfContext, canvas);
pdfContext->fGraphicsState.fMatrixTm.preTranslate(SkDoubleToScalar(width), SkDoubleToScalar(0.0));
}
@@ -204,23 +214,23 @@
}
};
- static SkPdfFont* fontFromPdfDictionary(SkNativeParsedPDF* doc, SkPdfFontDictionary* dict);
+ static SkPdfFont* fontFromPdfDictionary(SkPdfNativeDoc* doc, SkPdfFontDictionary* dict);
static SkPdfFont* Default() {return fontFromName(NULL, NULL, "TimesNewRoman");}
- static SkPdfType0Font* fontFromType0FontDictionary(SkNativeParsedPDF* doc, SkPdfType0FontDictionary* dict);
- static SkPdfType1Font* fontFromType1FontDictionary(SkNativeParsedPDF* doc, SkPdfType1FontDictionary* dict);
- static SkPdfType3Font* fontFromType3FontDictionary(SkNativeParsedPDF* doc, SkPdfType3FontDictionary* dict);
- static SkPdfTrueTypeFont* fontFromTrueTypeFontDictionary(SkNativeParsedPDF* doc, SkPdfTrueTypeFontDictionary* dict);
- static SkPdfMultiMasterFont* fontFromMultiMasterFontDictionary(SkNativeParsedPDF* doc, SkPdfMultiMasterFontDictionary* dict);
+ static SkPdfType0Font* fontFromType0FontDictionary(SkPdfNativeDoc* doc, SkPdfType0FontDictionary* dict);
+ static SkPdfType1Font* fontFromType1FontDictionary(SkPdfNativeDoc* doc, SkPdfType1FontDictionary* dict);
+ static SkPdfType3Font* fontFromType3FontDictionary(SkPdfNativeDoc* doc, SkPdfType3FontDictionary* dict);
+ static SkPdfTrueTypeFont* fontFromTrueTypeFontDictionary(SkPdfNativeDoc* doc, SkPdfTrueTypeFontDictionary* dict);
+ static SkPdfMultiMasterFont* fontFromMultiMasterFontDictionary(SkPdfNativeDoc* doc, SkPdfMultiMasterFontDictionary* dict);
- static SkPdfFont* fontFromFontDescriptor(SkNativeParsedPDF* doc, SkPdfFontDescriptorDictionary* fd, bool loadFromName = true);
+ static SkPdfFont* fontFromFontDescriptor(SkPdfNativeDoc* doc, SkPdfFontDescriptorDictionary* fd, bool loadFromName = true);
public:
- virtual double drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas) = 0;
+ virtual double drawOneChar(unsigned int ch, SkPaint* paint, SkPdfContext* pdfContext, SkCanvas* canvas) = 0;
virtual void afterWord(SkPaint* paint, SkMatrix* matrix) = 0;
private:
- static SkPdfFont* fontFromPdfDictionaryOnce(SkNativeParsedPDF* doc, SkPdfFontDictionary* dict);
+ static SkPdfFont* fontFromPdfDictionaryOnce(SkPdfNativeDoc* doc, SkPdfFontDictionary* dict);
};
class SkPdfStandardFont : public SkPdfFont {
@@ -230,7 +240,7 @@
SkPdfStandardFont(SkTypeface* typeface) : fTypeface(typeface) {}
public:
- virtual double drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas) {
+ virtual double drawOneChar(unsigned int ch, SkPaint* paint, SkPdfContext* pdfContext, SkCanvas* canvas) {
paint->setTypeface(fTypeface);
paint->setTextEncoding(SkPaint::kUTF8_TextEncoding);
@@ -249,11 +259,11 @@
class SkPdfType0Font : public SkPdfFont {
public:
- SkPdfType0Font(SkNativeParsedPDF* doc, SkPdfType0FontDictionary* dict);
+ SkPdfType0Font(SkPdfNativeDoc* doc, SkPdfType0FontDictionary* dict);
public:
- virtual double drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas) {
+ virtual double drawOneChar(unsigned int ch, SkPaint* paint, SkPdfContext* pdfContext, SkCanvas* canvas) {
return fBaseFont->drawOneChar(ToUnicode(ch), paint, pdfContext, canvas);
}
@@ -263,16 +273,23 @@
class SkPdfType1Font : public SkPdfFont {
public:
- SkPdfType1Font(SkNativeParsedPDF* doc, SkPdfType1FontDictionary* dict) {
+ SkPdfType1Font(SkPdfNativeDoc* doc, SkPdfType1FontDictionary* dict) {
if (dict->has_FontDescriptor()) {
fBaseFont = SkPdfFont::fontFromFontDescriptor(doc, dict->FontDescriptor(doc));
} else {
fBaseFont = fontFromName(doc, dict, dict->BaseFont(doc).c_str());
}
+
+ if (dict->isEncodingAName(doc)) {
+ fEncoding = SkPdfEncoding::fromName(dict->getEncodingAsName(doc).c_str());
+ } else if (dict->isEncodingADictionary(doc)) {
+ //SkPdfDictionary* dictEnc = dict->getEncodingAsDictionary(doc);
+ }
+ dict->FontDescriptor(doc);
}
public:
- virtual double drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas) {
+ virtual double drawOneChar(unsigned int ch, SkPaint* paint, SkPdfContext* pdfContext, SkCanvas* canvas) {
return fBaseFont->drawOneChar(ToUnicode(ch), paint, pdfContext, canvas);
}
@@ -283,13 +300,13 @@
class SkPdfTrueTypeFont : public SkPdfType1Font {
public:
- SkPdfTrueTypeFont(SkNativeParsedPDF* doc, SkPdfTrueTypeFontDictionary* dict) : SkPdfType1Font(doc, dict) {
+ SkPdfTrueTypeFont(SkPdfNativeDoc* doc, SkPdfTrueTypeFontDictionary* dict) : SkPdfType1Font(doc, dict) {
}
};
class SkPdfMultiMasterFont : public SkPdfType1Font {
public:
- SkPdfMultiMasterFont(SkNativeParsedPDF* doc, SkPdfMultiMasterFontDictionary* dict) : SkPdfType1Font(doc, dict) {
+ SkPdfMultiMasterFont(SkPdfNativeDoc* doc, SkPdfMultiMasterFontDictionary* dict) : SkPdfType1Font(doc, dict) {
}
};
/*
@@ -324,7 +341,7 @@
class SkPdfType3Font : public SkPdfFont {
struct Type3FontChar {
- SkPdfObject* fObj;
+ SkPdfNativeObject* fObj;
double fWidth;
};
@@ -339,7 +356,7 @@
Type3FontChar* fChars;
public:
- SkPdfType3Font(SkNativeParsedPDF* parsed, SkPdfType3FontDictionary* dict) {
+ SkPdfType3Font(SkPdfNativeDoc* parsed, SkPdfType3FontDictionary* dict) {
fBaseFont = fontFromName(parsed, dict, dict->BaseFont(parsed).c_str());
if (dict->has_Encoding()) {
@@ -400,7 +417,7 @@
}
public:
- virtual double drawOneChar(unsigned int ch, SkPaint* paint, PdfContext* pdfContext, SkCanvas* canvas) {
+ virtual double drawOneChar(unsigned int ch, SkPaint* paint, SkPdfContext* pdfContext, SkCanvas* canvas) {
if (ch < fFirstChar || ch > fLastChar || !fChars[ch - fFirstChar].fObj) {
return fBaseFont->drawOneChar(ToUnicode(ch), paint, pdfContext, canvas);
}
diff --git a/experimental/PdfViewer/SkPdfBasics.cpp b/experimental/PdfViewer/SkPdfGraphicsState.cpp
similarity index 91%
rename from experimental/PdfViewer/SkPdfBasics.cpp
rename to experimental/PdfViewer/SkPdfGraphicsState.cpp
index b9b57f3..3e7f7a8 100644
--- a/experimental/PdfViewer/SkPdfBasics.cpp
+++ b/experimental/PdfViewer/SkPdfGraphicsState.cpp
@@ -1,14 +1,14 @@
-#include "SkPdfBasics.h"
+#include "SkPdfGraphicsState.h"
#include "SkPdfNativeTokenizer.h"
#include "SkDashPathEffect.h"
-PdfContext::PdfContext(SkNativeParsedPDF* doc)
+SkPdfContext::SkPdfContext(SkPdfNativeDoc* doc)
: fPdfDoc(doc)
, fTmpPageAllocator(new SkPdfAllocator()) {
}
-PdfContext::~PdfContext() {
+SkPdfContext::~SkPdfContext() {
delete fTmpPageAllocator;
}
diff --git a/experimental/PdfViewer/SkPdfBasics.h b/experimental/PdfViewer/SkPdfGraphicsState.h
similarity index 93%
rename from experimental/PdfViewer/SkPdfBasics.h
rename to experimental/PdfViewer/SkPdfGraphicsState.h
index 9306ad5..d00c258 100644
--- a/experimental/PdfViewer/SkPdfBasics.h
+++ b/experimental/PdfViewer/SkPdfGraphicsState.h
@@ -4,19 +4,17 @@
#include "SkCanvas.h"
#include "SkPaint.h"
#include "SkPdfConfig.h"
+#include "SkPdfUtils.h"
-#include <iostream>
-#include <cstdio>
-#include <map>
#include <stack>
class SkPdfFont;
class SkPdfDoc;
-class SkPdfObject;
+class SkPdfNativeObject;
class SkPdfResourceDictionary;
class SkPdfSoftMaskDictionary;
-class SkNativeParsedPDF;
+class SkPdfNativeDoc;
class SkPdfAllocator;
// TODO(edisonn): better class design.
@@ -35,7 +33,7 @@
// TODO(edisonn): make color space an enum!
public:
NotOwnedString fColorSpace;
- SkPdfObject* fPattern;
+ SkPdfNativeObject* fPattern;
/*
color (various) The current color to be used during painting operations (see Section
@@ -67,7 +65,7 @@
fPattern = NULL;
}
- void setPatternColorSpace(SkPdfObject* pattern) {
+ void setPatternColorSpace(SkPdfNativeObject* pattern) {
fColorSpace.fBuffer = (const unsigned char*)"Pattern";
fColorSpace.fBytes = 7; // strlen("Pattern")
fPattern = pattern;
@@ -360,41 +358,18 @@
};
// TODO(edisonn): better class design.
-// TODO(edisonn): could we remove it?
-// TODO(edisonn): rename to SkPdfInlineImage
-struct SkPdfInlineImage {
- std::map<std::string, std::string> fKeyValuePairs;
- std::string fImageData;
-};
-
-// TODO(edisonn): better class design.
// TODO(edisonn): rename to SkPdfContext
-struct PdfContext {
- std::stack<SkPdfObject*> fObjectStack;
+struct SkPdfContext {
+ std::stack<SkPdfNativeObject*> fObjectStack;
std::stack<SkPdfGraphicsState> fStateStack;
SkPdfGraphicsState fGraphicsState;
- SkNativeParsedPDF* fPdfDoc;
+ SkPdfNativeDoc* fPdfDoc;
// TODO(edisonn): the allocator, could be freed after the page is done drawing.
SkPdfAllocator* fTmpPageAllocator;
SkMatrix fOriginalMatrix;
- SkPdfInlineImage fInlineImage;
-
- PdfContext(SkNativeParsedPDF* doc);
- ~PdfContext();
-};
-
-// TODO(edisonn): temporary code, to report how much of the PDF we actually think we rendered.
-// TODO(edisonn): rename to SkPdfResult
-enum PdfResult {
- kOK_PdfResult,
- kPartial_PdfResult,
- kNYI_PdfResult,
- kIgnoreError_PdfResult,
- kError_PdfResult,
- kUnsupported_PdfResult,
-
- kCount_PdfResult
+ SkPdfContext(SkPdfNativeDoc* doc);
+ ~SkPdfContext();
};
#endif // __DEFINED__SkPdfBasics
diff --git a/experimental/PdfViewer/SkPdfRenderer.cpp b/experimental/PdfViewer/SkPdfRenderer.cpp
index cd2d7d6..090383e 100644
--- a/experimental/PdfViewer/SkPdfRenderer.cpp
+++ b/experimental/PdfViewer/SkPdfRenderer.cpp
@@ -18,13 +18,13 @@
#include "SkTArray.h"
#include "SkTDict.h"
-#include "SkPdfBasics.h"
+#include "SkPdfGraphicsState.h"
#include "SkPdfNativeTokenizer.h"
#include <cstdio>
#include <stack>
#include <set>
-extern "C" PdfContext* gPdfContext;
+extern "C" SkPdfContext* gPdfContext;
extern "C" SkBitmap* gDumpBitmap;
extern "C" SkCanvas* gDumpCanvas;
@@ -52,7 +52,6 @@
#include "SkPdfMapper_autogen.h"
#include "SkPdfRenderer.h"
-#include "SkPdfBasics.h"
#include "SkPdfUtils.h"
#include "SkPdfFont.h"
@@ -95,19 +94,19 @@
protected:
PdfTokenLooper* fParent;
SkPdfNativeTokenizer* fTokenizer;
- PdfContext* fPdfContext;
+ SkPdfContext* fPdfContext;
SkCanvas* fCanvas;
public:
PdfTokenLooper(PdfTokenLooper* parent,
SkPdfNativeTokenizer* tokenizer,
- PdfContext* pdfContext,
+ SkPdfContext* pdfContext,
SkCanvas* canvas)
: fParent(parent), fTokenizer(tokenizer), fPdfContext(pdfContext), fCanvas(canvas) {}
virtual ~PdfTokenLooper() {}
- virtual PdfResult consumeToken(PdfToken& token) = 0;
+ virtual SkPdfResult consumeToken(PdfToken& token) = 0;
virtual void loop() = 0;
void setUp(PdfTokenLooper* parent) {
@@ -124,11 +123,11 @@
public:
PdfMainLooper(PdfTokenLooper* parent,
SkPdfNativeTokenizer* tokenizer,
- PdfContext* pdfContext,
+ SkPdfContext* pdfContext,
SkCanvas* canvas)
: PdfTokenLooper(parent, tokenizer, pdfContext, canvas) {}
- virtual PdfResult consumeToken(PdfToken& token);
+ virtual SkPdfResult consumeToken(PdfToken& token);
virtual void loop();
};
@@ -137,9 +136,9 @@
PdfInlineImageLooper()
: PdfTokenLooper(NULL, NULL, NULL, NULL) {}
- virtual PdfResult consumeToken(PdfToken& token);
+ virtual SkPdfResult consumeToken(PdfToken& token);
virtual void loop();
- PdfResult done();
+ SkPdfResult done();
};
class PdfCompatibilitySectionLooper : public PdfTokenLooper {
@@ -147,7 +146,7 @@
PdfCompatibilitySectionLooper()
: PdfTokenLooper(NULL, NULL, NULL, NULL) {}
- virtual PdfResult consumeToken(PdfToken& token);
+ virtual SkPdfResult consumeToken(PdfToken& token);
virtual void loop();
};
@@ -196,7 +195,7 @@
// TODO(edisonn): security issue, ret if size() != 6
for (int i = 0; i < 6; i++) {
- const SkPdfObject* elem = pdfArray->operator [](i);
+ const SkPdfNativeObject* elem = pdfArray->operator [](i);
if (elem == NULL || !elem->isNumber()) {
return SkMatrix::I(); // TODO(edisonn): report issue
}
@@ -207,7 +206,7 @@
}
-extern "C" SkNativeParsedPDF* gDoc;
+extern "C" SkPdfNativeDoc* gDoc;
SkBitmap* gDumpBitmap = NULL;
SkCanvas* gDumpCanvas = NULL;
char gLastKeyword[100] = "";
@@ -231,7 +230,7 @@
-// TODO(edisonn): Pass PdfContext and SkCanvasd only with the define for instrumentation.
+// TODO(edisonn): Pass SkPdfContext and SkCanvasd only with the define for instrumentation.
static bool readToken(SkPdfNativeTokenizer* fTokenizer, PdfToken* token) {
bool ret = fTokenizer->readToken(token);
@@ -326,7 +325,7 @@
-typedef PdfResult (*PdfOperatorRenderer)(PdfContext*, SkCanvas*, PdfTokenLooper**);
+typedef SkPdfResult (*PdfOperatorRenderer)(SkPdfContext*, SkCanvas*, PdfTokenLooper**);
SkTDict<PdfOperatorRenderer> gPdfOps(100);
@@ -336,9 +335,9 @@
SkTDictWithDefaultConstructor() : SkTDict<T>(10) {}
};
-SkTDictWithDefaultConstructor<int> gRenderStats[kCount_PdfResult];
+SkTDictWithDefaultConstructor<int> gRenderStats[kCount_SkPdfResult];
-const char* gRenderStatsNames[kCount_PdfResult] = {
+const char* gRenderStatsNames[kCount_SkPdfResult] = {
"Success",
"Partially implemented",
"Not yet implemented",
@@ -347,8 +346,8 @@
"Unsupported/Unknown"
};
-static PdfResult DrawText(PdfContext* pdfContext,
- const SkPdfObject* _str,
+static SkPdfResult DrawText(SkPdfContext* pdfContext,
+ const SkPdfNativeObject* _str,
SkCanvas* canvas)
{
@@ -360,7 +359,7 @@
if (_str == NULL || !_str->isAnyString()) {
// TODO(edisonn): report warning
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
const SkPdfString* str = (const SkPdfString*)_str;
@@ -370,7 +369,7 @@
if (skfont->encoding() == NULL) {
// TODO(edisonn): report warning
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
skfont->encoding()->decodeText(binary, &decoded);
@@ -390,14 +389,14 @@
skfont->drawText(decoded, &paint, pdfContext, canvas);
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
// TODO(edisonn): create header files with declarations!
-PdfResult PdfOp_q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
-PdfResult PdfOp_Q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
-PdfResult PdfOp_Tw(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
-PdfResult PdfOp_Tc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
+SkPdfResult PdfOp_q(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
+SkPdfResult PdfOp_Q(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
+SkPdfResult PdfOp_Tw(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
+SkPdfResult PdfOp_Tc(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
// TODO(edisonn): perf!!!
@@ -474,7 +473,7 @@
// this functions returns the image, it does not look at the smask.
-static SkBitmap* getImageFromObjectCore(PdfContext* pdfContext, SkPdfImageDictionary* image, bool transparencyMask) {
+static SkBitmap* getImageFromObjectCore(SkPdfContext* pdfContext, SkPdfImageDictionary* image, bool transparencyMask) {
if (image == NULL || !image->hasStream()) {
// TODO(edisonn): report warning to be used in testing.
return NULL;
@@ -593,19 +592,19 @@
return bitmap;
}
-static SkBitmap* getImageFromObject(PdfContext* pdfContext, SkPdfImageDictionary* image, bool transparencyMask) {
+static SkBitmap* getImageFromObject(SkPdfContext* pdfContext, SkPdfImageDictionary* image, bool transparencyMask) {
if (!transparencyMask) {
- if (!image->hasData(SkPdfObject::kBitmap_Data)) {
+ if (!image->hasData(SkPdfNativeObject::kBitmap_Data)) {
SkBitmap* bitmap = getImageFromObjectCore(pdfContext, image, transparencyMask);
- image->setData(bitmap, SkPdfObject::kBitmap_Data);
+ image->setData(bitmap, SkPdfNativeObject::kBitmap_Data);
}
- return (SkBitmap*) image->data(SkPdfObject::kBitmap_Data);
+ return (SkBitmap*) image->data(SkPdfNativeObject::kBitmap_Data);
} else {
return getImageFromObjectCore(pdfContext, image, transparencyMask);
}
}
-static SkBitmap* getSmaskFromObject(PdfContext* pdfContext, SkPdfImageDictionary* obj) {
+static SkBitmap* getSmaskFromObject(SkPdfContext* pdfContext, SkPdfImageDictionary* obj) {
SkPdfImageDictionary* sMask = obj->SMask(pdfContext->fPdfDoc);
if (sMask) {
@@ -616,9 +615,9 @@
return pdfContext->fGraphicsState.fSMask;
}
-static PdfResult doXObject_Image(PdfContext* pdfContext, SkCanvas* canvas, SkPdfImageDictionary* skpdfimage) {
+static SkPdfResult doXObject_Image(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfImageDictionary* skpdfimage) {
if (skpdfimage == NULL) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
SkBitmap* image = getImageFromObject(pdfContext, skpdfimage, false);
@@ -668,7 +667,7 @@
canvas->restore();
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
//TODO(edisonn): options for implementing isolation and knockout
@@ -695,7 +694,7 @@
-static void doGroup_before(PdfContext* pdfContext, SkCanvas* canvas, SkRect bbox, SkPdfTransparencyGroupDictionary* tgroup, bool page) {
+static void doGroup_before(SkPdfContext* pdfContext, SkCanvas* canvas, SkRect bbox, SkPdfTransparencyGroupDictionary* tgroup, bool page) {
SkRect bboxOrig = bbox;
SkBitmap backdrop;
bool isolatedGroup = tgroup->I(pdfContext->fPdfDoc);
@@ -706,18 +705,18 @@
}
// TODO(edisonn): non isolation implemented in skia
-//static void doGroup_after(PdfContext* pdfContext, SkCanvas* canvas, SkRect bbox, SkPdfTransparencyGroupDictionary* tgroup) {
+//static void doGroup_after(SkPdfContext* pdfContext, SkCanvas* canvas, SkRect bbox, SkPdfTransparencyGroupDictionary* tgroup) {
// if not isolated
// canvas->drawBitmapRect(backdrop, bboxOrig, NULL);
//}
-static PdfResult doXObject_Form(PdfContext* pdfContext, SkCanvas* canvas, SkPdfType1FormDictionary* skobj) {
+static SkPdfResult doXObject_Form(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfType1FormDictionary* skobj) {
if (!skobj || !skobj->hasStream()) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
if (!skobj->has_BBox()) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
PdfOp_q(pdfContext, canvas, NULL);
@@ -773,18 +772,18 @@
}
PdfOp_Q(pdfContext, canvas, NULL);
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
// TODO(edisonn): Extract a class like ObjWithStream
-static PdfResult doXObject_Pattern(PdfContext* pdfContext, SkCanvas* canvas, SkPdfType1PatternDictionary* skobj) {
+static SkPdfResult doXObject_Pattern(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfType1PatternDictionary* skobj) {
if (!skobj || !skobj->hasStream()) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
if (!skobj->has_BBox()) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
PdfOp_q(pdfContext, canvas, NULL);
@@ -825,17 +824,17 @@
// There could be operands left, that could be consumed by a parent tokenizer when we pop.
PdfOp_Q(pdfContext, canvas, NULL);
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
-//static PdfResult doXObject_PS(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfObject* obj) {
-// return kNYI_PdfResult;
+//static SkPdfResult doXObject_PS(SkPdfContext* pdfContext, SkCanvas* canvas, const SkPdfNativeObject* obj) {
+// return kNYI_SkPdfResult;
//}
-PdfResult doType3Char(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfObject* skobj, SkRect bBox, SkMatrix matrix, double textSize) {
+SkPdfResult doType3Char(SkPdfContext* pdfContext, SkCanvas* canvas, const SkPdfNativeObject* skobj, SkRect bBox, SkMatrix matrix, double textSize) {
if (!skobj || !skobj->hasStream()) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
PdfOp_q(pdfContext, canvas, NULL);
@@ -875,17 +874,17 @@
// There could be operands left, that could be consumed by a parent tokenizer when we pop.
PdfOp_Q(pdfContext, canvas, NULL);
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
// TODO(edisonn): make sure the pointer is unique
-std::set<const SkPdfObject*> gInRendering;
+std::set<const SkPdfNativeObject*> gInRendering;
class CheckRecursiveRendering {
- const SkPdfObject* fUniqueData;
+ const SkPdfNativeObject* fUniqueData;
public:
- CheckRecursiveRendering(const SkPdfObject* obj) : fUniqueData(obj) {
+ CheckRecursiveRendering(const SkPdfNativeObject* obj) : fUniqueData(obj) {
gInRendering.insert(obj);
}
@@ -894,55 +893,55 @@
gInRendering.erase(fUniqueData);
}
- static bool IsInRendering(const SkPdfObject* obj) {
+ static bool IsInRendering(const SkPdfNativeObject* obj) {
return gInRendering.find(obj) != gInRendering.end();
}
};
-static PdfResult doXObject(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfObject* obj) {
+static SkPdfResult doXObject(SkPdfContext* pdfContext, SkCanvas* canvas, const SkPdfNativeObject* obj) {
if (CheckRecursiveRendering::IsInRendering(obj)) {
// Oops, corrupt PDF!
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
CheckRecursiveRendering checkRecursion(obj);
switch (pdfContext->fPdfDoc->mapper()->mapXObjectDictionary(obj))
{
- case kImageDictionary_SkPdfObjectType:
+ case kImageDictionary_SkPdfNativeObjectType:
return doXObject_Image(pdfContext, canvas, (SkPdfImageDictionary*)obj);
- case kType1FormDictionary_SkPdfObjectType:
+ case kType1FormDictionary_SkPdfNativeObjectType:
return doXObject_Form(pdfContext, canvas, (SkPdfType1FormDictionary*)obj);
- //case kObjectDictionaryXObjectPS_SkPdfObjectType:
+ //case kObjectDictionaryXObjectPS_SkPdfNativeObjectType:
//return doXObject_PS(skxobj.asPS());
default: {
- if (pdfContext->fPdfDoc->mapper()->mapType1PatternDictionary(obj) != kNone_SkPdfObjectType) {
+ if (pdfContext->fPdfDoc->mapper()->mapType1PatternDictionary(obj) != kNone_SkPdfNativeObjectType) {
SkPdfType1PatternDictionary* pattern = (SkPdfType1PatternDictionary*)obj;
return doXObject_Pattern(pdfContext, canvas, pattern);
}
}
}
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
-static PdfResult doPage(PdfContext* pdfContext, SkCanvas* canvas, SkPdfPageObjectDictionary* skobj) {
+static SkPdfResult doPage(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfPageObjectDictionary* skobj) {
if (!skobj) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
if (!skobj->isContentsAStream(pdfContext->fPdfDoc)) {
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
SkPdfStream* stream = skobj->getContentsAsStream(pdfContext->fPdfDoc);
if (!stream) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
if (CheckRecursiveRendering::IsInRendering(skobj)) {
// Oops, corrupt PDF!
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
CheckRecursiveRendering checkRecursion(skobj);
@@ -976,23 +975,23 @@
// There could be operands left, that could be consumed by a parent tokenizer when we pop.
canvas->restore();
PdfOp_Q(pdfContext, canvas, NULL);
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
-PdfResult PdfOp_q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+SkPdfResult PdfOp_q(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fStateStack.push(pdfContext->fGraphicsState);
canvas->save();
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-PdfResult PdfOp_Q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+SkPdfResult PdfOp_Q(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fGraphicsState = pdfContext->fStateStack.top();
pdfContext->fStateStack.pop();
canvas->restore();
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_cm(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_cm(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
double array[6];
for (int i = 0 ; i < 6 ; i++) {
array[5 - i] = pdfContext->fObjectStack.top()->numberValue();
@@ -1023,26 +1022,26 @@
SkTraceMatrix(pdfContext->fGraphicsState.fCTM, "cm");
#endif
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
//leading TL Set the text leading, Tl
//, to leading, which is a number expressed in unscaled text
//space units. Text leading is used only by the T*, ', and " operators. Initial value: 0.
-static PdfResult PdfOp_TL(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_TL(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
double ty = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
pdfContext->fGraphicsState.fTextLeading = ty;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_Td(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Td(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
#ifdef PDF_TRACE
printf("stack size = %i\n", (int)pdfContext->fObjectStack.size());
#endif
double ty = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
- SkPdfObject* obj = pdfContext->fObjectStack.top();
+ SkPdfNativeObject* obj = pdfContext->fObjectStack.top();
obj = obj;
double tx = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
@@ -1052,10 +1051,10 @@
pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
pdfContext->fGraphicsState.fMatrixTlm.preConcat(matrix);
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
-static PdfResult PdfOp_TD(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_TD(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
double ty = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
double tx = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
@@ -1071,7 +1070,7 @@
SkPdfReal* vty = pdfContext->fPdfDoc->createReal(ty);
pdfContext->fObjectStack.push(vty);
- PdfResult ret = PdfOp_Td(pdfContext, canvas, looper);
+ SkPdfResult ret = PdfOp_Td(pdfContext, canvas, looper);
// TODO(edisonn): delete all the objects after rendering was complete, in this way pdf is rendered faster
// and the cleanup can happen while the user looks at the image
@@ -1079,7 +1078,7 @@
return ret;
}
-static PdfResult PdfOp_Tm(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Tm(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
double f = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
double e = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
double d = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
@@ -1103,25 +1102,25 @@
pdfContext->fGraphicsState.fMatrixTm = matrix;
pdfContext->fGraphicsState.fMatrixTlm = matrix;;
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
//— T* Move to the start of the next line. This operator has the same effect as the code
//0 Tl Td
//where Tl is the current leading parameter in the text state
-static PdfResult PdfOp_T_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_T_star(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
SkPdfReal* zero = pdfContext->fPdfDoc->createReal(0.0);
SkPdfReal* tl = pdfContext->fPdfDoc->createReal(pdfContext->fGraphicsState.fTextLeading);
pdfContext->fObjectStack.push(zero);
pdfContext->fObjectStack.push(tl);
- PdfResult ret = PdfOp_Td(pdfContext, canvas, looper);
+ SkPdfResult ret = PdfOp_Td(pdfContext, canvas, looper);
return ret;
}
-static PdfResult PdfOp_m(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_m(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
if (pdfContext->fGraphicsState.fPathClosed) {
pdfContext->fGraphicsState.fPath.reset();
pdfContext->fGraphicsState.fPathClosed = false;
@@ -1133,10 +1132,10 @@
pdfContext->fGraphicsState.fPath.moveTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX),
SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY));
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_l(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_l(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
if (pdfContext->fGraphicsState.fPathClosed) {
pdfContext->fGraphicsState.fPath.reset();
pdfContext->fGraphicsState.fPathClosed = false;
@@ -1148,10 +1147,10 @@
pdfContext->fGraphicsState.fPath.lineTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX),
SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY));
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_c(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_c(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
if (pdfContext->fGraphicsState.fPathClosed) {
pdfContext->fGraphicsState.fPath.reset();
pdfContext->fGraphicsState.fPathClosed = false;
@@ -1171,10 +1170,10 @@
pdfContext->fGraphicsState.fCurPosX = x3;
pdfContext->fGraphicsState.fCurPosY = y3;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_v(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_v(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
if (pdfContext->fGraphicsState.fPathClosed) {
pdfContext->fGraphicsState.fPath.reset();
pdfContext->fGraphicsState.fPathClosed = false;
@@ -1194,10 +1193,10 @@
pdfContext->fGraphicsState.fCurPosX = x3;
pdfContext->fGraphicsState.fCurPosY = y3;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_y(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_y(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
if (pdfContext->fGraphicsState.fPathClosed) {
pdfContext->fGraphicsState.fPath.reset();
pdfContext->fGraphicsState.fPathClosed = false;
@@ -1217,10 +1216,10 @@
pdfContext->fGraphicsState.fCurPosX = x3;
pdfContext->fGraphicsState.fCurPosY = y3;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_re(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_re(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
if (pdfContext->fGraphicsState.fPathClosed) {
pdfContext->fGraphicsState.fPath.reset();
pdfContext->fGraphicsState.fPathClosed = false;
@@ -1237,15 +1236,15 @@
pdfContext->fGraphicsState.fCurPosX = x;
pdfContext->fGraphicsState.fCurPosY = y + height;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_h(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_h(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fGraphicsState.fPath.close();
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_fillAndStroke(PdfContext* pdfContext, SkCanvas* canvas, bool fill, bool stroke, bool close, bool evenOdd) {
+static SkPdfResult PdfOp_fillAndStroke(SkPdfContext* pdfContext, SkCanvas* canvas, bool fill, bool stroke, bool close, bool evenOdd) {
SkPath path = pdfContext->fGraphicsState.fPath;
if (close) {
@@ -1280,7 +1279,7 @@
}
canvas->clipPath(path);
- if (pdfContext->fPdfDoc->mapper()->mapType1PatternDictionary(pdfContext->fGraphicsState.fNonStroking.fPattern) != kNone_SkPdfObjectType) {
+ if (pdfContext->fPdfDoc->mapper()->mapType1PatternDictionary(pdfContext->fGraphicsState.fNonStroking.fPattern) != kNone_SkPdfNativeObjectType) {
SkPdfType1PatternDictionary* pattern = (SkPdfType1PatternDictionary*)pdfContext->fGraphicsState.fNonStroking.fPattern;
// TODO(edisonn): constants
@@ -1372,47 +1371,47 @@
//pdfContext->fGraphicsState.fClipPath.reset();
pdfContext->fGraphicsState.fHasClipPathToApply = false;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_S(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_S(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_fillAndStroke(pdfContext, canvas, false, true, false, false);
}
-static PdfResult PdfOp_s(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_s(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_fillAndStroke(pdfContext, canvas, false, true, true, false);
}
-static PdfResult PdfOp_F(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_F(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
}
-static PdfResult PdfOp_f(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_f(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
}
-static PdfResult PdfOp_f_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_f_star(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, true);
}
-static PdfResult PdfOp_B(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_B(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, false);
}
-static PdfResult PdfOp_B_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_B_star(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, true);
}
-static PdfResult PdfOp_b(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_b(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, false);
}
-static PdfResult PdfOp_b_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_b_star(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, true);
}
-static PdfResult PdfOp_n(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_n(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
canvas->setMatrix(pdfContext->fGraphicsState.fCTM);
if (pdfContext->fGraphicsState.fHasClipPathToApply) {
#ifndef PDF_DEBUG_NO_CLIPING
@@ -1425,42 +1424,42 @@
pdfContext->fGraphicsState.fPathClosed = true;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_BT(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_BT(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fGraphicsState.fTextBlock = true;
SkMatrix matrix = pdfContext->fGraphicsState.fCTM;
matrix.preScale(SkDoubleToScalar(1), SkDoubleToScalar(-1));
pdfContext->fGraphicsState.fMatrixTm = matrix;
pdfContext->fGraphicsState.fMatrixTlm = matrix;
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
-static PdfResult PdfOp_ET(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_ET(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
if (!pdfContext->fGraphicsState.fTextBlock) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
// TODO(edisonn): anything else to be done once we are done with draw text? Like restore stack?
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-PdfResult skpdfGraphicsStateApplyFontCore(PdfContext* pdfContext, const SkPdfObject* fontName, double fontSize) {
+SkPdfResult skpdfGraphicsStateApplyFontCore(SkPdfContext* pdfContext, const SkPdfNativeObject* fontName, double fontSize) {
#ifdef PDF_TRACE
printf("font name: %s\n", fontName->nameValue2().c_str());
#endif
if (!pdfContext->fGraphicsState.fResources->Font(pdfContext->fPdfDoc)) {
// TODO(edisonn): try to recover and draw it any way?
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
- SkPdfObject* objFont = pdfContext->fGraphicsState.fResources->Font(pdfContext->fPdfDoc)->get(fontName);
+ SkPdfNativeObject* objFont = pdfContext->fGraphicsState.fResources->Font(pdfContext->fPdfDoc)->get(fontName);
objFont = pdfContext->fPdfDoc->resolveReference(objFont);
- if (kNone_SkPdfObjectType == pdfContext->fPdfDoc->mapper()->mapFontDictionary(objFont)) {
+ if (kNone_SkPdfNativeObjectType == pdfContext->fPdfDoc->mapper()->mapFontDictionary(objFont)) {
// TODO(edisonn): try to recover and draw it any way?
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
SkPdfFontDictionary* fd = (SkPdfFontDictionary*)objFont;
@@ -1471,7 +1470,7 @@
pdfContext->fGraphicsState.fSkFont = skfont;
}
pdfContext->fGraphicsState.fCurFontSize = fontSize;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
//font size Tf Set the text font, Tf
@@ -1479,19 +1478,19 @@
//font resource in the Fontsubdictionary of the current resource dictionary; size is
//a number representing a scale factor. There is no initial value for either font or
//size; they must be specified explicitly using Tf before any text is shown.
-static PdfResult PdfOp_Tf(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Tf(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
double fontSize = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
- SkPdfObject* fontName = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+ SkPdfNativeObject* fontName = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
return skpdfGraphicsStateApplyFontCore(pdfContext, fontName, fontSize);
}
-static PdfResult PdfOp_Tj(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Tj(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
if (!pdfContext->fGraphicsState.fTextBlock) {
// TODO(edisonn): try to recover and draw it any way?
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
- PdfResult ret = DrawText(pdfContext,
+ SkPdfResult ret = DrawText(pdfContext,
pdfContext->fObjectStack.top(),
canvas);
pdfContext->fObjectStack.pop();
@@ -1499,10 +1498,10 @@
return ret;
}
-static PdfResult PdfOp_quote(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_quote(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
if (!pdfContext->fGraphicsState.fTextBlock) {
// TODO(edisonn): try to recover and draw it any way?
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
PdfOp_T_star(pdfContext, canvas, looper);
@@ -1510,15 +1509,15 @@
return PdfOp_Tj(pdfContext, canvas, looper);
}
-static PdfResult PdfOp_doublequote(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_doublequote(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
if (!pdfContext->fGraphicsState.fTextBlock) {
// TODO(edisonn): try to recover and draw it any way?
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
- SkPdfObject* str = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
- SkPdfObject* ac = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
- SkPdfObject* aw = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+ SkPdfNativeObject* str = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+ SkPdfNativeObject* ac = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+ SkPdfNativeObject* aw = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
pdfContext->fObjectStack.push(aw);
PdfOp_Tw(pdfContext, canvas, looper);
@@ -1529,26 +1528,26 @@
pdfContext->fObjectStack.push(str);
PdfOp_quote(pdfContext, canvas, looper);
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
-static PdfResult PdfOp_TJ(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_TJ(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
if (!pdfContext->fGraphicsState.fTextBlock) {
// TODO(edisonn): try to recover and draw it any way?
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
SkPdfArray* array = (SkPdfArray*)pdfContext->fObjectStack.top();
pdfContext->fObjectStack.pop();
if (!array->isArray()) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
for( int i=0; i<static_cast<int>(array->size()); i++ )
{
if( (*array)[i]->isAnyString()) {
- SkPdfObject* obj = (*array)[i];
+ SkPdfNativeObject* obj = (*array)[i];
DrawText(pdfContext,
obj,
canvas);
@@ -1569,16 +1568,16 @@
pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
}
}
- return kPartial_PdfResult; // TODO(edisonn): Implement fully DrawText before returing OK.
+ return kPartial_SkPdfResult; // TODO(edisonn): Implement fully DrawText before returing OK.
}
-static PdfResult PdfOp_CS_cs(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
- SkPdfObject* name = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+static SkPdfResult PdfOp_CS_cs(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
+ SkPdfNativeObject* name = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
//Next, get the ColorSpace Dictionary from the Resource Dictionary:
SkPdfDictionary* colorSpaceResource = pdfContext->fGraphicsState.fResources->ColorSpace(pdfContext->fPdfDoc);
- SkPdfObject* colorSpace = colorSpaceResource ? pdfContext->fPdfDoc->resolveReference(colorSpaceResource->get(name)) : name;
+ SkPdfNativeObject* colorSpace = colorSpaceResource ? pdfContext->fPdfDoc->resolveReference(colorSpaceResource->get(name)) : name;
if (colorSpace == NULL) {
colorOperator->fColorSpace = name->strRef();
@@ -1591,16 +1590,16 @@
} else if (colorSpace->isArray()) {
int cnt = colorSpace->size();
if (cnt == 0) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
- SkPdfObject* type = colorSpace->objAtAIndex(0);
+ SkPdfNativeObject* type = colorSpace->objAtAIndex(0);
type = pdfContext->fPdfDoc->resolveReference(type);
if (type->isName("ICCBased")) {
if (cnt != 2) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
- SkPdfObject* prop = colorSpace->objAtAIndex(1);
+ SkPdfNativeObject* prop = colorSpace->objAtAIndex(1);
prop = pdfContext->fPdfDoc->resolveReference(prop);
#ifdef PDF_TRACE
printf("ICCBased prop = %s\n", prop->toString(0, 0).c_str());
@@ -1608,25 +1607,25 @@
// TODO(edisonn): hack
if (prop && prop->isDictionary() && prop->get("N") && prop->get("N")->isInteger() && prop->get("N")->intValue() == 3) {
colorOperator->setColorSpace(&strings_DeviceRGB);
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
}
}
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
-static PdfResult PdfOp_CS(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_CS(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
}
-static PdfResult PdfOp_cs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_cs(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
}
-static PdfResult PdfOp_SC_sc(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
+static SkPdfResult PdfOp_SC_sc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
double c[4];
// int64_t v[4];
@@ -1655,20 +1654,20 @@
if (colorOperator->fColorSpace.equals("DeviceRGB") || colorOperator->fColorSpace.equals("RGB")) {
colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255*c[0]), (U8CPU)(255*c[1]), (U8CPU)(255*c[2])));
}
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
-static PdfResult PdfOp_SC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_SC(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
}
-static PdfResult PdfOp_sc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_sc(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
}
-static PdfResult PdfOp_SCN_scn(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
+static SkPdfResult PdfOp_SCN_scn(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
if (pdfContext->fObjectStack.top()->isName()) {
- SkPdfObject* name = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+ SkPdfNativeObject* name = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
//Next, get the ExtGState Dictionary from the Resource Dictionary:
SkPdfDictionary* patternResources = pdfContext->fGraphicsState.fResources->Pattern(pdfContext->fPdfDoc);
@@ -1677,7 +1676,7 @@
#ifdef PDF_TRACE
printf("ExtGState is NULL!\n");
#endif
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
colorOperator->setPatternColorSpace(pdfContext->fPdfDoc->resolveReference(patternResources->get(name)));
@@ -1686,49 +1685,49 @@
// TODO(edisonn): SCN supports more color spaces than SCN. Read and implement spec.
PdfOp_SC_sc(pdfContext, canvas, colorOperator);
- return kPartial_PdfResult;
+ return kPartial_SkPdfResult;
}
-static PdfResult PdfOp_SCN(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_SCN(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
}
-static PdfResult PdfOp_scn(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_scn(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
}
-static PdfResult PdfOp_G_g(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
+static SkPdfResult PdfOp_G_g(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
/*double gray = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
-static PdfResult PdfOp_G(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_G(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
}
-static PdfResult PdfOp_g(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_g(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
}
-static PdfResult PdfOp_RG_rg(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
+static SkPdfResult PdfOp_RG_rg(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
double b = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
double g = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
double r = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
colorOperator->fColorSpace = strings_DeviceRGB;
colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255*r), (U8CPU)(255*g), (U8CPU)(255*b)));
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_RG(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_RG(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
}
-static PdfResult PdfOp_rg(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_rg(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
}
-static PdfResult PdfOp_K_k(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
+static SkPdfResult PdfOp_K_k(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
// TODO(edisonn): spec has some rules about overprint, implement them.
/*double k = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
/*double y = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
@@ -1737,97 +1736,97 @@
colorOperator->fColorSpace = strings_DeviceCMYK;
// TODO(edisonn): Set color.
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
-static PdfResult PdfOp_K(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_K(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
}
-static PdfResult PdfOp_k(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_k(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
}
-static PdfResult PdfOp_W(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_W(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
pdfContext->fGraphicsState.fHasClipPathToApply = true;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_W_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_W_star(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
pdfContext->fGraphicsState.fClipPath.setFillType(SkPath::kEvenOdd_FillType);
pdfContext->fGraphicsState.fHasClipPathToApply = true;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_BX(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_BX(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
*looper = new PdfCompatibilitySectionLooper();
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_EX(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_EX(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
#ifdef ASSERT_BAD_PDF_OPS
SkASSERT(false); // EX must be consumed by PdfCompatibilitySectionLooper, but let's
// have the assert when testing good pdfs.
#endif
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
-static PdfResult PdfOp_BI(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_BI(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
*looper = new PdfInlineImageLooper();
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-static PdfResult PdfOp_ID(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_ID(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
#ifdef ASSERT_BAD_PDF_OPS
SkASSERT(false); // must be processed in inline image looper, but let's
// have the assert when testing good pdfs.
#endif
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
-static PdfResult PdfOp_EI(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_EI(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
#ifdef ASSERT_BAD_PDF_OPS
SkASSERT(false); // must be processed in inline image looper, but let's
// have the assert when testing good pdfs.
#endif
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
// TODO(edisonn): security review here, make sure all parameters are valid, and safe.
-PdfResult skpdfGraphicsStateApply_ca(PdfContext* pdfContext, double ca) {
+SkPdfResult skpdfGraphicsStateApply_ca(SkPdfContext* pdfContext, double ca) {
pdfContext->fGraphicsState.fNonStroking.fOpacity = ca;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-PdfResult skpdfGraphicsStateApply_CA(PdfContext* pdfContext, double CA) {
+SkPdfResult skpdfGraphicsStateApply_CA(SkPdfContext* pdfContext, double CA) {
pdfContext->fGraphicsState.fStroking.fOpacity = CA;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-PdfResult skpdfGraphicsStateApplyLW(PdfContext* pdfContext, double lineWidth) {
+SkPdfResult skpdfGraphicsStateApplyLW(SkPdfContext* pdfContext, double lineWidth) {
pdfContext->fGraphicsState.fLineWidth = lineWidth;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-PdfResult skpdfGraphicsStateApplyLC(PdfContext* pdfContext, int64_t lineCap) {
+SkPdfResult skpdfGraphicsStateApplyLC(SkPdfContext* pdfContext, int64_t lineCap) {
pdfContext->fGraphicsState.fLineCap = (int)lineCap;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-PdfResult skpdfGraphicsStateApplyLJ(PdfContext* pdfContext, int64_t lineJoin) {
+SkPdfResult skpdfGraphicsStateApplyLJ(SkPdfContext* pdfContext, int64_t lineJoin) {
pdfContext->fGraphicsState.fLineJoin = (int)lineJoin;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-PdfResult skpdfGraphicsStateApplyML(PdfContext* pdfContext, double miterLimit) {
+SkPdfResult skpdfGraphicsStateApplyML(SkPdfContext* pdfContext, double miterLimit) {
pdfContext->fGraphicsState.fMiterLimit = miterLimit;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
// TODO(edisonn): implement all rules, as of now 3) and 5) and 6) do not seem suported by skia, but I am not sure
@@ -1840,17 +1839,17 @@
6) [2 3] 11 1 on, 3 off, 2 on, 3 off, 2 on, …
*/
-PdfResult skpdfGraphicsStateApplyD(PdfContext* pdfContext, SkPdfArray* intervals, SkPdfObject* phase) {
+SkPdfResult skpdfGraphicsStateApplyD(SkPdfContext* pdfContext, SkPdfArray* intervals, SkPdfNativeObject* phase) {
int cnt = intervals->size();
if (cnt >= 256) {
// TODO(edisonn): report error/warning, unsuported;
// TODO(edisonn): alloc memory
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
for (int i = 0; i < cnt; i++) {
if (!intervals->objAtAIndex(i)->isNumber()) {
// TODO(edisonn): report error/warning
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
}
@@ -1865,7 +1864,7 @@
cnt++;
} else {
// TODO(edisonn): report error/warning
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
}
pdfContext->fGraphicsState.fDashArrayLength = cnt;
@@ -1875,19 +1874,19 @@
pdfContext->fGraphicsState.fDashPhase = total;
}
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
-PdfResult skpdfGraphicsStateApplyD(PdfContext* pdfContext, SkPdfArray* dash) {
+SkPdfResult skpdfGraphicsStateApplyD(SkPdfContext* pdfContext, SkPdfArray* dash) {
// TODO(edisonn): verify input
if (!dash || dash->isArray() || dash->size() != 2 || !dash->objAtAIndex(0)->isArray() || !dash->objAtAIndex(1)->isNumber()) {
// TODO(edisonn): report error/warning
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
return skpdfGraphicsStateApplyD(pdfContext, (SkPdfArray*)dash->objAtAIndex(0), dash->objAtAIndex(1));
}
-void skpdfGraphicsStateApplyFont(PdfContext* pdfContext, SkPdfArray* fontAndSize) {
+void skpdfGraphicsStateApplyFont(SkPdfContext* pdfContext, SkPdfArray* fontAndSize) {
if (!fontAndSize || fontAndSize->isArray() || fontAndSize->size() != 2 || !fontAndSize->objAtAIndex(0)->isName() || !fontAndSize->objAtAIndex(1)->isNumber()) {
// TODO(edisonn): report error/warning
return;
@@ -1897,56 +1896,56 @@
//lineWidth w Set the line width in the graphics state (see “Line Width” on page 152).
-static PdfResult PdfOp_w(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_w(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
double lw = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
return skpdfGraphicsStateApplyLW(pdfContext, lw);
}
//lineCap J Set the line cap style in the graphics state (see “Line Cap Style” on page 153).
-static PdfResult PdfOp_J(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_J(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
int64_t lc = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
return skpdfGraphicsStateApplyLC(pdfContext, lc);
}
//lineJoin j Set the line join style in the graphics state (see “Line Join Style” on page 153).
-static PdfResult PdfOp_j(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_j(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
double lj = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
return skpdfGraphicsStateApplyLJ(pdfContext, lj);
}
//miterLimit M Set the miter limit in the graphics state (see “Miter Limit” on page 153).
-static PdfResult PdfOp_M(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_M(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
double ml = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
return skpdfGraphicsStateApplyML(pdfContext, ml);
}
//dashArray dashPhase d Set the line dash pattern in the graphics state (see “Line Dash Pattern” on
//page 155).
-static PdfResult PdfOp_d(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- SkPdfObject* phase = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
- SkPdfObject* array = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+static SkPdfResult PdfOp_d(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ SkPdfNativeObject* phase = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+ SkPdfNativeObject* array = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
if (!array->isArray()) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
return skpdfGraphicsStateApplyD(pdfContext, (SkPdfArray*)array, phase);
}
//intent ri (PDF 1.1) Set the color rendering intent in the graphics state (see “Rendering Intents” on page 197).
-static PdfResult PdfOp_ri(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_ri(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
//flatness i Set the flatness tolerance in the graphics state (see Section 6.5.1, “Flatness
//Tolerance”). flatness is a number in the range 0 to 100; a value of 0 speci-
//fies the output device’s default flatness tolerance.
-static PdfResult PdfOp_i(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_i(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
SkTDict<SkXfermode::Mode> gPdfBlendModes(20);
@@ -1988,7 +1987,7 @@
return (SkXfermode::Mode)(SkXfermode::kLastMode + 1);
}
-void skpdfGraphicsStateApplyBM_name(PdfContext* pdfContext, const std::string& blendMode) {
+void skpdfGraphicsStateApplyBM_name(SkPdfContext* pdfContext, const std::string& blendMode) {
SkXfermode::Mode mode = xferModeFromBlendMode(blendMode.c_str(), blendMode.length());
if (mode <= SkXfermode::kLastMode) {
pdfContext->fGraphicsState.fBlendModesLength = 1;
@@ -1998,7 +1997,7 @@
}
}
-void skpdfGraphicsStateApplyBM_array(PdfContext* pdfContext, SkPdfArray* blendModes) {
+void skpdfGraphicsStateApplyBM_array(SkPdfContext* pdfContext, SkPdfArray* blendModes) {
if (!blendModes || blendModes->isArray() || blendModes->size() == 0 || blendModes->size() > 256) {
// TODO(edisonn): report error/warning
return;
@@ -2006,7 +2005,7 @@
SkXfermode::Mode modes[256];
int cnt = blendModes->size();
for (int i = 0; i < cnt; i++) {
- SkPdfObject* name = blendModes->objAtAIndex(i);
+ SkPdfNativeObject* name = blendModes->objAtAIndex(i);
if (!name->isName()) {
// TODO(edisonn): report error/warning
return;
@@ -2024,7 +2023,7 @@
}
}
-void skpdfGraphicsStateApplySMask_dict(PdfContext* pdfContext, SkPdfDictionary* sMask) {
+void skpdfGraphicsStateApplySMask_dict(SkPdfContext* pdfContext, SkPdfDictionary* sMask) {
// TODO(edisonn): verify input
if (pdfContext->fPdfDoc->mapper()->mapSoftMaskDictionary(sMask)) {
pdfContext->fGraphicsState.fSoftMaskDictionary = (SkPdfSoftMaskDictionary*)sMask;
@@ -2036,7 +2035,7 @@
}
}
-void skpdfGraphicsStateApplySMask_name(PdfContext* pdfContext, const std::string& sMask) {
+void skpdfGraphicsStateApplySMask_name(SkPdfContext* pdfContext, const std::string& sMask) {
if (sMask == "None") {
pdfContext->fGraphicsState.fSoftMaskDictionary = NULL;
pdfContext->fGraphicsState.fSMask = NULL;
@@ -2054,7 +2053,7 @@
return;
}
- SkPdfObject* obj = pdfContext->fPdfDoc->resolveReference(extGStateDictionary->get(sMask.c_str()));
+ SkPdfNativeObject* obj = pdfContext->fPdfDoc->resolveReference(extGStateDictionary->get(sMask.c_str()));
if (!obj || !obj->isDictionary()) {
// TODO (edisonn): report error/warning
return;
@@ -2066,15 +2065,15 @@
skpdfGraphicsStateApplySMask_dict(pdfContext, obj->asDictionary());
}
-void skpdfGraphicsStateApplyAIS(PdfContext* pdfContext, bool alphaSource) {
+void skpdfGraphicsStateApplyAIS(SkPdfContext* pdfContext, bool alphaSource) {
pdfContext->fGraphicsState.fAlphaSource = alphaSource;
}
//dictName gs (PDF 1.2) Set the specified parameters in the graphics state. dictName is
//the name of a graphics state parameter dictionary in the ExtGState subdictionary of the current resource dictionary (see the next section).
-static PdfResult PdfOp_gs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- SkPdfObject* name = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+static SkPdfResult PdfOp_gs(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ SkPdfNativeObject* name = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
#ifdef PDF_TRACE
std::string str;
@@ -2087,19 +2086,19 @@
#ifdef PDF_TRACE
printf("ExtGState is NULL!\n");
#endif
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
- SkPdfObject* value = pdfContext->fPdfDoc->resolveReference(extGStateDictionary->get(name));
+ SkPdfNativeObject* value = pdfContext->fPdfDoc->resolveReference(extGStateDictionary->get(name));
- if (kNone_SkPdfObjectType == pdfContext->fPdfDoc->mapper()->mapGraphicsStateDictionary(value)) {
- return kIgnoreError_PdfResult;
+ if (kNone_SkPdfNativeObjectType == pdfContext->fPdfDoc->mapper()->mapGraphicsStateDictionary(value)) {
+ return kIgnoreError_SkPdfResult;
}
SkPdfGraphicsStateDictionary* gs = (SkPdfGraphicsStateDictionary*)value;
// TODO(edisonn): now load all those properties in graphic state.
if (gs == NULL) {
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
if (gs->has_LW()) {
@@ -2158,17 +2157,17 @@
skpdfGraphicsStateApplyAIS(pdfContext, gs->AIS(pdfContext->fPdfDoc));
}
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
//charSpace Tc Set the character spacing, Tc
//, to charSpace, which is a number expressed in unscaled text space units. Character spacing is used by the Tj, TJ, and ' operators.
//Initial value: 0.
-PdfResult PdfOp_Tc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+SkPdfResult PdfOp_Tc(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
double charSpace = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
pdfContext->fGraphicsState.fCharSpace = charSpace;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
//wordSpace Tw Set the word spacing, T
@@ -2176,47 +2175,47 @@
//, to wordSpace, which is a number expressed in unscaled
//text space units. Word spacing is used by the Tj, TJ, and ' operators. Initial
//value: 0.
-PdfResult PdfOp_Tw(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+SkPdfResult PdfOp_Tw(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
double wordSpace = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
pdfContext->fGraphicsState.fWordSpace = wordSpace;
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
//scale Tz Set the horizontal scaling, Th
//, to (scale ˜ 100). scale is a number specifying the
//percentage of the normal width. Initial value: 100 (normal width).
-static PdfResult PdfOp_Tz(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Tz(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
/*double scale = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
//render Tr Set the text rendering mode, T
//mode, to render, which is an integer. Initial value: 0.
-static PdfResult PdfOp_Tr(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Tr(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
/*double render = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
//rise Ts Set the text rise, Trise, to rise, which is a number expressed in unscaled text space
//units. Initial value: 0.
-static PdfResult PdfOp_Ts(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Ts(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
/*double rise = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
//wx wy d0
-static PdfResult PdfOp_d0(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_d0(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fObjectStack.pop();
pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
//wx wy llx lly urx ury d1
-static PdfResult PdfOp_d1(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_d1(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fObjectStack.pop();
pdfContext->fObjectStack.pop();
pdfContext->fObjectStack.pop();
@@ -2224,19 +2223,19 @@
pdfContext->fObjectStack.pop();
pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
//name sh
-static PdfResult PdfOp_sh(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_sh(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
//name Do
-static PdfResult PdfOp_Do(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- SkPdfObject* name = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+static SkPdfResult PdfOp_Do(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ SkPdfNativeObject* name = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
SkPdfDictionary* xObject = pdfContext->fGraphicsState.fResources->XObject(pdfContext->fPdfDoc);
@@ -2244,10 +2243,10 @@
#ifdef PDF_TRACE
printf("XObject is NULL!\n");
#endif
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
- SkPdfObject* value = xObject->get(name);
+ SkPdfNativeObject* value = xObject->get(name);
value = pdfContext->fPdfDoc->resolveReference(value);
#ifdef PDF_TRACE
@@ -2260,10 +2259,10 @@
//tag MP Designate a marked-content point. tag is a name object indicating the role or
//significance of the point.
-static PdfResult PdfOp_MP(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_MP(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
//tag properties DP Designate a marked-content point with an associated property list. tag is a
@@ -2271,34 +2270,34 @@
//either an inline dictionary containing the property list or a name object
//associated with it in the Properties subdictionary of the current resource
//dictionary (see Section 9.5.1, “Property Lists”).
-static PdfResult PdfOp_DP(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_DP(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fObjectStack.pop();
pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
//tag BMC Begin a marked-content sequence terminated by a balancing EMC operator.
//tag is a name object indicating the role or significance of the sequence.
-static PdfResult PdfOp_BMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_BMC(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
//tag properties BDC Begin a marked-content sequence with an associated property list, terminated
//by a balancing EMCoperator. tag is a name object indicating the role or significance of the sequence; propertiesis either an inline dictionary containing the
//property list or a name object associated with it in the Properties subdictionary of the current resource dictionary (see Section 9.5.1, “Property Lists”).
-static PdfResult PdfOp_BDC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+static SkPdfResult PdfOp_BDC(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
pdfContext->fObjectStack.pop();
pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
+ return kNYI_SkPdfResult;
}
//— EMC End a marked-content sequence begun by a BMC or BDC operator.
-static PdfResult PdfOp_EMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return kNYI_PdfResult;
+static SkPdfResult PdfOp_EMC(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return kNYI_SkPdfResult;
}
static void initPdfOperatorRenderes() {
@@ -2411,7 +2410,7 @@
void reportPdfRenderStats() {
std::map<std::string, int>::iterator iter;
- for (int i = 0 ; i < kCount_PdfResult; i++) {
+ for (int i = 0 ; i < kCount_SkPdfResult; i++) {
SkTDict<int>::Iter iter(gRenderStats[i]);
const char* key;
int value = 0;
@@ -2421,7 +2420,7 @@
}
}
-PdfResult PdfMainLooper::consumeToken(PdfToken& token) {
+SkPdfResult PdfMainLooper::consumeToken(PdfToken& token) {
if (token.fType == kKeyword_TokenType && token.fKeywordLength < 256)
{
// TODO(edisonn): log trace flag (verbose, error, info, warning, ...)
@@ -2429,7 +2428,7 @@
if (gPdfOps.find(token.fKeyword, token.fKeywordLength, &pdfOperatorRenderer) && pdfOperatorRenderer) {
// caller, main work is done by pdfOperatorRenderer(...)
PdfTokenLooper* childLooper = NULL;
- PdfResult result = pdfOperatorRenderer(fPdfContext, fCanvas, &childLooper);
+ SkPdfResult result = pdfOperatorRenderer(fPdfContext, fCanvas, &childLooper);
int cnt = 0;
gRenderStats[result].find(token.fKeyword, token.fKeywordLength, &cnt);
@@ -2442,8 +2441,8 @@
}
} else {
int cnt = 0;
- gRenderStats[kUnsupported_PdfResult].find(token.fKeyword, token.fKeywordLength, &cnt);
- gRenderStats[kUnsupported_PdfResult].set(token.fKeyword, token.fKeywordLength, cnt + 1);
+ gRenderStats[kUnsupported_SkPdfResult].find(token.fKeyword, token.fKeywordLength, &cnt);
+ gRenderStats[kUnsupported_SkPdfResult].set(token.fKeyword, token.fKeywordLength, cnt + 1);
}
}
else if (token.fType == kObject_TokenType)
@@ -2452,9 +2451,9 @@
}
else {
// TODO(edisonn): deine or use assert not reached
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
- return kOK_PdfResult;
+ return kOK_SkPdfResult;
}
void PdfMainLooper::loop() {
@@ -2464,20 +2463,20 @@
}
}
-PdfResult PdfInlineImageLooper::consumeToken(PdfToken& token) {
+SkPdfResult PdfInlineImageLooper::consumeToken(PdfToken& token) {
SkASSERT(false);
- return kIgnoreError_PdfResult;
+ return kIgnoreError_SkPdfResult;
}
void PdfInlineImageLooper::loop() {
doXObject_Image(fPdfContext, fCanvas, fTokenizer->readInlineImage());
}
-PdfResult PdfInlineImageLooper::done() {
- return kNYI_PdfResult;
+SkPdfResult PdfInlineImageLooper::done() {
+ return kNYI_SkPdfResult;
}
-PdfResult PdfCompatibilitySectionLooper::consumeToken(PdfToken& token) {
+SkPdfResult PdfCompatibilitySectionLooper::consumeToken(PdfToken& token) {
return fParent->consumeToken(token);
}
@@ -2512,7 +2511,7 @@
// TODO (edisonn): hide parser/tokenizer behind and interface and a query language, and resolve
// references automatically.
-PdfContext* gPdfContext = NULL;
+SkPdfContext* gPdfContext = NULL;
bool SkPdfRenderer::renderPage(int page, SkCanvas* canvas, const SkRect& dst) const {
if (!fPdfDoc) {
@@ -2523,7 +2522,7 @@
return false;
}
- PdfContext pdfContext(fPdfDoc);
+ SkPdfContext pdfContext(fPdfDoc);
pdfContext.fOriginalMatrix = SkMatrix::I();
pdfContext.fGraphicsState.fResources = fPdfDoc->pageResources(page);
@@ -2590,7 +2589,7 @@
unload();
// TODO(edisonn): create static function that could return NULL if there are errors
- fPdfDoc = new SkNativeParsedPDF(inputFileName.c_str());
+ fPdfDoc = new SkPdfNativeDoc(inputFileName.c_str());
if (fPdfDoc->pages() == 0) {
delete fPdfDoc;
fPdfDoc = NULL;
@@ -2603,7 +2602,7 @@
unload();
// TODO(edisonn): create static function that could return NULL if there are errors
- fPdfDoc = new SkNativeParsedPDF(stream);
+ fPdfDoc = new SkPdfNativeDoc(stream);
if (fPdfDoc->pages() == 0) {
delete fPdfDoc;
fPdfDoc = NULL;
diff --git a/experimental/PdfViewer/SkPdfRenderer.h b/experimental/PdfViewer/SkPdfRenderer.h
index effe69c..df8f56c 100644
--- a/experimental/PdfViewer/SkPdfRenderer.h
+++ b/experimental/PdfViewer/SkPdfRenderer.h
@@ -11,7 +11,7 @@
class SkBitmap;
class SkCanvas;
-class SkNativeParsedPDF;
+class SkPdfNativeDoc;
struct SkRect;
class SkStream;
@@ -22,7 +22,7 @@
// TODO(edisonn): move in another file
class SkPdfRenderer : public SkRefCnt {
- SkNativeParsedPDF* fPdfDoc;
+ SkPdfNativeDoc* fPdfDoc;
public:
SkPdfRenderer() : fPdfDoc(NULL) {}
virtual ~SkPdfRenderer() {unload();}
diff --git a/experimental/PdfViewer/SkPdfUtils.h b/experimental/PdfViewer/SkPdfUtils.h
index 6555ac5..35c2cea 100644
--- a/experimental/PdfViewer/SkPdfUtils.h
+++ b/experimental/PdfViewer/SkPdfUtils.h
@@ -1,12 +1,60 @@
#ifndef __DEFINED__SkPdfUtils
#define __DEFINED__SkPdfUtils
-#include "SkPdfBasics.h"
+#include "SkMatrix.h"
+#include "SkRect.h"
class SkPdfArray;
+class SkPdfContext;
+class SkCanvas;
+class SkPdfNativeObject;
+
+// TODO(edisonn): temporary code, to report how much of the PDF we actually think we rendered.
+enum SkPdfResult {
+ kOK_SkPdfResult,
+ kPartial_SkPdfResult,
+ kNYI_SkPdfResult,
+ kIgnoreError_SkPdfResult,
+ kError_SkPdfResult,
+ kUnsupported_SkPdfResult,
+
+ kCount_SkPdfResult
+};
+
+struct NotOwnedString {
+ const unsigned char* fBuffer;
+ size_t fBytes;
+
+ static void init(NotOwnedString* str) {
+ str->fBuffer = NULL;
+ str->fBytes = 0;
+ }
+
+ static void init(NotOwnedString* str, const char* sz) {
+ str->fBuffer = (const unsigned char*)sz;
+ str->fBytes = strlen(sz);
+ }
+
+ bool equals(const char* sz) {
+ return strncmp((const char*)fBuffer, sz, fBytes) == 0 && fBytes == strlen(sz);
+
+ }
+};
SkMatrix SkMatrixFromPdfArray(SkPdfArray* pdfArray);
-PdfResult doType3Char(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfObject* skobj, SkRect bBox, SkMatrix matrix, double textSize);
+SkPdfResult doType3Char(SkPdfContext* pdfContext, SkCanvas* canvas, const SkPdfNativeObject* skobj, SkRect bBox, SkMatrix matrix, double textSize);
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// TRACE functions
+//
+#ifdef PDF_TRACE
+void SkTraceMatrix(const SkMatrix& matrix, const char* sz);
+void SkTraceRect(const SkRect& rect, const char* sz);
+#else
+#define SkTraceMatrix(a,b)
+#define SkTraceRect(a,b)
+#endif
#endif // __DEFINED__SkPdfUtils
diff --git a/experimental/PdfViewer/generate_code.py b/experimental/PdfViewer/generate_code.py
index 0fb566d..c02f256 100644
--- a/experimental/PdfViewer/generate_code.py
+++ b/experimental/PdfViewer/generate_code.py
@@ -9,10 +9,10 @@
# TODO(edisonn): date and some other types are in fact strings, with a custom format!!!
# TODO(edisonn): refer to page 99 (PDF data types)
knowTypes = {
-'(any)': ['SkPdfObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'],
+'(any)': ['SkPdfNativeObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'],
# TODO(edisonn): return constant for undefined
-'(undefined)': ['SkPdfObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'],
-'(various)': ['SkPdfObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'],
+'(undefined)': ['SkPdfNativeObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'],
+'(various)': ['SkPdfNativeObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'],
'array': ['SkPdfArray*', '(SkPdfArray*)ret', datatypes.CppNull(), 'ret->isArray()'],
'boolean': ['bool', 'ret->boolValue()', datatypes.PdfBoolean('false'), 'ret->isBoolean()'],
#date is a string, with special formating, add here the
@@ -254,8 +254,8 @@
for name in self.fClasses:
cls = self.fClasses[name]
- cls.fEnum = 'k' + name + '_SkPdfObjectType'
- cls.fEnumEnd = 'k' + name + '__End_SkPdfObjectType'
+ cls.fEnum = 'k' + name + '_SkPdfNativeObjectType'
+ cls.fEnumEnd = 'k' + name + '__End_SkPdfNativeObjectType'
fileHeadersNative.write('#include "SkPdf' + cls.fName + '_autogen.h"\n')
fileHeadersNativeCpp.write('#include "SkPdf' + cls.fName + '_autogen.cpp"\n')
@@ -280,8 +280,8 @@
fileEnums.write('#define __DEFINED__SkPdfEnums\n')
fileEnums.write('\n')
- fileEnums.write('enum SkPdfObjectType {\n')
- fileEnums.write(' kNone_SkPdfObjectType = 0,\n')
+ fileEnums.write('enum SkPdfNativeObjectType {\n')
+ fileEnums.write(' kNone_SkPdfNativeObjectType = 0,\n')
for enum in enumsRoot:
self.writeEnum(fileEnums, enum, enumToCls)
fileEnums.write('};\n')
@@ -315,13 +315,13 @@
nativeFileClass.write('#include <string>\n')
nativeFileClass.write('#include "SkPdfEnums_autogen.h"\n')
nativeFileClass.write('#include "SkPdfNYI.h"\n')
- nativeFileClass.write('#include "SkPdfObject.h"\n')
- nativeFileClass.write('class SkNativeParsedPDF;\n')
+ nativeFileClass.write('#include "SkPdfNativeObject.h"\n')
+ nativeFileClass.write('class SkPdfNativeDoc;\n')
if cls.fBase != '':
nativeFileClass.write('#include "SkPdf' + cls.fBase + '_autogen.h"\n')
- nativeFileClassCpp.write('#include "SkNativeParsedPDF.h"\n')
+ nativeFileClassCpp.write('#include "SkPdfNativeDoc.h"\n')
nativeFileClass.write('\n')
@@ -330,7 +330,7 @@
nativeFileClass.write('// ' + cls.fComment + '\n')
if cls.fBase == '':
- nativeFileClass.write('class SkPdf' + cls.fName + ' : public SkPdfObject {\n')
+ nativeFileClass.write('class SkPdf' + cls.fName + ' : public SkPdfNativeObject {\n')
else:
nativeFileClass.write('class SkPdf' + cls.fName + ' : public SkPdf' + cls.fBase + ' {\n')
@@ -375,9 +375,9 @@
if len(prop.fTypes.split()) == 1:
t = prop.fTypes.strip()
- nativeFileClass.write(' ' + knowTypes[t][0] + ' ' + prop.fCppName + '(SkNativeParsedPDF* doc);\n')
- nativeFileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::' + prop.fCppName + '(SkNativeParsedPDF* doc) {\n')
- nativeFileClassCpp.write(' SkPdfObject* ret = get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
+ nativeFileClass.write(' ' + knowTypes[t][0] + ' ' + prop.fCppName + '(SkPdfNativeDoc* doc);\n')
+ nativeFileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::' + prop.fCppName + '(SkPdfNativeDoc* doc) {\n')
+ nativeFileClassCpp.write(' SkPdfNativeObject* ret = get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
nativeFileClassCpp.write(' if (doc) {ret = doc->resolveReference(ret);}\n')
nativeFileClassCpp.write(' if ((ret != NULL && ' + knowTypes[t][3] + ') || (doc == NULL && ret != NULL && ret->isReference())) return ' + knowTypes[t][1] + ';\n')
@@ -396,19 +396,19 @@
for type in prop.fTypes.split():
t = type.strip()
- nativeFileClass.write(' bool is' + prop.fCppName + 'A' + t.title() + '(SkNativeParsedPDF* doc);\n')
+ nativeFileClass.write(' bool is' + prop.fCppName + 'A' + t.title() + '(SkPdfNativeDoc* doc);\n')
- nativeFileClassCpp.write('bool SkPdf' + cls.fName + '::is' + prop.fCppName + 'A' + t.title() + '(SkNativeParsedPDF* doc) {\n')
- nativeFileClassCpp.write(' SkPdfObject* ret = get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
+ nativeFileClassCpp.write('bool SkPdf' + cls.fName + '::is' + prop.fCppName + 'A' + t.title() + '(SkPdfNativeDoc* doc) {\n')
+ nativeFileClassCpp.write(' SkPdfNativeObject* ret = get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
nativeFileClassCpp.write(' if (doc) {ret = doc->resolveReference(ret);}\n')
nativeFileClassCpp.write(' return ret != NULL && ' + knowTypes[t][3] + ';\n')
nativeFileClassCpp.write('}\n')
nativeFileClassCpp.write('\n')
- nativeFileClass.write(' ' + knowTypes[t][0] + ' get' + prop.fCppName + 'As' + t.title() + '(SkNativeParsedPDF* doc);\n')
- nativeFileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::get' + prop.fCppName + 'As' + t.title() + '(SkNativeParsedPDF* doc) {\n')
+ nativeFileClass.write(' ' + knowTypes[t][0] + ' get' + prop.fCppName + 'As' + t.title() + '(SkPdfNativeDoc* doc);\n')
+ nativeFileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::get' + prop.fCppName + 'As' + t.title() + '(SkPdfNativeDoc* doc) {\n')
- nativeFileClassCpp.write(' SkPdfObject* ret = get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
+ nativeFileClassCpp.write(' SkPdfNativeObject* ret = get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
nativeFileClassCpp.write(' if (doc) {ret = doc->resolveReference(ret);}\n')
nativeFileClassCpp.write(' if ((ret != NULL && ' + knowTypes[t][3] + ') || (doc == NULL && ret != NULL && ret->isReference())) return ' + knowTypes[t][1] + ';\n')
@@ -458,51 +458,51 @@
fileMapperNative.write('\n')
fileMapperNative.write('#include "SkPdfHeaders_autogen.h"\n')
- fileMapperNative.write('#include "SkNativeParsedPDF.h"\n')
- fileMapperNative.write('#include "SkPdfObject.h"\n')
+ fileMapperNative.write('#include "SkPdfNativeDoc.h"\n')
+ fileMapperNative.write('#include "SkPdfNativeObject.h"\n')
fileMapperNativeCpp.write('#include "SkPdfMapper_autogen.h"\n')
fileMapperNativeCpp.write('#include "SkPdfUtils.h"\n')
- fileMapperNativeCpp.write('#include "SkPdfObject.h"\n')
+ fileMapperNativeCpp.write('#include "SkPdfNativeObject.h"\n')
fileMapperNativeCpp.write('\n')
fileMapperNative.write('class SkPdfMapper {\n')
- fileMapperNative.write(' SkNativeParsedPDF* fParsedDoc;\n')
+ fileMapperNative.write(' SkPdfNativeDoc* fParsedDoc;\n')
fileMapperNative.write('public:\n')
- fileMapperNative.write(' SkPdfMapper(SkNativeParsedPDF* doc) : fParsedDoc(doc) {}\n')
+ fileMapperNative.write(' SkPdfMapper(SkPdfNativeDoc* doc) : fParsedDoc(doc) {}\n')
fileMapperNative.write('\n')
for name in self.fClassesNamesInOrder:
cls = self.fClasses[name]
- fileMapperNative.write(' SkPdfObjectType map' + name + '(const SkPdfObject* in) const;\n')
+ fileMapperNative.write(' SkPdfNativeObjectType map' + name + '(const SkPdfNativeObject* in) const;\n')
- fileMapperNativeCpp.write('SkPdfObjectType SkPdfMapper::map' + name + '(const SkPdfObject* in) const {\n')
- fileMapperNativeCpp.write(' if (in == NULL || !is' + name + '(in)) return kNone_SkPdfObjectType;\n')
+ fileMapperNativeCpp.write('SkPdfNativeObjectType SkPdfMapper::map' + name + '(const SkPdfNativeObject* in) const {\n')
+ fileMapperNativeCpp.write(' if (in == NULL || !is' + name + '(in)) return kNone_SkPdfNativeObjectType;\n')
fileMapperNativeCpp.write('\n')
if len(cls.fEnumSubclasses) > 0:
- fileMapperNativeCpp.write(' SkPdfObjectType ret;\n')
+ fileMapperNativeCpp.write(' SkPdfNativeObjectType ret;\n')
# stream must be last one
hasStream = False
for sub in cls.fEnumSubclasses:
- fileMapperNativeCpp.write(' if (kNone_SkPdfObjectType != (ret = map' + enumToCls[sub].fName + '(in))) return ret;\n')
+ fileMapperNativeCpp.write(' if (kNone_SkPdfNativeObjectType != (ret = map' + enumToCls[sub].fName + '(in))) return ret;\n')
fileMapperNativeCpp.write('\n')
- fileMapperNativeCpp.write(' return k' + name + '_SkPdfObjectType;\n')
+ fileMapperNativeCpp.write(' return k' + name + '_SkPdfNativeObjectType;\n')
fileMapperNativeCpp.write('}\n')
fileMapperNativeCpp.write('\n')
for name in self.fClassesNamesInOrder:
cls = self.fClasses[name]
- fileMapperNative.write(' bool is' + name + '(const SkPdfObject* nativeObj) const ;\n')
- fileMapperNativeCpp.write('bool SkPdfMapper::is' + name + '(const SkPdfObject* nativeObj) const {\n')
+ fileMapperNative.write(' bool is' + name + '(const SkPdfNativeObject* nativeObj) const ;\n')
+ fileMapperNativeCpp.write('bool SkPdfMapper::is' + name + '(const SkPdfNativeObject* nativeObj) const {\n')
if cls.fCheck != '':
fileMapperNativeCpp.write(' return ' + cls.fCheck + ';\n')
@@ -513,7 +513,7 @@
prop = field.fProp
if prop.fHasMust:
if emitedRet == False:
- fileMapperNativeCpp.write(' const SkPdfObject* ret = NULL;\n')
+ fileMapperNativeCpp.write(' const SkPdfNativeObject* ret = NULL;\n')
emitedRet = True
cntMust = cntMust + 1
fileMapperNativeCpp.write(' if (!nativeObj->isDictionary()) return false;\n')
@@ -541,19 +541,19 @@
fileMapperNativeCpp.write('\n')
# TODO(edisonn): dict should be a SkPdfDictionary ?
- fileMapperNative.write(' bool SkPdf' + name + 'FromDictionary(const SkPdfObject* dict, const char* key, SkPdf' + name + '** data) const ;\n')
- fileMapperNativeCpp.write('bool SkPdfMapper::SkPdf' + name + 'FromDictionary(const SkPdfObject* dict, const char* key, SkPdf' + name + '** data) const {\n')
- fileMapperNativeCpp.write(' const SkPdfObject* value = dict->get(key);\n')
+ fileMapperNative.write(' bool SkPdf' + name + 'FromDictionary(const SkPdfNativeObject* dict, const char* key, SkPdf' + name + '** data) const ;\n')
+ fileMapperNativeCpp.write('bool SkPdfMapper::SkPdf' + name + 'FromDictionary(const SkPdfNativeObject* dict, const char* key, SkPdf' + name + '** data) const {\n')
+ fileMapperNativeCpp.write(' const SkPdfNativeObject* value = dict->get(key);\n')
fileMapperNativeCpp.write(' if (value == NULL) { return false; }\n')
fileMapperNativeCpp.write(' if (data == NULL) { return true; }\n')
- fileMapperNativeCpp.write(' if (kNone_SkPdfObjectType == map' + name + '(value)) return false;\n')
+ fileMapperNativeCpp.write(' if (kNone_SkPdfNativeObjectType == map' + name + '(value)) return false;\n')
fileMapperNativeCpp.write(' *data = (SkPdf' + name + '*)value;\n')
fileMapperNativeCpp.write(' return true;\n');
fileMapperNativeCpp.write('}\n')
fileMapperNativeCpp.write('\n')
- fileMapperNative.write(' bool SkPdf' + name + 'FromDictionary(const SkPdfObject* dict, const char* key, const char* abr, SkPdf' + name + '** data) const ;\n')
- fileMapperNativeCpp.write('bool SkPdfMapper::SkPdf' + name + 'FromDictionary(const SkPdfObject* dict, const char* key, const char* abr, SkPdf' + name + '** data) const {\n')
+ fileMapperNative.write(' bool SkPdf' + name + 'FromDictionary(const SkPdfNativeObject* dict, const char* key, const char* abr, SkPdf' + name + '** data) const ;\n')
+ fileMapperNativeCpp.write('bool SkPdfMapper::SkPdf' + name + 'FromDictionary(const SkPdfNativeObject* dict, const char* key, const char* abr, SkPdf' + name + '** data) const {\n')
fileMapperNativeCpp.write(' if (SkPdf' + name + 'FromDictionary(dict, key, data)) return true;\n')
fileMapperNativeCpp.write(' if (abr == NULL || *abr == \'\\0\') return false;\n')
fileMapperNativeCpp.write(' return SkPdf' + name + 'FromDictionary(dict, abr, data);\n')
diff --git a/experimental/PdfViewer/pdfparser/native/SkNativeParsedPDF.cpp b/experimental/PdfViewer/pdfparser/native/SkPdfNativeDoc.cpp
similarity index 85%
rename from experimental/PdfViewer/pdfparser/native/SkNativeParsedPDF.cpp
rename to experimental/PdfViewer/pdfparser/native/SkPdfNativeDoc.cpp
index d9f680c..3d17fb9 100644
--- a/experimental/PdfViewer/pdfparser/native/SkNativeParsedPDF.cpp
+++ b/experimental/PdfViewer/pdfparser/native/SkPdfNativeDoc.cpp
@@ -1,7 +1,6 @@
-#include "SkNativeParsedPDF.h"
+#include "SkPdfNativeDoc.h"
#include "SkPdfNativeTokenizer.h"
-#include "SkPdfBasics.h"
-#include "SkPdfObject.h"
+#include "SkPdfNativeObject.h"
#include <stdio.h>
#include <string.h>
@@ -59,7 +58,7 @@
return current;
}
-SkNativeParsedPDF* gDoc = NULL;
+SkPdfNativeDoc* gDoc = NULL;
// TODO(edisonn): NYI
// TODO(edisonn): 3 constructuctors from URL, from stream, from file ...
@@ -69,7 +68,7 @@
// 2) recoverable corupt file: remove endobj, endsteam, remove other keywords, use other white spaces, insert comments randomly, ...
// 3) irrecoverable corrupt file
-SkNativeParsedPDF::SkNativeParsedPDF(SkStream* stream)
+SkPdfNativeDoc::SkPdfNativeDoc(SkStream* stream)
: fAllocator(new SkPdfAllocator())
, fFileContent(NULL)
, fContentLength(0)
@@ -82,7 +81,7 @@
init(ptr, size);
}
-SkNativeParsedPDF::SkNativeParsedPDF(const char* path)
+SkPdfNativeDoc::SkPdfNativeDoc(const char* path)
: fAllocator(new SkPdfAllocator())
, fFileContent(NULL)
, fContentLength(0)
@@ -108,7 +107,7 @@
}
}
-void SkNativeParsedPDF::init(const void* bytes, size_t length) {
+void SkPdfNativeDoc::init(const void* bytes, size_t length) {
fFileContent = (const unsigned char*)bytes;
fContentLength = length;
const unsigned char* eofLine = lineHome(fFileContent, fFileContent + fContentLength - 1);
@@ -158,7 +157,7 @@
// and resolve references?... or not ...
}
-void SkNativeParsedPDF::loadWithoutXRef() {
+void SkPdfNativeDoc::loadWithoutXRef() {
const unsigned char* current = fFileContent;
const unsigned char* end = fFileContent + fContentLength;
@@ -167,7 +166,7 @@
current = skipPdfWhiteSpaces(0, current, end);
while (current < end) {
- SkPdfObject token;
+ SkPdfNativeObject token;
current = nextObject(0, current, end, &token, NULL, NULL);
if (token.isInteger()) {
int id = (int)token.intValue();
@@ -189,7 +188,7 @@
fObjects[id].fOffset = current - fFileContent;
- SkPdfObject* obj = fAllocator->allocObject();
+ SkPdfNativeObject* obj = fAllocator->allocObject();
current = nextObject(0, current, end, obj, fAllocator, this);
fObjects[id].fResolvedReference = obj;
@@ -210,8 +209,8 @@
// TODO(edisonn): hack, detect root catalog - we need to implement liniarized support, and remove this hack.
if (!fRootCatalogRef) {
for (unsigned int i = 0 ; i < objects(); i++) {
- SkPdfObject* obj = object(i);
- SkPdfObject* root = (obj && obj->isDictionary()) ? obj->get("Root") : NULL;
+ SkPdfNativeObject* obj = object(i);
+ SkPdfNativeObject* root = (obj && obj->isDictionary()) ? obj->get("Root") : NULL;
if (root && root->isReference()) {
fRootCatalogRef = root;
}
@@ -233,20 +232,20 @@
}
// TODO(edisonn): NYI
-SkNativeParsedPDF::~SkNativeParsedPDF() {
+SkPdfNativeDoc::~SkPdfNativeDoc() {
sk_free((void*)fFileContent);
delete fAllocator;
}
-const unsigned char* SkNativeParsedPDF::readCrossReferenceSection(const unsigned char* xrefStart, const unsigned char* trailerEnd) {
- SkPdfObject xref;
+const unsigned char* SkPdfNativeDoc::readCrossReferenceSection(const unsigned char* xrefStart, const unsigned char* trailerEnd) {
+ SkPdfNativeObject xref;
const unsigned char* current = nextObject(0, xrefStart, trailerEnd, &xref, NULL, NULL);
if (!xref.isKeyword("xref")) {
return trailerEnd;
}
- SkPdfObject token;
+ SkPdfNativeObject token;
while (current < trailerEnd) {
token.reset();
const unsigned char* previous = current;
@@ -297,12 +296,12 @@
return current;
}
-const unsigned char* SkNativeParsedPDF::readTrailer(const unsigned char* trailerStart, const unsigned char* trailerEnd, bool storeCatalog, long* prev, bool skipKeyword) {
+const unsigned char* SkPdfNativeDoc::readTrailer(const unsigned char* trailerStart, const unsigned char* trailerEnd, bool storeCatalog, long* prev, bool skipKeyword) {
*prev = -1;
const unsigned char* current = trailerStart;
if (!skipKeyword) {
- SkPdfObject trailerKeyword;
+ SkPdfNativeObject trailerKeyword;
// TODO(edisonn): use null allocator, and let it just fail if memory
// needs allocated (but no crash)!
current = nextObject(0, current, trailerEnd, &trailerKeyword, NULL, NULL);
@@ -314,7 +313,7 @@
}
}
- SkPdfObject token;
+ SkPdfNativeObject token;
current = nextObject(0, current, trailerEnd, &token, fAllocator, NULL);
if (!token.isDictionary()) {
return current;
@@ -325,7 +324,7 @@
}
if (storeCatalog) {
- SkPdfObject* ref = trailer->Root(NULL);
+ SkPdfNativeObject* ref = trailer->Root(NULL);
if (ref == NULL || !ref->isReference()) {
// TODO(edisonn): oops, we have to fix the corrup pdf file
return current;
@@ -340,7 +339,7 @@
return current;
}
-void SkNativeParsedPDF::addCrossSectionInfo(int id, int generation, int offset, bool isFreed) {
+void SkPdfNativeDoc::addCrossSectionInfo(int id, int generation, int offset, bool isFreed) {
// TODO(edisonn): security here
while (fObjects.count() < id + 1) {
reset(fObjects.append());
@@ -351,7 +350,7 @@
fObjects[id].fResolvedReference = NULL;
}
-SkPdfObject* SkNativeParsedPDF::readObject(int id/*, int expectedGeneration*/) {
+SkPdfNativeObject* SkPdfNativeDoc::readObject(int id/*, int expectedGeneration*/) {
long startOffset = fObjects[id].fOffset;
//long endOffset = fObjects[id].fOffsetEnd;
// TODO(edisonn): use hinted endOffset
@@ -364,10 +363,10 @@
SkPdfNativeTokenizer tokenizer(current, end - current, fMapper, fAllocator, this);
- SkPdfObject idObj;
- SkPdfObject generationObj;
- SkPdfObject objKeyword;
- SkPdfObject* dict = fAllocator->allocObject();
+ SkPdfNativeObject idObj;
+ SkPdfNativeObject generationObj;
+ SkPdfNativeObject objKeyword;
+ SkPdfNativeObject* dict = fAllocator->allocObject();
current = nextObject(0, current, end, &idObj, NULL, NULL);
if (current >= end) {
@@ -402,7 +401,7 @@
return dict;
}
-void SkNativeParsedPDF::fillPages(SkPdfPageTreeNodeDictionary* tree) {
+void SkPdfNativeDoc::fillPages(SkPdfPageTreeNodeDictionary* tree) {
SkPdfArray* kids = tree->Kids(this);
if (kids == NULL) {
*fPages.append() = (SkPdfPageObjectDictionary*)tree;
@@ -411,8 +410,8 @@
int cnt = kids->size();
for (int i = 0; i < cnt; i++) {
- SkPdfObject* obj = resolveReference(kids->objAtAIndex(i));
- if (fMapper->mapPageObjectDictionary(obj) != kPageObjectDictionary_SkPdfObjectType) {
+ SkPdfNativeObject* obj = resolveReference(kids->objAtAIndex(i));
+ if (fMapper->mapPageObjectDictionary(obj) != kPageObjectDictionary_SkPdfNativeObjectType) {
*fPages.append() = (SkPdfPageObjectDictionary*)obj;
} else {
// TODO(edisonn): verify that it is a page tree indeed
@@ -421,23 +420,23 @@
}
}
-int SkNativeParsedPDF::pages() const {
+int SkPdfNativeDoc::pages() const {
return fPages.count();
}
-SkPdfPageObjectDictionary* SkNativeParsedPDF::page(int page) {
+SkPdfPageObjectDictionary* SkPdfNativeDoc::page(int page) {
SkASSERT(page >= 0 && page < fPages.count());
return fPages[page];
}
-SkPdfResourceDictionary* SkNativeParsedPDF::pageResources(int page) {
+SkPdfResourceDictionary* SkPdfNativeDoc::pageResources(int page) {
SkASSERT(page >= 0 && page < fPages.count());
return fPages[page]->Resources(this);
}
// TODO(edisonn): Partial implemented. Move the logics directly in the code generator for inheritable and default value?
-SkRect SkNativeParsedPDF::MediaBox(int page) {
+SkRect SkPdfNativeDoc::MediaBox(int page) {
SkPdfPageObjectDictionary* current = fPages[page];
while (!current->has_MediaBox() && current->has_Parent()) {
current = (SkPdfPageObjectDictionary*)current->Parent(this);
@@ -449,7 +448,7 @@
}
// TODO(edisonn): stream or array ... ? for now only array
-SkPdfNativeTokenizer* SkNativeParsedPDF::tokenizerOfPage(int page,
+SkPdfNativeTokenizer* SkPdfNativeDoc::tokenizerOfPage(int page,
SkPdfAllocator* allocator) {
if (fPages[page]->isContentsAStream(this)) {
return tokenizerOfStream(fPages[page]->getContentsAsStream(this), allocator);
@@ -460,7 +459,7 @@
}
}
-SkPdfNativeTokenizer* SkNativeParsedPDF::tokenizerOfStream(SkPdfObject* stream,
+SkPdfNativeTokenizer* SkPdfNativeDoc::tokenizerOfStream(SkPdfNativeObject* stream,
SkPdfAllocator* allocator) {
if (stream == NULL) {
return NULL;
@@ -470,18 +469,18 @@
}
// TODO(edisonn): NYI
-SkPdfNativeTokenizer* SkNativeParsedPDF::tokenizerOfBuffer(const unsigned char* buffer, size_t len,
+SkPdfNativeTokenizer* SkPdfNativeDoc::tokenizerOfBuffer(const unsigned char* buffer, size_t len,
SkPdfAllocator* allocator) {
// warning does not track two calls in the same buffer! the buffer is updated!
// make a clean copy if needed!
return new SkPdfNativeTokenizer(buffer, len, fMapper, allocator, this);
}
-size_t SkNativeParsedPDF::objects() const {
+size_t SkPdfNativeDoc::objects() const {
return fObjects.count();
}
-SkPdfObject* SkNativeParsedPDF::object(int i) {
+SkPdfNativeObject* SkPdfNativeDoc::object(int i) {
SkASSERT(!(i < 0 || i > fObjects.count()));
if (i < 0 || i > fObjects.count()) {
@@ -497,35 +496,35 @@
return fObjects[i].fObj;
}
-const SkPdfMapper* SkNativeParsedPDF::mapper() const {
+const SkPdfMapper* SkPdfNativeDoc::mapper() const {
return fMapper;
}
-SkPdfReal* SkNativeParsedPDF::createReal(double value) const {
- SkPdfObject* obj = fAllocator->allocObject();
- SkPdfObject::makeReal(value, obj);
+SkPdfReal* SkPdfNativeDoc::createReal(double value) const {
+ SkPdfNativeObject* obj = fAllocator->allocObject();
+ SkPdfNativeObject::makeReal(value, obj);
return (SkPdfReal*)obj;
}
-SkPdfInteger* SkNativeParsedPDF::createInteger(int value) const {
- SkPdfObject* obj = fAllocator->allocObject();
- SkPdfObject::makeInteger(value, obj);
+SkPdfInteger* SkPdfNativeDoc::createInteger(int value) const {
+ SkPdfNativeObject* obj = fAllocator->allocObject();
+ SkPdfNativeObject::makeInteger(value, obj);
return (SkPdfInteger*)obj;
}
-SkPdfString* SkNativeParsedPDF::createString(const unsigned char* sz, size_t len) const {
- SkPdfObject* obj = fAllocator->allocObject();
- SkPdfObject::makeString(sz, len, obj);
+SkPdfString* SkPdfNativeDoc::createString(const unsigned char* sz, size_t len) const {
+ SkPdfNativeObject* obj = fAllocator->allocObject();
+ SkPdfNativeObject::makeString(sz, len, obj);
return (SkPdfString*)obj;
}
-SkPdfAllocator* SkNativeParsedPDF::allocator() const {
+SkPdfAllocator* SkPdfNativeDoc::allocator() const {
return fAllocator;
}
// TODO(edisonn): fix infinite loop if ref to itself!
// TODO(edisonn): perf, fix refs at load, and resolve will simply return fResolvedReference?
-SkPdfObject* SkNativeParsedPDF::resolveReference(SkPdfObject* ref) {
+SkPdfNativeObject* SkPdfNativeDoc::resolveReference(SkPdfNativeObject* ref) {
if (ref && ref->isReference()) {
int id = ref->referenceId();
// TODO(edisonn): generation/updates not supported now
@@ -564,13 +563,11 @@
return fObjects[id].fResolvedReference;
}
-
-
// TODO(edisonn): fix the mess with const, probably we need to remove it pretty much everywhere
- return (SkPdfObject*)ref;
+ return (SkPdfNativeObject*)ref;
}
-size_t SkNativeParsedPDF::bytesUsed() const {
+size_t SkPdfNativeDoc::bytesUsed() const {
return fAllocator->bytesUsed() +
fContentLength +
fObjects.count() * sizeof(PublicObjectEntry) +
diff --git a/experimental/PdfViewer/pdfparser/native/SkNativeParsedPDF.h b/experimental/PdfViewer/pdfparser/native/SkPdfNativeDoc.h
similarity index 84%
rename from experimental/PdfViewer/pdfparser/native/SkNativeParsedPDF.h
rename to experimental/PdfViewer/pdfparser/native/SkPdfNativeDoc.h
index de71bf6..5f22c42 100644
--- a/experimental/PdfViewer/pdfparser/native/SkNativeParsedPDF.h
+++ b/experimental/PdfViewer/pdfparser/native/SkPdfNativeDoc.h
@@ -8,7 +8,7 @@
class SkPdfAllocator;
class SkPdfMapper;
-class SkPdfObject;
+class SkPdfNativeObject;
class SkPdfReal;
class SkPdfInteger;
class SkPdfString;
@@ -21,14 +21,14 @@
class SkStream;
-class SkNativeParsedPDF {
+class SkPdfNativeDoc {
private:
struct PublicObjectEntry {
long fOffset;
// long endOffset; // TODO(edisonn): determine the end of the object, to be used when the doc is corrupted
- SkPdfObject* fObj;
+ SkPdfNativeObject* fObj;
// TODO(edisonn): perf ... probably it does not make sense to cache the ref. test it!
- SkPdfObject* fResolvedReference;
+ SkPdfNativeObject* fResolvedReference;
};
public:
@@ -38,22 +38,22 @@
// TODO(edisonn): allow corruptions of file (e.g. missing endobj, missing stream length, ...)
// TODO(edisonn): encryption
- SkNativeParsedPDF(const char* path);
- SkNativeParsedPDF(SkStream* stream);
+ SkPdfNativeDoc(const char* path);
+ SkPdfNativeDoc(SkStream* stream);
- ~SkNativeParsedPDF();
+ ~SkPdfNativeDoc();
int pages() const;
SkPdfResourceDictionary* pageResources(int page);
SkRect MediaBox(int page);
SkPdfNativeTokenizer* tokenizerOfPage(int n, SkPdfAllocator* allocator);
- SkPdfNativeTokenizer* tokenizerOfStream(SkPdfObject* stream, SkPdfAllocator* allocator);
+ SkPdfNativeTokenizer* tokenizerOfStream(SkPdfNativeObject* stream, SkPdfAllocator* allocator);
SkPdfNativeTokenizer* tokenizerOfBuffer(const unsigned char* buffer, size_t len,
SkPdfAllocator* allocator);
size_t objects() const;
- SkPdfObject* object(int i);
+ SkPdfNativeObject* object(int i);
SkPdfPageObjectDictionary* page(int page);
const SkPdfMapper* mapper() const;
@@ -64,7 +64,7 @@
// the string does not own the char*
SkPdfString* createString(const unsigned char* sz, size_t len) const;
- SkPdfObject* resolveReference(SkPdfObject* ref);
+ SkPdfNativeObject* resolveReference(SkPdfNativeObject* ref);
// Reports an approximation of all the memory usage.
size_t bytesUsed() const;
@@ -86,7 +86,7 @@
obj->fOffset = -1;
}
- SkPdfObject* readObject(int id/*, int generation*/);
+ SkPdfNativeObject* readObject(int id/*, int generation*/);
void fillPages(SkPdfPageTreeNodeDictionary* tree);
@@ -95,7 +95,7 @@
SkPdfMapper* fMapper;
const unsigned char* fFileContent;
size_t fContentLength;
- SkPdfObject* fRootCatalogRef;
+ SkPdfNativeObject* fRootCatalogRef;
SkPdfCatalogDictionary* fRootCatalog;
mutable SkTDArray<PublicObjectEntry> fObjects;
diff --git a/experimental/PdfViewer/pdfparser/native/SkPdfObject.cpp b/experimental/PdfViewer/pdfparser/native/SkPdfNativeObject.cpp
similarity index 86%
rename from experimental/PdfViewer/pdfparser/native/SkPdfObject.cpp
rename to experimental/PdfViewer/pdfparser/native/SkPdfNativeObject.cpp
index a02d789..b0f62aa 100644
--- a/experimental/PdfViewer/pdfparser/native/SkPdfObject.cpp
+++ b/experimental/PdfViewer/pdfparser/native/SkPdfNativeObject.cpp
@@ -1,5 +1,5 @@
-#include "SkPdfObject.h"
+#include "SkPdfNativeObject.h"
#include "SkPdfStreamCommonDictionary_autogen.h"
#include "SkFlate.h"
@@ -9,9 +9,9 @@
#include "SkBitmap.h"
#include "SkPdfFont.h"
-SkPdfObject SkPdfObject::kNull = SkPdfObject::makeNull();
+SkPdfNativeObject SkPdfNativeObject::kNull = SkPdfNativeObject::makeNull();
-bool SkPdfObject::applyFlateDecodeFilter() {
+bool SkPdfNativeObject::applyFlateDecodeFilter() {
if (!SkFlate::HaveFlate()) {
// TODO(edisonn): warn, make callers handle it
return false;
@@ -39,14 +39,14 @@
}
}
-bool SkPdfObject::applyDCTDecodeFilter() {
+bool SkPdfNativeObject::applyDCTDecodeFilter() {
// this would fail, and it won't allow any more filters.
// technically, it would be possible, but not a real world scenario
// TODO(edisonn): or get the image here and store it for fast retrieval?
return false;
}
-bool SkPdfObject::applyFilter(const char* name) {
+bool SkPdfNativeObject::applyFilter(const char* name) {
if (strcmp(name, "FlateDecode") == 0) {
return applyFlateDecodeFilter();
} else if (strcmp(name, "DCTDecode") == 0) {
@@ -56,7 +56,7 @@
return false;
}
-bool SkPdfObject::filterStream() {
+bool SkPdfNativeObject::filterStream() {
if (!hasStream()) {
return false;
}
@@ -76,7 +76,7 @@
const SkPdfArray* filters = stream->getFilterAsArray(NULL);
int cnt = filters->size();
for (int i = cnt - 1; i >= 0; i--) {
- const SkPdfObject* filterName = filters->objAtAIndex(i);
+ const SkPdfNativeObject* filterName = filters->objAtAIndex(i);
if (filterName != NULL && filterName->isName()) {
if (!applyFilter(filterName->nameValue())) {
break;
@@ -90,7 +90,7 @@
return true;
}
-void SkPdfObject::releaseData() {
+void SkPdfNativeObject::releaseData() {
if (fData) {
switch (fDataType) {
case kFont_Data:
diff --git a/experimental/PdfViewer/pdfparser/native/SkPdfObject.h b/experimental/PdfViewer/pdfparser/native/SkPdfNativeObject.h
similarity index 83%
rename from experimental/PdfViewer/pdfparser/native/SkPdfObject.h
rename to experimental/PdfViewer/pdfparser/native/SkPdfNativeObject.h
index 1fb4e1f..1fa6272 100644
--- a/experimental/PdfViewer/pdfparser/native/SkPdfObject.h
+++ b/experimental/PdfViewer/pdfparser/native/SkPdfNativeObject.h
@@ -12,6 +12,9 @@
#include "SkPdfNYI.h"
#include "SkPdfConfig.h"
+#include "SkPdfUtils.h"
+
+#include "SkPdfNativeTokenizer.h"
class SkPdfDictionary;
class SkPdfStream;
@@ -25,7 +28,7 @@
#define kUnfilteredStreamBit 1
#define kOwnedStreamBit 2
-class SkPdfObject {
+class SkPdfNativeObject {
public:
enum ObjectType {
kInvalid_PdfObjectType,
@@ -78,10 +81,10 @@
NotOwnedString fStr;
// TODO(edisonn): make sure the foorprint of fArray and fMap is small, otherwise, use pointers, or classes with up to 8 bytes in footprint
- SkTDArray<SkPdfObject*>* fArray;
+ SkTDArray<SkPdfNativeObject*>* fArray;
Reference fRef;
};
- SkTDict<SkPdfObject*>* fMap;
+ SkTDict<SkPdfNativeObject*>* fMap;
// TODO(edisonn): rename data with cache
void* fData;
@@ -90,7 +93,7 @@
public:
- SkPdfObject() : fObjectType(kInvalid_PdfObjectType), fMap(NULL), fData(NULL), fDataType(kEmpty_Data) {}
+ SkPdfNativeObject() : fObjectType(kInvalid_PdfObjectType), fMap(NULL), fData(NULL), fDataType(kEmpty_Data) {}
inline bool hasData(DataType type) {
@@ -109,7 +112,7 @@
void releaseData();
-// ~SkPdfObject() {
+// ~SkPdfNativeObject() {
// //reset(); must be called manually!
// }
@@ -190,49 +193,49 @@
return nyi;
}
- static void makeBoolean(bool value, SkPdfObject* obj) {
+ static void makeBoolean(bool value, SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fObjectType = kBoolean_PdfObjectType;
obj->fBooleanValue = value;
}
- static SkPdfObject makeBoolean(bool value) {
- SkPdfObject obj;
+ static SkPdfNativeObject makeBoolean(bool value) {
+ SkPdfNativeObject obj;
obj.fObjectType = kBoolean_PdfObjectType;
obj.fBooleanValue = value;
return obj;
}
- static void makeInteger(int64_t value, SkPdfObject* obj) {
+ static void makeInteger(int64_t value, SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fObjectType = kInteger_PdfObjectType;
obj->fIntegerValue = value;
}
- static void makeReal(double value, SkPdfObject* obj) {
+ static void makeReal(double value, SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fObjectType = kReal_PdfObjectType;
obj->fRealValue = value;
}
- static void makeNull(SkPdfObject* obj) {
+ static void makeNull(SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fObjectType = kNull_PdfObjectType;
}
- static SkPdfObject makeNull() {
- SkPdfObject obj;
+ static SkPdfNativeObject makeNull() {
+ SkPdfNativeObject obj;
obj.fObjectType = kNull_PdfObjectType;
return obj;
}
- static SkPdfObject kNull;
+ static SkPdfNativeObject kNull;
- static void makeNumeric(const unsigned char* start, const unsigned char* end, SkPdfObject* obj) {
+ static void makeNumeric(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
// TODO(edisonn): NYI properly
@@ -252,7 +255,7 @@
}
}
- static void makeReference(unsigned int id, unsigned int gen, SkPdfObject* obj) {
+ static void makeReference(unsigned int id, unsigned int gen, SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fObjectType = kReference_PdfObjectType;
@@ -261,69 +264,69 @@
}
- static void makeString(const unsigned char* start, SkPdfObject* obj) {
+ static void makeString(const unsigned char* start, SkPdfNativeObject* obj) {
makeStringCore(start, strlen((const char*)start), obj, kString_PdfObjectType);
}
- static void makeString(const unsigned char* start, const unsigned char* end, SkPdfObject* obj) {
+ static void makeString(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* obj) {
makeStringCore(start, end - start, obj, kString_PdfObjectType);
}
- static void makeString(const unsigned char* start, size_t bytes, SkPdfObject* obj) {
+ static void makeString(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj) {
makeStringCore(start, bytes, obj, kString_PdfObjectType);
}
- static void makeHexString(const unsigned char* start, SkPdfObject* obj) {
+ static void makeHexString(const unsigned char* start, SkPdfNativeObject* obj) {
makeStringCore(start, strlen((const char*)start), obj, kHexString_PdfObjectType);
}
- static void makeHexString(const unsigned char* start, const unsigned char* end, SkPdfObject* obj) {
+ static void makeHexString(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* obj) {
makeStringCore(start, end - start, obj, kHexString_PdfObjectType);
}
- static void makeHexString(const unsigned char* start, size_t bytes, SkPdfObject* obj) {
+ static void makeHexString(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj) {
makeStringCore(start, bytes, obj, kHexString_PdfObjectType);
}
- static void makeName(const unsigned char* start, SkPdfObject* obj) {
+ static void makeName(const unsigned char* start, SkPdfNativeObject* obj) {
makeStringCore(start, strlen((const char*)start), obj, kName_PdfObjectType);
}
- static void makeName(const unsigned char* start, const unsigned char* end, SkPdfObject* obj) {
+ static void makeName(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* obj) {
makeStringCore(start, end - start, obj, kName_PdfObjectType);
}
- static void makeName(const unsigned char* start, size_t bytes, SkPdfObject* obj) {
+ static void makeName(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj) {
makeStringCore(start, bytes, obj, kName_PdfObjectType);
}
- static void makeKeyword(const unsigned char* start, SkPdfObject* obj) {
+ static void makeKeyword(const unsigned char* start, SkPdfNativeObject* obj) {
makeStringCore(start, strlen((const char*)start), obj, kKeyword_PdfObjectType);
}
- static void makeKeyword(const unsigned char* start, const unsigned char* end, SkPdfObject* obj) {
+ static void makeKeyword(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* obj) {
makeStringCore(start, end - start, obj, kKeyword_PdfObjectType);
}
- static void makeKeyword(const unsigned char* start, size_t bytes, SkPdfObject* obj) {
+ static void makeKeyword(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj) {
makeStringCore(start, bytes, obj, kKeyword_PdfObjectType);
}
// TODO(edisonn): make the functions to return SkPdfArray, move these functions in SkPdfArray
- static void makeEmptyArray(SkPdfObject* obj) {
+ static void makeEmptyArray(SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fObjectType = kArray_PdfObjectType;
- obj->fArray = new SkTDArray<SkPdfObject*>();
+ obj->fArray = new SkTDArray<SkPdfNativeObject*>();
// return (SkPdfArray*)obj;
}
- bool appendInArray(SkPdfObject* obj) {
+ bool appendInArray(SkPdfNativeObject* obj) {
SkASSERT(fObjectType == kArray_PdfObjectType);
if (fObjectType != kArray_PdfObjectType) {
// TODO(edisonn): report err
@@ -340,35 +343,35 @@
return fArray->count();
}
- SkPdfObject* objAtAIndex(int i) {
+ SkPdfNativeObject* objAtAIndex(int i) {
SkASSERT(fObjectType == kArray_PdfObjectType);
return (*fArray)[i];
}
- SkPdfObject* removeLastInArray() {
+ SkPdfNativeObject* removeLastInArray() {
SkASSERT(fObjectType == kArray_PdfObjectType);
- SkPdfObject* ret = NULL;
+ SkPdfNativeObject* ret = NULL;
fArray->pop(&ret);
return ret;
}
- const SkPdfObject* objAtAIndex(int i) const {
+ const SkPdfNativeObject* objAtAIndex(int i) const {
SkASSERT(fObjectType == kArray_PdfObjectType);
return (*fArray)[i];
}
- SkPdfObject* operator[](int i) {
+ SkPdfNativeObject* operator[](int i) {
SkASSERT(fObjectType == kArray_PdfObjectType);
return (*fArray)[i];
}
- const SkPdfObject* operator[](int i) const {
+ const SkPdfNativeObject* operator[](int i) const {
SkASSERT(fObjectType == kArray_PdfObjectType);
return (*fArray)[i];
@@ -376,11 +379,11 @@
// TODO(edisonn): make the functions to return SkPdfDictionary, move these functions in SkPdfDictionary
- static void makeEmptyDictionary(SkPdfObject* obj) {
+ static void makeEmptyDictionary(SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fObjectType = kDictionary_PdfObjectType;
- obj->fMap = new SkTDict<SkPdfObject*>(1);
+ obj->fMap = new SkTDict<SkPdfNativeObject*>(1);
obj->fStr.fBuffer = NULL;
obj->fStr.fBytes = 0;
}
@@ -392,7 +395,7 @@
// which will be used in code
// add function SkPdfFastNameKey key(const char* key);
// TODO(edisonn): setting the same key twike, will make the value undefined!
- bool set(const SkPdfObject* key, SkPdfObject* value) {
+ bool set(const SkPdfNativeObject* key, SkPdfNativeObject* value) {
SkASSERT(fObjectType == kDictionary_PdfObjectType);
SkASSERT(key->fObjectType == kName_PdfObjectType);
@@ -407,11 +410,11 @@
return set(key->fStr.fBuffer, key->fStr.fBytes, value);
}
- bool set(const char* key, SkPdfObject* value) {
+ bool set(const char* key, SkPdfNativeObject* value) {
return set((const unsigned char*)key, strlen(key), value);
}
- bool set(const unsigned char* key, size_t len, SkPdfObject* value) {
+ bool set(const unsigned char* key, size_t len, SkPdfNativeObject* value) {
SkASSERT(fObjectType == kDictionary_PdfObjectType);
if (fObjectType != kDictionary_PdfObjectType) {
@@ -422,7 +425,7 @@
return fMap->set((const char*)key, len, value);
}
- SkPdfObject* get(const SkPdfObject* key) {
+ SkPdfNativeObject* get(const SkPdfNativeObject* key) {
SkASSERT(fObjectType == kDictionary_PdfObjectType);
SkASSERT(key->fObjectType == kName_PdfObjectType);
@@ -436,18 +439,18 @@
return get(key->fStr.fBuffer, key->fStr.fBytes);
}
- SkPdfObject* get(const char* key) {
+ SkPdfNativeObject* get(const char* key) {
return get((const unsigned char*)key, strlen(key));
}
- SkPdfObject* get(const unsigned char* key, size_t len) {
+ SkPdfNativeObject* get(const unsigned char* key, size_t len) {
SkASSERT(fObjectType == kDictionary_PdfObjectType);
SkASSERT(key);
if (fObjectType != kDictionary_PdfObjectType) {
// TODO(edisonn): report err
return NULL;
}
- SkPdfObject* ret = NULL;
+ SkPdfNativeObject* ret = NULL;
fMap->find((const char*)key, len, &ret);
#ifdef PDF_TRACE
@@ -459,7 +462,7 @@
return ret;
}
- const SkPdfObject* get(const SkPdfObject* key) const {
+ const SkPdfNativeObject* get(const SkPdfNativeObject* key) const {
SkASSERT(fObjectType == kDictionary_PdfObjectType);
SkASSERT(key->fObjectType == kName_PdfObjectType);
@@ -473,18 +476,18 @@
return get(key->fStr.fBuffer, key->fStr.fBytes);
}
- const SkPdfObject* get(const char* key) const {
+ const SkPdfNativeObject* get(const char* key) const {
return get((const unsigned char*)key, strlen(key));
}
- const SkPdfObject* get(const unsigned char* key, size_t len) const {
+ const SkPdfNativeObject* get(const unsigned char* key, size_t len) const {
SkASSERT(fObjectType == kDictionary_PdfObjectType);
SkASSERT(key);
if (fObjectType != kDictionary_PdfObjectType) {
// TODO(edisonn): report err
return NULL;
}
- SkPdfObject* ret = NULL;
+ SkPdfNativeObject* ret = NULL;
fMap->find((const char*)key, len, &ret);
#ifdef PDF_TRACE
@@ -496,8 +499,8 @@
return ret;
}
- const SkPdfObject* get(const char* key, const char* abr) const {
- const SkPdfObject* ret = get(key);
+ const SkPdfNativeObject* get(const char* key, const char* abr) const {
+ const SkPdfNativeObject* ret = get(key);
// TODO(edisonn): / is a valid name, and it might be an abreviation, so "" should not be like NULL
// make this distiontion in generator, and remove "" from condition
if (ret != NULL || abr == NULL || *abr == '\0') {
@@ -506,8 +509,8 @@
return get(abr);
}
- SkPdfObject* get(const char* key, const char* abr) {
- SkPdfObject* ret = get(key);
+ SkPdfNativeObject* get(const char* key, const char* abr) {
+ SkPdfNativeObject* ret = get(key);
// TODO(edisonn): / is a valid name, and it might be an abreviation, so "" should not be like NULL
// make this distiontion in generator, and remove "" from condition
if (ret != NULL || abr == NULL || *abr == '\0') {
@@ -758,7 +761,7 @@
double array[4];
for (int i = 0; i < 4; i++) {
// TODO(edisonn): version where we could resolve references?
- const SkPdfObject* elem = objAtAIndex(i);
+ const SkPdfNativeObject* elem = objAtAIndex(i);
if (elem == NULL || !elem->isNumber()) {
// TODO(edisonn): report error
return SkRect::MakeEmpty();
@@ -781,7 +784,7 @@
double array[6];
for (int i = 0; i < 6; i++) {
// TODO(edisonn): version where we could resolve references?
- const SkPdfObject* elem = objAtAIndex(i);
+ const SkPdfNativeObject* elem = objAtAIndex(i);
if (elem == NULL || !elem->isNumber()) {
// TODO(edisonn): report error
return SkMatrix::I();
@@ -862,6 +865,29 @@
}
}
+ static void append(SkString* str, const char* data, size_t len, const char* prefix = "\\x") {
+ for (unsigned int i = 0 ; i < len; i++) {
+ if (data[i] == kNUL_PdfWhiteSpace) {
+ str->append(prefix);
+ str->append("00");
+ } else if (data[i] == kHT_PdfWhiteSpace) {
+ str->append(prefix);
+ str->append("09");
+ } else if (data[i] == kLF_PdfWhiteSpace) {
+ str->append(prefix);
+ str->append("0A");
+ } else if (data[i] == kFF_PdfWhiteSpace) {
+ str->append(prefix);
+ str->append("0C");
+ } else if (data[i] == kCR_PdfWhiteSpace) {
+ str->append(prefix);
+ str->append("0D");
+ } else {
+ str->append(data + i, 1);
+ }
+ }
+ }
+
SkString toString(int firstRowLevel = 0, int level = 0) {
SkString str;
appendSpaces(&str, firstRowLevel);
@@ -884,7 +910,7 @@
case kString_PdfObjectType:
str.append("\"");
- str.append((const char*)fStr.fBuffer, fStr.fBytes);
+ append(&str, (const char*)fStr.fBuffer, fStr.fBytes);
str.append("\"");
break;
@@ -898,11 +924,11 @@
case kName_PdfObjectType:
str.append("/");
- str.append((const char*)fStr.fBuffer, fStr.fBytes);
+ append(&str, (const char*)fStr.fBuffer, fStr.fBytes, "#");
break;
case kKeyword_PdfObjectType:
- str.append((const char*)fStr.fBuffer, fStr.fBytes);
+ append(&str, (const char*)fStr.fBuffer, fStr.fBytes);
break;
case kArray_PdfObjectType:
@@ -919,8 +945,8 @@
break;
case kDictionary_PdfObjectType: {
- SkTDict<SkPdfObject*>::Iter iter(*fMap);
- SkPdfObject* obj = NULL;
+ SkTDict<SkPdfNativeObject*>::Iter iter(*fMap);
+ SkPdfNativeObject* obj = NULL;
const char* key = NULL;
str.append("<<\n");
while ((key = iter.next(&obj)) != NULL) {
@@ -934,7 +960,7 @@
size_t length = 0;
if (GetFilteredStreamRef(&stream, &length)) {
str.append("stream\n");
- str.append((const char*)stream, length > 256 ? 256 : length);
+ append(&str, (const char*)stream, length > 256 ? 256 : length);
str.append("\nendstream");
} else {
str.append("stream STREAM_ERROR endstream");
@@ -964,15 +990,15 @@
}
private:
- static void makeStringCore(const unsigned char* start, SkPdfObject* obj, ObjectType type) {
+ static void makeStringCore(const unsigned char* start, SkPdfNativeObject* obj, ObjectType type) {
makeStringCore(start, strlen((const char*)start), obj, type);
}
- static void makeStringCore(const unsigned char* start, const unsigned char* end, SkPdfObject* obj, ObjectType type) {
+ static void makeStringCore(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* obj, ObjectType type) {
makeStringCore(start, end - start, obj, type);
}
- static void makeStringCore(const unsigned char* start, size_t bytes, SkPdfObject* obj, ObjectType type) {
+ static void makeStringCore(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj, ObjectType type) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fObjectType = type;
@@ -985,20 +1011,20 @@
bool applyDCTDecodeFilter();
};
-class SkPdfStream : public SkPdfObject {};
-class SkPdfArray : public SkPdfObject {};
-class SkPdfString : public SkPdfObject {};
-class SkPdfHexString : public SkPdfObject {};
-class SkPdfInteger : public SkPdfObject {};
-class SkPdfReal : public SkPdfObject {};
-class SkPdfNumber : public SkPdfObject {};
+class SkPdfStream : public SkPdfNativeObject {};
+class SkPdfArray : public SkPdfNativeObject {};
+class SkPdfString : public SkPdfNativeObject {};
+class SkPdfHexString : public SkPdfNativeObject {};
+class SkPdfInteger : public SkPdfNativeObject {};
+class SkPdfReal : public SkPdfNativeObject {};
+class SkPdfNumber : public SkPdfNativeObject {};
-class SkPdfName : public SkPdfObject {
- SkPdfName() : SkPdfObject() {
- SkPdfObject::makeName((const unsigned char*)"", this);
+class SkPdfName : public SkPdfNativeObject {
+ SkPdfName() : SkPdfNativeObject() {
+ SkPdfNativeObject::makeName((const unsigned char*)"", this);
}
public:
- SkPdfName(char* name) : SkPdfObject() {
+ SkPdfName(char* name) : SkPdfNativeObject() {
this->makeName((const unsigned char*)name, this);
}
};
diff --git a/experimental/PdfViewer/pdfparser/native/SkPdfNativeTokenizer.cpp b/experimental/PdfViewer/pdfparser/native/SkPdfNativeTokenizer.cpp
index 00861a5..28f3193 100644
--- a/experimental/PdfViewer/pdfparser/native/SkPdfNativeTokenizer.cpp
+++ b/experimental/PdfViewer/pdfparser/native/SkPdfNativeTokenizer.cpp
@@ -1,6 +1,6 @@
#include "SkPdfNativeTokenizer.h"
-#include "SkPdfObject.h"
+#include "SkPdfNativeObject.h"
#include "SkPdfConfig.h"
#include "SkPdfStreamCommonDictionary_autogen.h"
@@ -126,7 +126,7 @@
}
// last elem has to be ]
-static const unsigned char* readArray(int level, const unsigned char* start, const unsigned char* end, SkPdfObject* array, SkPdfAllocator* allocator, SkNativeParsedPDF* doc) {
+static const unsigned char* readArray(int level, const unsigned char* start, const unsigned char* end, SkPdfNativeObject* array, SkPdfAllocator* allocator, SkPdfNativeDoc* doc) {
if (allocator == NULL) {
// TODO(edisonn): report/warning error
return end;
@@ -148,15 +148,15 @@
return endOfToken;
}
- SkPdfObject* newObj = allocator->allocObject();
+ SkPdfNativeObject* newObj = allocator->allocObject();
start = nextObject(level + 1, start, end, newObj, allocator, doc);
// TODO(edisonn): perf/memory: put the variables on the stack, and flush them on the array only when
// we are sure they are not references!
if (newObj->isKeywordReference() && array->size() >= 2 && array->objAtAIndex(array->size() - 1)->isInteger() && array->objAtAIndex(array->size() - 2)->isInteger()) {
- SkPdfObject* gen = array->removeLastInArray();
- SkPdfObject* id = array->removeLastInArray();
+ SkPdfNativeObject* gen = array->removeLastInArray();
+ SkPdfNativeObject* id = array->removeLastInArray();
newObj->reset();
- SkPdfObject::makeReference((unsigned int)id->intValue(), (unsigned int)gen->intValue(), newObj);
+ SkPdfNativeObject::makeReference((unsigned int)id->intValue(), (unsigned int)gen->intValue(), newObj);
}
array->appendInArray(newObj);
}
@@ -296,7 +296,7 @@
return readString(level, start, end, NULL) - start;
}
-static const unsigned char* readString(int level, const unsigned char* start, const unsigned char* end, SkPdfObject* str, SkPdfAllocator* allocator) {
+static const unsigned char* readString(int level, const unsigned char* start, const unsigned char* end, SkPdfNativeObject* str, SkPdfAllocator* allocator) {
if (!allocator) {
return end;
}
@@ -304,7 +304,7 @@
// TODO(edisonn): optimize the allocation, don't allocate new string, but put it in a preallocated buffer
unsigned char* out = (unsigned char*)allocator->alloc(outLength);
start = readString(level, start, end, out);
- SkPdfObject::makeString(out, out + outLength, str);
+ SkPdfNativeObject::makeString(out, out + outLength, str);
TRACE_STRING(out, out + outLength);
return start; // consumed already ) at the end of the string
}
@@ -443,7 +443,7 @@
return readHexString(level, start, end, NULL) - start;
}
-static const unsigned char* readHexString(int level, const unsigned char* start, const unsigned char* end, SkPdfObject* str, SkPdfAllocator* allocator) {
+static const unsigned char* readHexString(int level, const unsigned char* start, const unsigned char* end, SkPdfNativeObject* str, SkPdfAllocator* allocator) {
if (!allocator) {
return end;
}
@@ -451,7 +451,7 @@
// TODO(edisonn): optimize the allocation, don't allocate new string, but put it in a preallocated buffer
unsigned char* out = (unsigned char*)allocator->alloc(outLength);
start = readHexString(level, start, end, out);
- SkPdfObject::makeHexString(out, out + outLength, str);
+ SkPdfNativeObject::makeHexString(out, out + outLength, str);
TRACE_HEXSTRING(out, out + outLength);
return start; // consumed already > at the end of the string
}
@@ -568,7 +568,7 @@
return readName(level, start, end, NULL) - start;
}
-static const unsigned char* readName(int level, const unsigned char* start, const unsigned char* end, SkPdfObject* name, SkPdfAllocator* allocator) {
+static const unsigned char* readName(int level, const unsigned char* start, const unsigned char* end, SkPdfNativeObject* name, SkPdfAllocator* allocator) {
if (!allocator) {
return end;
}
@@ -576,7 +576,7 @@
// TODO(edisonn): optimize the allocation, don't allocate new string, but put it in a preallocated buffer
unsigned char* out = (unsigned char*)allocator->alloc(outLength);
start = readName(level, start, end, out);
- SkPdfObject::makeName(out, out + outLength, name);
+ SkPdfNativeObject::makeName(out, out + outLength, name);
TRACE_NAME(out, out + outLength);
return start;
}
@@ -605,7 +605,7 @@
// right now implement the silly algorithm that assumes endstream is finishing the stream
-static const unsigned char* readStream(int level, const unsigned char* start, const unsigned char* end, SkPdfObject* dict, SkNativeParsedPDF* doc) {
+static const unsigned char* readStream(int level, const unsigned char* start, const unsigned char* end, SkPdfNativeObject* dict, SkPdfNativeDoc* doc) {
TRACE_INDENT(level, "Stream");
start = skipPdfWhiteSpaces(level, start, end);
if (!(start[0] == 's' && start[1] == 't' && start[2] == 'r' && start[3] == 'e' && start[4] == 'a' && start[5] == 'm')) {
@@ -682,7 +682,7 @@
return start;
}
-static const unsigned char* readInlineImageStream(int level, const unsigned char* start, const unsigned char* end, SkPdfImageDictionary* inlineImage, SkNativeParsedPDF* doc) {
+static const unsigned char* readInlineImageStream(int level, const unsigned char* start, const unsigned char* end, SkPdfImageDictionary* inlineImage, SkPdfNativeDoc* doc) {
TRACE_INDENT(level, "Inline Image");
// We already processed ID keyword, and we should be positioned immediately after it
@@ -714,26 +714,26 @@
return endEI;
}
-static const unsigned char* readDictionary(int level, const unsigned char* start, const unsigned char* end, SkPdfObject* dict, SkPdfAllocator* allocator, SkNativeParsedPDF* doc) {
+static const unsigned char* readDictionary(int level, const unsigned char* start, const unsigned char* end, SkPdfNativeObject* dict, SkPdfAllocator* allocator, SkPdfNativeDoc* doc) {
if (allocator == NULL) {
// TODO(edisonn): report/warning error
return end;
}
TRACE_INDENT(level, "Dictionary");
- SkPdfObject::makeEmptyDictionary(dict);
+ SkPdfNativeObject::makeEmptyDictionary(dict);
start = skipPdfWhiteSpaces(level, start, end);
SkPdfAllocator tmpStorage; // keys will be stored in dict, we can free them immediately after set.
while (start < end && *start == kNamed_PdfDelimiter) {
- SkPdfObject key;
+ SkPdfNativeObject key;
//*start = '\0';
start++;
start = readName(level + 1, start, end, &key, &tmpStorage);
start = skipPdfWhiteSpaces(level + 1, start, end);
if (start < end) {
- SkPdfObject* value = allocator->allocObject();
+ SkPdfNativeObject* value = allocator->allocObject();
start = nextObject(level + 1, start, end, value, allocator, doc);
start = skipPdfWhiteSpaces(level + 1, start, end);
@@ -741,16 +741,16 @@
if (start < end) {
// seems we have an indirect reference
if (isPdfDigit(*start)) {
- SkPdfObject generation;
+ SkPdfNativeObject generation;
start = nextObject(level + 1, start, end, &generation, allocator, doc);
- SkPdfObject keywordR;
+ SkPdfNativeObject keywordR;
start = nextObject(level + 1, start, end, &keywordR, allocator, doc);
if (value->isInteger() && generation.isInteger() && keywordR.isKeywordReference()) {
int64_t id = value->intValue();
value->reset();
- SkPdfObject::makeReference((unsigned int)id, (unsigned int)generation.intValue(), value);
+ SkPdfNativeObject::makeReference((unsigned int)id, (unsigned int)generation.intValue(), value);
dict->set(&key, value);
} else {
// error, ignore
@@ -767,7 +767,7 @@
}
start = skipPdfWhiteSpaces(level + 1, start, end);
} else {
- dict->set(&key, &SkPdfObject::kNull);
+ dict->set(&key, &SkPdfNativeObject::kNull);
return end;
}
}
@@ -792,7 +792,7 @@
return start;
}
-const unsigned char* nextObject(int level, const unsigned char* start, const unsigned char* end, SkPdfObject* token, SkPdfAllocator* allocator, SkNativeParsedPDF* doc) {
+const unsigned char* nextObject(int level, const unsigned char* start, const unsigned char* end, SkPdfNativeObject* token, SkPdfAllocator* allocator, SkPdfNativeDoc* doc) {
const unsigned char* current;
// skip white spaces
@@ -812,7 +812,7 @@
switch (*start) {
case kOpenedSquareBracket_PdfDelimiter:
//*start = '\0';
- SkPdfObject::makeEmptyArray(token);
+ SkPdfNativeObject::makeEmptyArray(token);
return readArray(level + 1, current, end, token, allocator, doc);
case kOpenedRoundBracket_PdfDelimiter:
@@ -847,31 +847,31 @@
}
if (tokenLen == 4 && start[0] == 'n' && start[1] == 'u' && start[2] == 'l' && start[3] == 'l') {
- SkPdfObject::makeNull(token);
+ SkPdfNativeObject::makeNull(token);
return current;
}
if (tokenLen == 4 && start[0] == 't' && start[1] == 'r' && start[2] == 'u' && start[3] == 'e') {
- SkPdfObject::makeBoolean(true, token);
+ SkPdfNativeObject::makeBoolean(true, token);
return current;
}
if (tokenLen == 5 && start[0] == 'f' && start[1] == 'a' && start[2] == 'l' && start[3] == 's' && start[4] == 'e') {
- SkPdfObject::makeBoolean(false, token);
+ SkPdfNativeObject::makeBoolean(false, token);
return current;
}
if (isPdfNumeric(*start)) {
- SkPdfObject::makeNumeric(start, current, token);
+ SkPdfNativeObject::makeNumeric(start, current, token);
} else {
- SkPdfObject::makeKeyword(start, current, token);
+ SkPdfNativeObject::makeKeyword(start, current, token);
}
return current;
}
-SkPdfObject* SkPdfAllocator::allocBlock() {
- fSizeInBytes += BUFFER_SIZE * sizeof(SkPdfObject);
- return new SkPdfObject[BUFFER_SIZE];
+SkPdfNativeObject* SkPdfAllocator::allocBlock() {
+ fSizeInBytes += BUFFER_SIZE * sizeof(SkPdfNativeObject);
+ return new SkPdfNativeObject[BUFFER_SIZE];
}
SkPdfAllocator::~SkPdfAllocator() {
@@ -890,19 +890,19 @@
delete[] fCurrent;
}
-SkPdfObject* SkPdfAllocator::allocObject() {
+SkPdfNativeObject* SkPdfAllocator::allocObject() {
if (fCurrentUsed >= BUFFER_SIZE) {
fHistory.push(fCurrent);
fCurrent = allocBlock();
fCurrentUsed = 0;
- fSizeInBytes += sizeof(SkPdfObject*);
+ fSizeInBytes += sizeof(SkPdfNativeObject*);
}
fCurrentUsed++;
return &fCurrent[fCurrentUsed - 1];
}
// TODO(edisonn): perf: do no copy the buffers, but use them, and mark cache the result, so there is no need of a second pass
-SkPdfNativeTokenizer::SkPdfNativeTokenizer(SkPdfObject* objWithStream, const SkPdfMapper* mapper, SkPdfAllocator* allocator, SkNativeParsedPDF* doc) : fDoc(doc), fMapper(mapper), fAllocator(allocator), fUncompressedStream(NULL), fUncompressedStreamEnd(NULL), fEmpty(false), fHasPutBack(false) {
+SkPdfNativeTokenizer::SkPdfNativeTokenizer(SkPdfNativeObject* objWithStream, const SkPdfMapper* mapper, SkPdfAllocator* allocator, SkPdfNativeDoc* doc) : fDoc(doc), fMapper(mapper), fAllocator(allocator), fUncompressedStream(NULL), fUncompressedStreamEnd(NULL), fEmpty(false), fHasPutBack(false) {
const unsigned char* buffer = NULL;
size_t len = 0;
objWithStream->GetFilteredStreamRef(&buffer, &len);
@@ -915,7 +915,7 @@
fUncompressedStreamEnd = fUncompressedStream + len;
}
-SkPdfNativeTokenizer::SkPdfNativeTokenizer(const unsigned char* buffer, int len, const SkPdfMapper* mapper, SkPdfAllocator* allocator, SkNativeParsedPDF* doc) : fDoc(doc), fMapper(mapper), fAllocator(allocator), fEmpty(false), fHasPutBack(false) {
+SkPdfNativeTokenizer::SkPdfNativeTokenizer(const unsigned char* buffer, int len, const SkPdfMapper* mapper, SkPdfAllocator* allocator, SkPdfNativeDoc* doc) : fDoc(doc), fMapper(mapper), fAllocator(allocator), fEmpty(false), fHasPutBack(false) {
// TODO(edisonn): hack, find end of object
char* endobj = strrstrk((char*)buffer, (char*)buffer + len, "endobj");
if (endobj) {
@@ -929,7 +929,7 @@
}
bool SkPdfNativeTokenizer::readTokenCore(PdfToken* token) {
- SkPdfObject obj;
+ SkPdfNativeObject obj;
#ifdef PDF_TRACE_READ_TOKEN
static int read_op = 0;
#endif
@@ -944,12 +944,12 @@
fUncompressedStream = nextObject(0, fUncompressedStream, fUncompressedStreamEnd, &obj, fAllocator, fDoc);
// If it is a keyword, we will only get the pointer of the string
- if (obj.type() == SkPdfObject::kKeyword_PdfObjectType) {
+ if (obj.type() == SkPdfNativeObject::kKeyword_PdfObjectType) {
token->fKeyword = obj.c_str();
token->fKeywordLength = obj.lenstr();
token->fType = kKeyword_TokenType;
} else {
- SkPdfObject* pobj = fAllocator->allocObject();
+ SkPdfNativeObject* pobj = fAllocator->allocObject();
*pobj = obj;
token->fObject = pobj;
token->fType = kObject_TokenType;
@@ -1027,7 +1027,7 @@
#define HANDLE_NAME_ABBR(obj,longName,shortName) if (obj->isName(#shortName)) return &longName;
-static SkPdfObject* inlineImageKeyAbbreviationExpand(SkPdfObject* key) {
+static SkPdfNativeObject* inlineImageKeyAbbreviationExpand(SkPdfNativeObject* key) {
if (!key || !key->isName()) {
return key;
}
@@ -1047,7 +1047,7 @@
return key;
}
-static SkPdfObject* inlineImageValueAbbreviationExpand(SkPdfObject* value) {
+static SkPdfNativeObject* inlineImageValueAbbreviationExpand(SkPdfNativeObject* value) {
if (!value || !value->isName()) {
return value;
}
@@ -1076,17 +1076,17 @@
}
SkPdfImageDictionary* inlineImage = (SkPdfImageDictionary*)fAllocator->allocObject();
- SkPdfObject::makeEmptyDictionary(inlineImage);
+ SkPdfNativeObject::makeEmptyDictionary(inlineImage);
while (fUncompressedStream < fUncompressedStreamEnd) {
- SkPdfObject* key = fAllocator->allocObject();
+ SkPdfNativeObject* key = fAllocator->allocObject();
fUncompressedStream = nextObject(0, fUncompressedStream, fUncompressedStreamEnd, key, fAllocator, fDoc);
if (key->isKeyword() && key->lenstr() == 2 && key->c_str()[0] == 'I' && key->c_str()[1] == 'D') { // ID
fUncompressedStream = readInlineImageStream(0, fUncompressedStream, fUncompressedStreamEnd, inlineImage, fDoc);
return inlineImage;
} else {
- SkPdfObject* obj = fAllocator->allocObject();
+ SkPdfNativeObject* obj = fAllocator->allocObject();
fUncompressedStream = nextObject(0, fUncompressedStream, fUncompressedStreamEnd, obj, fAllocator, fDoc);
// TODO(edisonn): perf maybe we should not expand abreviation like this
inlineImage->set(inlineImageKeyAbbreviationExpand(key),
diff --git a/experimental/PdfViewer/pdfparser/native/SkPdfNativeTokenizer.h b/experimental/PdfViewer/pdfparser/native/SkPdfNativeTokenizer.h
index 134f7b3..a96a002 100644
--- a/experimental/PdfViewer/pdfparser/native/SkPdfNativeTokenizer.h
+++ b/experimental/PdfViewer/pdfparser/native/SkPdfNativeTokenizer.h
@@ -73,16 +73,16 @@
// this would allow us not to do any garbage collection while we parse or draw a pdf, and defere it
// while the user is looking at the image
-class SkPdfObject;
+class SkPdfNativeObject;
class SkPdfAllocator {
#define BUFFER_SIZE 1024
- SkTDArray<SkPdfObject*> fHistory;
+ SkTDArray<SkPdfNativeObject*> fHistory;
SkTDArray<void*> fHandles;
- SkPdfObject* fCurrent;
+ SkPdfNativeObject* fCurrent;
int fCurrentUsed;
- SkPdfObject* allocBlock();
+ SkPdfNativeObject* allocBlock();
size_t fSizeInBytes;
public:
@@ -94,7 +94,7 @@
~SkPdfAllocator();
- SkPdfObject* allocObject();
+ SkPdfNativeObject* allocObject();
// TODO(edisonn): free this memory in destructor, track the usage?
void* alloc(size_t bytes) {
@@ -109,8 +109,8 @@
}
};
-class SkNativeParsedPDF;
-const unsigned char* nextObject(int level, const unsigned char* start, const unsigned char* end, SkPdfObject* token, SkPdfAllocator* allocator, SkNativeParsedPDF* doc);
+class SkPdfNativeDoc;
+const unsigned char* nextObject(int level, const unsigned char* start, const unsigned char* end, SkPdfNativeObject* token, SkPdfAllocator* allocator, SkPdfNativeDoc* doc);
enum SkPdfTokenType {
kKeyword_TokenType,
@@ -120,7 +120,7 @@
struct PdfToken {
const char* fKeyword;
size_t fKeywordLength;
- SkPdfObject* fObject;
+ SkPdfNativeObject* fObject;
SkPdfTokenType fType;
PdfToken() : fKeyword(NULL), fKeywordLength(0), fObject(NULL) {}
@@ -128,8 +128,8 @@
class SkPdfNativeTokenizer {
public:
- SkPdfNativeTokenizer(SkPdfObject* objWithStream, const SkPdfMapper* mapper, SkPdfAllocator* allocator, SkNativeParsedPDF* doc);
- SkPdfNativeTokenizer(const unsigned char* buffer, int len, const SkPdfMapper* mapper, SkPdfAllocator* allocator, SkNativeParsedPDF* doc);
+ SkPdfNativeTokenizer(SkPdfNativeObject* objWithStream, const SkPdfMapper* mapper, SkPdfAllocator* allocator, SkPdfNativeDoc* doc);
+ SkPdfNativeTokenizer(const unsigned char* buffer, int len, const SkPdfMapper* mapper, SkPdfAllocator* allocator, SkPdfNativeDoc* doc);
virtual ~SkPdfNativeTokenizer();
@@ -139,7 +139,7 @@
SkPdfImageDictionary* readInlineImage();
private:
- SkNativeParsedPDF* fDoc;
+ SkPdfNativeDoc* fDoc;
const SkPdfMapper* fMapper;
SkPdfAllocator* fAllocator;