refactoring for pdf viewer lib
Review URL: https://codereview.chromium.org/17856004
git-svn-id: http://skia.googlecode.com/svn/trunk@9773 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/experimental/PdfViewer/SkPdfBasics.h b/experimental/PdfViewer/SkPdfBasics.h
index 126e63d..27e21f1 100644
--- a/experimental/PdfViewer/SkPdfBasics.h
+++ b/experimental/PdfViewer/SkPdfBasics.h
@@ -4,6 +4,9 @@
#include "podofo.h"
using namespace PoDoFo;
+#include "SkCanvas.h"
+#include "SkPaint.h"
+
#include <iostream>
#include <cstdio>
#include <stack>
@@ -16,6 +19,8 @@
class SkPdfFont;
class SkPdfDoc;
+class SkPdfObject;
+class SkPdfResourceDictionary;
// TODO(edisonn): better class design.
struct PdfColorOperator {
diff --git a/experimental/PdfViewer/SkPdfFont.cpp b/experimental/PdfViewer/SkPdfFont.cpp
index a4d70ab..4fac286 100644
--- a/experimental/PdfViewer/SkPdfFont.cpp
+++ b/experimental/PdfViewer/SkPdfFont.cpp
@@ -1,4 +1,5 @@
#include "SkPdfFont.h"
+#include "SkPdfParser.h"
std::map<std::string, SkPdfStandardFontEntry>& getStandardFonts() {
static std::map<std::string, SkPdfStandardFontEntry> gPdfStandardFonts;
diff --git a/experimental/PdfViewer/SkPdfFont.h b/experimental/PdfViewer/SkPdfFont.h
index a3f0d36..85b9fc4 100644
--- a/experimental/PdfViewer/SkPdfFont.h
+++ b/experimental/PdfViewer/SkPdfFont.h
@@ -7,6 +7,7 @@
#include <map>
#include <string>
+#include "SkTypeface.h"
#include "SkUtils.h"
#include "SkPdfBasics.h"
#include "SkPdfUtils.h"
diff --git a/experimental/PdfViewer/SkPdfParser.cpp b/experimental/PdfViewer/SkPdfParser.cpp
new file mode 100644
index 0000000..6d5ccae
--- /dev/null
+++ b/experimental/PdfViewer/SkPdfParser.cpp
@@ -0,0 +1,2352 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkForceLinking.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkImageEncoder.h"
+#include "SkOSFile.h"
+#include "SkPicture.h"
+#include "SkStream.h"
+#include "SkTypeface.h"
+#include "SkTArray.h"
+#include "picture_utils.h"
+
+#include <iostream>
+#include <cstdio>
+#include <stack>
+
+#include "podofo.h"
+using namespace PoDoFo;
+
+
+__SK_FORCE_IMAGE_DECODER_LINKING;
+
+// TODO(edisonn): tool, show what objects were read at least, show the ones not even read
+// keep for each object pos in file
+// plug in for VS? syntax coloring, show selected object ... from the text, or from rendered x,y
+
+// TODO(edisonn): security - validate all the user input, all pdf!
+
+
+#include "SkPdfHeaders_autogen.h"
+#include "SkPdfPodofoMapper_autogen.h"
+#include "SkPdfParser.h"
+
+#include "SkPdfBasics.h"
+#include "SkPdfUtils.h"
+
+#include "SkPdfFont.h"
+
+bool skpdfmap(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out) {
+ return mapObject(podofoDoc, podofoObj, out);
+}
+
+
+/*
+ * TODO(edisonn):
+ * - all font types and all ppdf font features
+ * - word spacing
+ * - load font for baidu.pdf
+ * - load font for youtube.pdf
+ * - parser for pdf from the definition already available in pdfspec_autogen.py
+ * - all docs from ~/work
+ * - encapsulate podofo in the pdf api so the skpdf does not know anything about podofo ... in progress
+ * - load gs/ especially smask and already known prop (skp) ... in progress
+ * - wrapper on classes for customizations? e.g.
+ * SkPdfPageObjectVanila - has only the basic loaders/getters
+ * SkPdfPageObject : public SkPdfPageObjectVanila, extends, and I can add customizations here
+ * need to find a nice object model for all this with constructors and factories
+ * - deal with inheritable automatically ?
+ * - deal with specific type in spec directly, add all dictionary types to known types
+*/
+
+using namespace std;
+using namespace PoDoFo;
+
+// Utilities
+static void setup_bitmap(SkBitmap* bitmap, int width, int height, SkColor color = SK_ColorWHITE) {
+ bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height);
+
+ bitmap->allocPixels();
+ bitmap->eraseColor(color);
+}
+
+// TODO(edisonn): synonyms? DeviceRGB and RGB ...
+int GetColorSpaceComponents(const std::string& colorSpace) {
+ if (colorSpace == "DeviceCMYK") {
+ return 4;
+ } else if (colorSpace == "DeviceGray" ||
+ colorSpace == "CalGray" ||
+ colorSpace == "Indexed") {
+ return 1;
+ } else if (colorSpace == "DeviceRGB" ||
+ colorSpace == "CalRGB" ||
+ colorSpace == "Lab") {
+ return 3;
+ } else {
+ return 0;
+ }
+}
+
+const PdfObject* resolveReferenceObject(const PdfMemDocument* pdfDoc,
+ const PdfObject* obj,
+ bool resolveOneElementArrays) {
+ while (obj && (obj->IsReference() || (resolveOneElementArrays &&
+ obj->IsArray() &&
+ obj->GetArray().GetSize() == 1))) {
+ if (obj->IsReference()) {
+ // We need to force the non const, the only update we will do is for recurssion checks.
+ PdfReference& ref = (PdfReference&)obj->GetReference();
+ obj = pdfDoc->GetObjects().GetObject(ref);
+ } else {
+ obj = &obj->GetArray()[0];
+ }
+ }
+
+ return obj;
+}
+
+static SkMatrix SkMatrixFromPdfMatrix(double array[6]) {
+ SkMatrix matrix;
+ matrix.setAll(SkDoubleToScalar(array[0]),
+ SkDoubleToScalar(array[2]),
+ SkDoubleToScalar(array[4]),
+ SkDoubleToScalar(array[1]),
+ SkDoubleToScalar(array[3]),
+ SkDoubleToScalar(array[5]),
+ SkDoubleToScalar(0),
+ SkDoubleToScalar(0),
+ SkDoubleToScalar(1));
+
+ return matrix;
+}
+
+SkMatrix SkMatrixFromPdfArray(SkPdfArray* pdfArray) {
+ double array[6];
+
+ // TODO(edisonn): security issue, ret if size() != 6
+ for (int i = 0; i < 6; i++) {
+ const PdfObject* elem = resolveReferenceObject(pdfArray->doc(), (*pdfArray)[i]->podofo());
+ if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
+ return SkMatrix::I(); // TODO(edisonn): report issue
+ }
+ array[i] = elem->GetReal();
+ }
+
+ return SkMatrixFromPdfMatrix(array);
+}
+
+PdfContext* gPdfContext = NULL;
+SkBitmap* gDumpBitmap = NULL;
+SkCanvas* gDumpCanvas = NULL;
+char gLastKeyword[100] = "";
+int gLastOpKeyword = -1;
+char allOpWithVisualEffects[100] = ",S,s,f,F,f*,B,B*,b,b*,n,Tj,TJ,\',\",d0,d1,sh,EI,Do,EX,";
+int gReadOp = 0;
+
+
+
+bool hasVisualEffect(const char* pdfOp) {
+ return true;
+ if (*pdfOp == '\0') return false;
+
+ char markedPdfOp[100] = ",";
+ strcat(markedPdfOp, pdfOp);
+ strcat(markedPdfOp, ",");
+
+ return (strstr(allOpWithVisualEffects, markedPdfOp) != NULL);
+}
+
+// TODO(edisonn): Pass PdfContext and SkCanvasd only with the define for instrumentation.
+static bool readToken(SkPdfTokenizer* fTokenizer, PdfToken* token) {
+ bool ret = fTokenizer->readToken(token);
+
+ gReadOp++;
+
+#ifdef PDF_TRACE_DIFF_IN_PNG
+ // TODO(edisonn): compare with old bitmap, and save only new bits are available, and save
+ // the numbar and name of last operation, so the file name will reflect op that changed.
+ if (hasVisualEffect(gLastKeyword)) { // TODO(edisonn): and has dirty bits.
+ gDumpCanvas->flush();
+
+ SkBitmap bitmap;
+ setup_bitmap(&bitmap, gDumpBitmap->width(), gDumpBitmap->height());
+
+ memcpy(bitmap.getPixels(), gDumpBitmap->getPixels(), gDumpBitmap->getSize());
+
+ SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
+ SkCanvas canvas(device);
+
+ // draw context stuff here
+ SkPaint blueBorder;
+ blueBorder.setColor(SK_ColorBLUE);
+ blueBorder.setStyle(SkPaint::kStroke_Style);
+ blueBorder.setTextSize(SkDoubleToScalar(20));
+
+ SkString str;
+
+ const SkClipStack* clipStack = gDumpCanvas->getClipStack();
+ if (clipStack) {
+ SkClipStack::Iter iter(*clipStack, SkClipStack::Iter::kBottom_IterStart);
+ const SkClipStack::Element* elem;
+ double y = 0;
+ int total = 0;
+ while (elem = iter.next()) {
+ total++;
+ y += 30;
+
+ switch (elem->getType()) {
+ case SkClipStack::Element::kRect_Type:
+ canvas.drawRect(elem->getRect(), blueBorder);
+ canvas.drawText("Rect Clip", strlen("Rect Clip"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
+ break;
+ case SkClipStack::Element::kPath_Type:
+ canvas.drawPath(elem->getPath(), blueBorder);
+ canvas.drawText("Path Clip", strlen("Path Clip"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
+ break;
+ case SkClipStack::Element::kEmpty_Type:
+ canvas.drawText("Empty Clip!!!", strlen("Empty Clip!!!"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
+ break;
+ default:
+ canvas.drawText("Unkown Clip!!!", strlen("Unkown Clip!!!"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
+ break;
+ }
+ }
+
+ y += 30;
+ str.printf("Number of clips in stack: %i", total);
+ canvas.drawText(str.c_str(), str.size(), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
+ }
+
+ const SkRegion& clipRegion = gDumpCanvas->getTotalClip();
+ SkPath clipPath;
+ if (clipRegion.getBoundaryPath(&clipPath)) {
+ SkPaint redBorder;
+ redBorder.setColor(SK_ColorRED);
+ redBorder.setStyle(SkPaint::kStroke_Style);
+ canvas.drawPath(clipPath, redBorder);
+ }
+
+ canvas.flush();
+
+ SkString out;
+
+ // TODO(edisonn): get the image, and overlay on top of it, the clip , grafic state, teh stack,
+ // ... and other properties, to be able to debug th code easily
+
+ out.appendf("/usr/local/google/home/edisonn/log_view2/step-%i-%s.png", gLastOpKeyword, gLastKeyword);
+ SkImageEncoder::EncodeFile(out.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100);
+ }
+
+ if (token->fType == kKeyword_TokenType) {
+ strcpy(gLastKeyword, token->fKeyword);
+ gLastOpKeyword = gReadOp;
+ } else {
+ strcpy(gLastKeyword, "");
+ }
+#endif
+
+ return ret;
+}
+
+
+
+typedef PdfResult (*PdfOperatorRenderer)(PdfContext*, SkCanvas*, PdfTokenLooper**);
+
+map<std::string, PdfOperatorRenderer> gPdfOps;
+
+map<std::string, int> gRenderStats[kCount_PdfResult];
+
+char* gRenderStatsNames[kCount_PdfResult] = {
+ "Success",
+ "Partially implemented",
+ "Not yet implemented",
+ "Ignore Error",
+ "Error",
+ "Unsupported/Unknown"
+};
+
+static SkTypeface* SkTypefaceFromPdfFont(PdfFont* font) {
+ if (font == NULL) {
+ return SkTypeface::CreateFromName("Times New Roman", SkTypeface::kNormal);
+ }
+
+ PdfObject* fontObject = font->GetObject();
+
+ PdfObject* pBaseFont = NULL;
+ // TODO(edisonn): warning, PoDoFo has a bug in PdfFont constructor, does not call InitVars()
+ // for now fixed locally.
+ pBaseFont = fontObject->GetIndirectKey( "BaseFont" );
+ const char* pszBaseFontName = pBaseFont->GetName().GetName().c_str();
+
+#ifdef PDF_TRACE
+ std::string str;
+ fontObject->ToString(str);
+ printf("Base Font Name: %s\n", pszBaseFontName);
+ printf("Font Object Data: %s\n", str.c_str());
+#endif
+
+ SkTypeface* typeface = SkTypefaceFromPdfStandardFont(pszBaseFontName, font->IsBold(), font->IsItalic());
+
+ if (typeface != NULL) {
+ return typeface;
+ }
+
+ char name[1000];
+ // HACK
+ strncpy(name, pszBaseFontName, 1000);
+ char* comma = strstr(name, ",");
+ char* dash = strstr(name, "-");
+ if (comma) *comma = '\0';
+ if (dash) *dash = '\0';
+
+ typeface = SkTypeface::CreateFromName(
+ name,
+ SkTypeface::Style((font->IsBold() ? SkTypeface::kBold : 0) |
+ (font->IsItalic() ? SkTypeface::kItalic : 0)));
+
+ if (typeface != NULL) {
+#ifdef PDF_TRACE
+ printf("HACKED FONT found %s\n", name);
+#endif
+ return typeface;
+ }
+
+#ifdef PDF_TRACE
+ printf("FONT_NOT_FOUND %s\n", pszBaseFontName);
+#endif
+
+ // TODO(edisonn): Report Warning, NYI
+ return SkTypeface::CreateFromName(
+ "Times New Roman",
+ SkTypeface::Style((font->IsBold() ? SkTypeface::kBold : 0) |
+ (font->IsItalic() ? SkTypeface::kItalic : 0)));
+}
+
+PdfResult DrawText(PdfContext* pdfContext,
+ const SkPdfObject* str,
+ SkCanvas* canvas)
+{
+
+ SkPdfFont* skfont = pdfContext->fGraphicsState.fSkFont;
+ if (skfont == NULL) {
+ skfont = SkPdfFont::Default();
+ }
+
+ SkUnencodedText binary(str);
+
+ SkDecodedText decoded;
+
+ if (skfont->encoding() == NULL) {
+ // TODO(edisonn): report warning
+ return kNYI_PdfResult;
+ }
+
+ skfont->encoding()->decodeText(binary, &decoded);
+
+ SkPaint paint;
+ // TODO(edisonn): when should fCurFont->GetFontSize() used? When cur is fCurFontSize == 0?
+ // Or maybe just not call setTextSize at all?
+ if (pdfContext->fGraphicsState.fCurFontSize != 0) {
+ paint.setTextSize(SkDoubleToScalar(pdfContext->fGraphicsState.fCurFontSize));
+ }
+
+// if (fCurFont && fCurFont->GetFontScale() != 0) {
+// paint.setTextScaleX(SkFloatToScalar(fCurFont->GetFontScale() / 100.0));
+// }
+
+ pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
+
+ canvas->save();
+
+#if 1
+ SkMatrix matrix = pdfContext->fGraphicsState.fMatrixTm;
+
+ SkPoint point1;
+ pdfContext->fGraphicsState.fMatrixTm.mapXY(SkIntToScalar(0), SkIntToScalar(0), &point1);
+
+ SkMatrix mirror;
+ mirror.setTranslate(0, -point1.y());
+ // TODO(edisonn): fix rotated text, and skewed too
+ mirror.postScale(SK_Scalar1, -SK_Scalar1);
+ // TODO(edisonn): post rotate, skew
+ mirror.postTranslate(0, point1.y());
+
+ matrix.postConcat(mirror);
+
+ canvas->setMatrix(matrix);
+
+ SkTraceMatrix(matrix, "mirrored");
+#endif
+
+ skfont->drawText(decoded, &paint, pdfContext, canvas, &pdfContext->fGraphicsState.fMatrixTm);
+ canvas->restore();
+
+ return kPartial_PdfResult;
+}
+
+// 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);
+
+// TODO(edisonn): deal with synonyms (/BPC == /BitsPerComponent), here or in GetKey?
+// Always pass long form in key, and have a map of long -> short key
+bool LongFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ long* data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc,
+ dict.GetKey(PdfName(key)));
+
+ if (value == NULL || !value->IsNumber()) {
+ return false;
+ }
+ if (data == NULL) {
+ return true;
+ }
+
+ *data = value->GetNumber();
+ return true;
+}
+
+bool LongFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ long* data) {
+ if (LongFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return LongFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ double* data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc,
+ dict.GetKey(PdfName(key)));
+
+ if (value == NULL || (!value->IsReal() && !value->IsNumber())) {
+ return false;
+ }
+ if (data == NULL) {
+ return true;
+ }
+
+ *data = value->GetReal();
+ return true;
+}
+
+bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ double* data) {
+ if (DoubleFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return DoubleFromDictionary(pdfDoc, dict, abr, data);
+}
+
+
+bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ bool* data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc,
+ dict.GetKey(PdfName(key)));
+
+ if (value == NULL || !value->IsBool()) {
+ return false;
+ }
+ if (data == NULL) {
+ return true;
+ }
+
+ *data = value->GetBool();
+ return true;
+}
+
+bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ bool* data) {
+ if (BoolFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return BoolFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool NameFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ std::string* data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc,
+ dict.GetKey(PdfName(key)),
+ true);
+ if (value == NULL || !value->IsName()) {
+ return false;
+ }
+ if (data == NULL) {
+ return true;
+ }
+
+ *data = value->GetName().GetName();
+ return true;
+}
+
+bool NameFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ std::string* data) {
+ if (NameFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return NameFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool StringFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ std::string* data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc,
+ dict.GetKey(PdfName(key)),
+ true);
+ if (value == NULL || (!value->IsString() && !value->IsHexString())) {
+ return false;
+ }
+ if (data == NULL) {
+ return true;
+ }
+
+ *data = value->GetString().GetString();
+ return true;
+}
+
+bool StringFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ std::string* data) {
+ if (StringFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return StringFromDictionary(pdfDoc, dict, abr, data);
+}
+
+/*
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ SkPdfArray** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc,
+ dict.GetKey(PdfName(key)),
+ true);
+ if (value == NULL || !value->IsArray()) {
+ return false;
+ }
+ if (data == NULL) {
+ return true;
+ }
+
+ return mapArray(*pdfDoc, *value, data);
+}
+
+
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ SkPdfArray** data) {
+ if (ArrayFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ArrayFromDictionary(pdfDoc, dict, abr, data);
+}
+
+
+bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ SkPdfDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc,
+ dict.GetKey(PdfName(key)),
+ true);
+ if (value == NULL || !value->IsDictionary()) {
+ return false;
+ }
+ if (data == NULL) {
+ return true;
+ }
+
+ return mapDictionary(*pdfDoc, *value, data);
+}
+
+bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ SkPdfDictionary** data) {
+ if (DictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return DictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+
+bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ SkPdfObject** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc,
+ dict.GetKey(PdfName(key)),
+ true);
+ if (value == NULL) {
+ return false;
+ }
+ if (data == NULL) {
+ return true;
+ }
+ return mapObject(*pdfDoc, *value, data);
+}
+
+bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ SkPdfObject** data) {
+ if (ObjectFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ObjectFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ SkPdfStream** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc,
+ dict.GetKey(PdfName(key)),
+ true);
+ if (value == NULL) {
+ return false;
+ }
+ if (data == NULL) {
+ return true;
+ }
+ return mapStream(*pdfDoc, *value, data);
+}
+
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ SkPdfStream** data) {
+ if (StreamFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return StreamFromDictionary(pdfDoc, dict, abr, data);
+}
+*/
+
+// TODO(edisonn): perf!!!
+
+static SkColorTable* getGrayColortable() {
+ static SkColorTable* grayColortable = NULL;
+ if (grayColortable == NULL) {
+ SkPMColor* colors = new SkPMColor[256];
+ for (int i = 0 ; i < 256; i++) {
+ colors[i] = SkPreMultiplyARGB(255, i, i, i);
+ }
+ grayColortable = new SkColorTable(colors, 256);
+ }
+ return grayColortable;
+}
+
+SkBitmap transferImageStreamToBitmap(unsigned char* uncompressedStream, pdf_long uncompressedStreamLength,
+ int width, int height, int bytesPerLine,
+ int bpc, const std::string& colorSpace,
+ bool transparencyMask) {
+ SkBitmap bitmap;
+
+ int components = GetColorSpaceComponents(colorSpace);
+//#define MAX_COMPONENTS 10
+
+ int bitsPerLine = width * components * bpc;
+ // TODO(edisonn): assume start of lines are aligned at 32 bits?
+ // Is there a faster way to load the uncompressed stream into a bitmap?
+
+ // minimal support for now
+ if ((colorSpace == "DeviceRGB" || colorSpace == "RGB") && bpc == 8) {
+ SkColor* uncompressedStreamArgb = (SkColor*)malloc(width * height * sizeof(SkColor));
+
+ for (int h = 0 ; h < height; h++) {
+ long i = width * (height - 1 - h);
+ for (int w = 0 ; w < width; w++) {
+ uncompressedStreamArgb[i] = SkColorSetRGB(uncompressedStream[3 * w],
+ uncompressedStream[3 * w + 1],
+ uncompressedStream[3 * w + 2]);
+ i++;
+ }
+ uncompressedStream += bytesPerLine;
+ }
+
+ bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
+ bitmap.setPixels(uncompressedStreamArgb);
+ }
+ else if ((colorSpace == "DeviceGray" || colorSpace == "Gray") && bpc == 8) {
+ unsigned char* uncompressedStreamA8 = (unsigned char*)malloc(width * height);
+
+ for (int h = 0 ; h < height; h++) {
+ long i = width * (height - 1 - h);
+ for (int w = 0 ; w < width; w++) {
+ uncompressedStreamA8[i] = transparencyMask ? 255 - uncompressedStream[w] :
+ uncompressedStream[w];
+ i++;
+ }
+ uncompressedStream += bytesPerLine;
+ }
+
+ bitmap.setConfig(transparencyMask ? SkBitmap::kA8_Config : SkBitmap::kIndex8_Config,
+ width, height);
+ bitmap.setPixels(uncompressedStreamA8, transparencyMask ? NULL : getGrayColortable());
+ }
+
+ // TODO(edisonn): Report Warning, NYI, or error
+ return bitmap;
+}
+
+bool transferImageStreamToARGB(unsigned char* uncompressedStream, pdf_long uncompressedStreamLength,
+ int width, int bytesPerLine,
+ int bpc, const std::string& colorSpace,
+ SkColor** uncompressedStreamArgb,
+ pdf_long* uncompressedStreamLengthInBytesArgb) {
+ int components = GetColorSpaceComponents(colorSpace);
+//#define MAX_COMPONENTS 10
+
+ int bitsPerLine = width * components * bpc;
+ // TODO(edisonn): assume start of lines are aligned at 32 bits?
+ int height = uncompressedStreamLength / bytesPerLine;
+
+ // minimal support for now
+ if ((colorSpace == "DeviceRGB" || colorSpace == "RGB") && bpc == 8) {
+ *uncompressedStreamLengthInBytesArgb = width * height * 4;
+ *uncompressedStreamArgb = (SkColor*)malloc(*uncompressedStreamLengthInBytesArgb);
+
+ for (int h = 0 ; h < height; h++) {
+ long i = width * (height - 1 - h);
+ for (int w = 0 ; w < width; w++) {
+ (*uncompressedStreamArgb)[i] = SkColorSetRGB(uncompressedStream[3 * w],
+ uncompressedStream[3 * w + 1],
+ uncompressedStream[3 * w + 2]);
+ i++;
+ }
+ uncompressedStream += bytesPerLine;
+ }
+ return true;
+ }
+
+ if ((colorSpace == "DeviceGray" || colorSpace == "Gray") && bpc == 8) {
+ *uncompressedStreamLengthInBytesArgb = width * height * 4;
+ *uncompressedStreamArgb = (SkColor*)malloc(*uncompressedStreamLengthInBytesArgb);
+
+ for (int h = 0 ; h < height; h++) {
+ long i = width * (height - 1 - h);
+ for (int w = 0 ; w < width; w++) {
+ (*uncompressedStreamArgb)[i] = SkColorSetRGB(uncompressedStream[w],
+ uncompressedStream[w],
+ uncompressedStream[w]);
+ i++;
+ }
+ uncompressedStream += bytesPerLine;
+ }
+ return true;
+ }
+
+ return false;
+}
+
+// utils
+
+// TODO(edisonn): add cache, or put the bitmap property directly on the PdfObject
+// TODO(edisonn): deal with colorSpaces, we could add them to SkBitmap::Config
+// TODO(edisonn): preserve A1 format that skia knows, + fast convert from 111, 222, 444 to closest
+// skia format, through a table
+
+// this functions returns the image, it does not look at the smask.
+
+SkBitmap getImageFromObject(PdfContext* pdfContext, const SkPdfImageDictionary* image, bool transparencyMask) {
+ if (image == NULL || !image->valid()) {
+ // TODO(edisonn): report warning to be used in testing.
+ return SkBitmap();
+ }
+
+ // TODO (edisonn): Fast Jpeg(DCTDecode) draw, or fast PNG(FlateDecode) draw ...
+// PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
+// obj.GetDictionary().GetKey(PdfName("Filter")));
+// if (value && value->IsArray() && value->GetArray().GetSize() == 1) {
+// value = resolveReferenceObject(pdfContext->fPdfDoc,
+// &value->GetArray()[0]);
+// }
+// if (value && value->IsName() && value->GetName().GetName() == "DCTDecode") {
+// SkStream stream = SkStream::
+// SkImageDecoder::Factory()
+// }
+
+ long bpc = image->BitsPerComponent();
+ long width = image->Width();
+ long height = image->Height();
+ std::string colorSpace = "DeviceRGB";
+
+ // TODO(edisonn): color space can be an array too!
+ if (image->isColorSpaceAName()) {
+ colorSpace = image->getColorSpaceAsName();
+ }
+
+/*
+ bool imageMask = image->imageMask();
+
+ if (imageMask) {
+ if (bpc != 0 && bpc != 1) {
+ // TODO(edisonn): report warning to be used in testing.
+ return SkBitmap();
+ }
+ bpc = 1;
+ }
+*/
+
+ const PdfObject* obj = image->podofo();
+
+ char* uncompressedStream = NULL;
+ pdf_long uncompressedStreamLength = 0;
+
+ PdfResult ret = kPartial_PdfResult;
+ // TODO(edisonn): get rid of try/catch exceptions! We should not throw on user data!
+ try {
+ obj->GetStream()->GetFilteredCopy(&uncompressedStream, &uncompressedStreamLength);
+ } catch (PdfError& e) {
+ // TODO(edisonn): report warning to be used in testing.
+ return SkBitmap();
+ }
+
+ int bytesPerLine = uncompressedStreamLength / height;
+#ifdef PDF_TRACE
+ if (uncompressedStreamLength % height != 0) {
+ printf("Warning uncompressedStreamLength % height != 0 !!!\n");
+ }
+#endif
+
+ SkBitmap bitmap = transferImageStreamToBitmap(
+ (unsigned char*)uncompressedStream, uncompressedStreamLength,
+ width, height, bytesPerLine,
+ bpc, colorSpace,
+ transparencyMask);
+
+ free(uncompressedStream);
+
+ return bitmap;
+}
+
+SkBitmap getSmaskFromObject(PdfContext* pdfContext, const SkPdfImageDictionary* obj) {
+ const PdfObject* sMask = resolveReferenceObject(&pdfContext->fPdfDoc->podofo(),
+ obj->podofo()->GetDictionary().GetKey(PdfName("SMask")));
+
+#ifdef PDF_TRACE
+ std::string str;
+ if (sMask) {
+ sMask->ToString(str);
+ printf("/SMask of /Subtype /Image: %s\n", str.c_str());
+ }
+#endif
+
+ if (sMask) {
+ SkPdfImageDictionary skxobjmask(&pdfContext->fPdfDoc->podofo(), sMask);
+ return getImageFromObject(pdfContext, &skxobjmask, true);
+ }
+
+ // TODO(edisonn): implement GS SMask. Default to empty right now.
+ return pdfContext->fGraphicsState.fSMask;
+}
+
+PdfResult doXObject_Image(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfImageDictionary* skpdfimage) {
+ if (skpdfimage == NULL || !skpdfimage->valid()) {
+ return kIgnoreError_PdfResult;
+ }
+
+ SkBitmap image = getImageFromObject(pdfContext, skpdfimage, false);
+ SkBitmap sMask = getSmaskFromObject(pdfContext, skpdfimage);
+
+ canvas->save();
+ canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
+ SkRect dst = SkRect::MakeXYWH(SkDoubleToScalar(0.0), SkDoubleToScalar(0.0), SkDoubleToScalar(1.0), SkDoubleToScalar(1.0));
+
+ if (sMask.empty()) {
+ canvas->drawBitmapRect(image, dst, NULL);
+ } else {
+ canvas->saveLayer(&dst, NULL);
+ canvas->drawBitmapRect(image, dst, NULL);
+ SkPaint xfer;
+ pdfContext->fGraphicsState.applyGraphicsState(&xfer, false);
+ xfer.setXfermodeMode(SkXfermode::kSrcOut_Mode); // SkXfermode::kSdtOut_Mode
+ canvas->drawBitmapRect(sMask, dst, &xfer);
+ canvas->restore();
+ }
+
+ canvas->restore();
+
+ return kPartial_PdfResult;
+}
+
+bool SkMatrixFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ SkMatrix** matrix) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc,
+ dict.GetKey(PdfName(key)));
+
+ if (value == NULL || !value->IsArray()) {
+ return false;
+ }
+
+ if (value->GetArray().GetSize() != 6) {
+ return false;
+ }
+
+ double array[6];
+ for (int i = 0; i < 6; i++) {
+ const PdfObject* elem = resolveReferenceObject(pdfDoc, &value->GetArray()[i]);
+ if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
+ return false;
+ }
+ array[i] = elem->GetReal();
+ }
+
+ *matrix = new SkMatrix();
+ **matrix = SkMatrixFromPdfMatrix(array);
+ return true;
+}
+
+bool SkMatrixFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ SkMatrix** data) {
+ if (SkMatrixFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return SkMatrixFromDictionary(pdfDoc, dict, abr, data);
+
+}
+
+bool SkRectFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ SkRect** rect) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc,
+ dict.GetKey(PdfName(key)));
+
+ if (value == NULL || !value->IsArray()) {
+ return false;
+ }
+
+ if (value->GetArray().GetSize() != 4) {
+ return false;
+ }
+
+ double array[4];
+ for (int i = 0; i < 4; i++) {
+ const PdfObject* elem = resolveReferenceObject(pdfDoc, &value->GetArray()[i]);
+ if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
+ return false;
+ }
+ array[i] = elem->GetReal();
+ }
+
+ *rect = new SkRect();
+ **rect = SkRect::MakeLTRB(SkDoubleToScalar(array[0]),
+ SkDoubleToScalar(array[1]),
+ SkDoubleToScalar(array[2]),
+ SkDoubleToScalar(array[3]));
+ return true;
+}
+
+bool SkRectFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ SkRect** data) {
+ if (SkRectFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return SkRectFromDictionary(pdfDoc, dict, abr, data);
+
+}
+
+
+SkPdfObject* get(const SkPdfObject* obj, const char* key, const char* abr = "") {
+ SkPdfObject* ret = NULL;
+ if (obj == NULL) return NULL;
+ const SkPdfDictionary* dict = obj->asDictionary();
+ if (dict == NULL) return NULL;
+ if (!dict->podofo()->IsDictionary()) return NULL;
+ ObjectFromDictionary(dict->doc(), dict->podofo()->GetDictionary(), key, abr, &ret);
+ return ret;
+}
+
+PdfResult doXObject_Form(PdfContext* pdfContext, SkCanvas* canvas, SkPdfType1FormDictionary* skobj) {
+ if (!skobj || !skobj->podofo() || !skobj->podofo()->HasStream() || skobj->podofo()->GetStream() == NULL || skobj->podofo()->GetStream()->GetLength() == 0) {
+ return kOK_PdfResult;
+ }
+
+ PdfOp_q(pdfContext, canvas, NULL);
+ canvas->save();
+
+
+ if (skobj->Resources()) {
+ pdfContext->fGraphicsState.fResources = skobj->Resources();
+ }
+
+ SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Current matrix");
+
+ if (skobj->Matrix()) {
+ pdfContext->fGraphicsState.fMatrix.preConcat(*skobj->Matrix());
+ pdfContext->fGraphicsState.fMatrixTm = pdfContext->fGraphicsState.fMatrix;
+ pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix;
+ // TODO(edisonn) reset matrixTm and matricTlm also?
+ }
+
+ SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Total matrix");
+
+ canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
+
+ if (skobj->BBox()) {
+ canvas->clipRect(*skobj->BBox(), SkRegion::kIntersect_Op, true); // TODO(edisonn): AA from settings.
+ }
+
+ // TODO(edisonn): iterate smart on the stream even if it is compressed, tokenize it as we go.
+ // For this PdfContentsTokenizer needs to be extended.
+
+ PdfResult ret = kPartial_PdfResult;
+ SkPdfTokenizer tokenizer(skobj);
+ PdfMainLooper looper(NULL, &tokenizer, pdfContext, canvas);
+ looper.loop();
+
+ // TODO(edisonn): should we restore the variable stack at the same state?
+ // There could be operands left, that could be consumed by a parent tokenizer when we pop.
+ canvas->restore();
+ PdfOp_Q(pdfContext, canvas, NULL);
+ return ret;
+}
+
+PdfResult doXObject_PS(PdfContext* pdfContext, SkCanvas* canvas, const PdfObject& obj) {
+ return kNYI_PdfResult;
+}
+
+PdfResult doType3Char(PdfContext* pdfContext, SkCanvas* canvas, SkPdfObject* skobj, SkRect bBox, SkMatrix matrix, double textSize) {
+ if (!skobj || !skobj->podofo() || !skobj->podofo()->HasStream() || skobj->podofo()->GetStream() == NULL || skobj->podofo()->GetStream()->GetLength() == 0) {
+ return kOK_PdfResult;
+ }
+
+ PdfOp_q(pdfContext, canvas, NULL);
+ canvas->save();
+
+ pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
+ pdfContext->fGraphicsState.fMatrixTm.preScale(SkDoubleToScalar(textSize), SkDoubleToScalar(textSize));
+
+ pdfContext->fGraphicsState.fMatrix = pdfContext->fGraphicsState.fMatrixTm;
+ pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix;
+
+ SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Total matrix");
+
+ canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
+
+ SkRect rm = bBox;
+ pdfContext->fGraphicsState.fMatrix.mapRect(&rm);
+
+ SkTraceRect(rm, "bbox mapped");
+
+ canvas->clipRect(bBox, SkRegion::kIntersect_Op, true); // TODO(edisonn): AA from settings.
+
+ // TODO(edisonn): iterate smart on the stream even if it is compressed, tokenize it as we go.
+ // For this PdfContentsTokenizer needs to be extended.
+
+ PdfResult ret = kPartial_PdfResult;
+ SkPdfTokenizer tokenizer(skobj);
+ PdfMainLooper looper(NULL, &tokenizer, pdfContext, canvas);
+ looper.loop();
+
+ // TODO(edisonn): should we restore the variable stack at the same state?
+ // There could be operands left, that could be consumed by a parent tokenizer when we pop.
+ canvas->restore();
+ PdfOp_Q(pdfContext, canvas, NULL);
+ return ret;
+}
+
+
+// TODO(edisonn): faster, have the property on the SkPdfObject itself?
+std::set<const PdfObject*> gInRendering;
+
+class CheckRecursiveRendering {
+ const PdfObject& fObj;
+public:
+ CheckRecursiveRendering(const PdfObject& obj) : fObj(obj) {
+ gInRendering.insert(&obj);
+ }
+
+ ~CheckRecursiveRendering() {
+ //SkASSERT(fObj.fInRendering);
+ gInRendering.erase(&fObj);
+ }
+
+ static bool IsInRendering(const PdfObject& obj) {
+ return gInRendering.find(&obj) != gInRendering.end();
+ }
+};
+
+PdfResult doXObject(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfObject& obj) {
+ if (CheckRecursiveRendering::IsInRendering(*obj.podofo())) {
+ // Oops, corrupt PDF!
+ return kIgnoreError_PdfResult;
+ }
+
+ CheckRecursiveRendering checkRecursion(*obj.podofo());
+
+ // TODO(edisonn): check type
+ SkPdfXObjectDictionary* skobj = NULL;
+ if (!mapXObjectDictionary(obj, &skobj)) return kIgnoreError_PdfResult;
+
+ if (!skobj || !skobj->valid()) return kIgnoreError_PdfResult;
+
+ PdfResult ret = kIgnoreError_PdfResult;
+ switch (skobj->getType())
+ {
+ case kImageDictionary_SkPdfObjectType:
+ ret = doXObject_Image(pdfContext, canvas, skobj->asImageDictionary());
+ break;
+ case kType1FormDictionary_SkPdfObjectType:
+ ret = doXObject_Form(pdfContext, canvas, skobj->asType1FormDictionary());
+ break;
+ //case kObjectDictionaryXObjectPS_SkPdfObjectType:
+ //return doXObject_PS(skxobj.asPS());
+ }
+
+ delete skobj;
+ return ret;
+}
+
+PdfResult PdfOp_q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fStateStack.push(pdfContext->fGraphicsState);
+ canvas->save();
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_Q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fGraphicsState = pdfContext->fStateStack.top();
+ pdfContext->fStateStack.pop();
+ canvas->restore();
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_cm(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ double array[6];
+ for (int i = 0 ; i < 6 ; i++) {
+ array[5 - i] = pdfContext->fObjectStack.top()->asNumber()->value();
+ pdfContext->fObjectStack.pop();
+ }
+
+ // a b
+ // c d
+ // e f
+
+ // 0 1
+ // 2 3
+ // 4 5
+
+ // sx ky
+ // kx sy
+ // tx ty
+ SkMatrix matrix = SkMatrixFromPdfMatrix(array);
+
+ pdfContext->fGraphicsState.fMatrix.preConcat(matrix);
+
+#ifdef PDF_TRACE
+ printf("cm ");
+ for (int i = 0 ; i < 6 ; i++) {
+ printf("%f ", array[i]);
+ }
+ printf("\n");
+ SkTraceMatrix(pdfContext->fGraphicsState.fMatrix);
+#endif
+
+ return kOK_PdfResult;
+}
+
+//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.
+PdfResult PdfOp_TL(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ double ty = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ pdfContext->fGraphicsState.fTextLeading = ty;
+
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_Td(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ double ty = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double tx = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ double array[6] = {1, 0, 0, 1, tx, ty};
+ SkMatrix matrix = SkMatrixFromPdfMatrix(array);
+
+ pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
+ pdfContext->fGraphicsState.fMatrixTlm.preConcat(matrix);
+
+ return kPartial_PdfResult;
+}
+
+PdfResult PdfOp_TD(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ double ty = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double tx = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ // TODO(edisonn): Create factory methods or constructors so podofo is hidden
+ PdfObject _ty(PdfVariant(-ty));
+ pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc->podofo(), &_ty));
+
+ PdfOp_TL(pdfContext, canvas, looper);
+
+ PdfObject vtx(PdfVariant(-(-tx))); // TODO(edisonn): Hmm, the compiler thinks I have here a function pointer if we use (tx), but not -(-tx)
+ pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc->podofo(), &vtx));
+
+ PdfObject vty(PdfVariant(-(-ty)));
+ pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc->podofo(), &vty));
+
+ return PdfOp_Td(pdfContext, canvas, looper);
+}
+
+PdfResult PdfOp_Tm(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ double f = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double e = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double d = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double c = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double b = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double a = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ double array[6];
+ array[0] = a;
+ array[1] = b;
+ array[2] = c;
+ array[3] = d;
+ array[4] = e;
+ array[5] = f;
+
+ SkMatrix matrix = SkMatrixFromPdfMatrix(array);
+ matrix.postConcat(pdfContext->fGraphicsState.fMatrix);
+
+ // TODO(edisonn): Text positioning.
+ pdfContext->fGraphicsState.fMatrixTm = matrix;
+ pdfContext->fGraphicsState.fMatrixTlm = matrix;;
+
+ return kPartial_PdfResult;
+}
+
+//— 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
+PdfResult PdfOp_T_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ PdfObject zero(PdfVariant(0.0));
+ PdfObject tl(PdfVariant(-(-pdfContext->fGraphicsState.fTextLeading)));
+
+ pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc->podofo(), &zero));
+ pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc->podofo(), &tl));
+ return PdfOp_Td(pdfContext, canvas, looper);
+}
+
+PdfResult PdfOp_m(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ if (pdfContext->fGraphicsState.fPathClosed) {
+ pdfContext->fGraphicsState.fPath.reset();
+ pdfContext->fGraphicsState.fPathClosed = false;
+ }
+
+ pdfContext->fGraphicsState.fCurPosY = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ pdfContext->fGraphicsState.fCurPosX = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ pdfContext->fGraphicsState.fPath.moveTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX),
+ SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY));
+
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_l(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ if (pdfContext->fGraphicsState.fPathClosed) {
+ pdfContext->fGraphicsState.fPath.reset();
+ pdfContext->fGraphicsState.fPathClosed = false;
+ }
+
+ pdfContext->fGraphicsState.fCurPosY = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ pdfContext->fGraphicsState.fCurPosX = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ pdfContext->fGraphicsState.fPath.lineTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX),
+ SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY));
+
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_c(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ if (pdfContext->fGraphicsState.fPathClosed) {
+ pdfContext->fGraphicsState.fPath.reset();
+ pdfContext->fGraphicsState.fPathClosed = false;
+ }
+
+ double y3 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double x3 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double y2 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double x2 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double y1 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double x1 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1),
+ SkDoubleToScalar(x2), SkDoubleToScalar(y2),
+ SkDoubleToScalar(x3), SkDoubleToScalar(y3));
+
+ pdfContext->fGraphicsState.fCurPosX = x3;
+ pdfContext->fGraphicsState.fCurPosY = y3;
+
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_v(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ if (pdfContext->fGraphicsState.fPathClosed) {
+ pdfContext->fGraphicsState.fPath.reset();
+ pdfContext->fGraphicsState.fPathClosed = false;
+ }
+
+ double y3 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double x3 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double y2 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double x2 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double y1 = pdfContext->fGraphicsState.fCurPosY;
+ double x1 = pdfContext->fGraphicsState.fCurPosX;
+
+ pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1),
+ SkDoubleToScalar(x2), SkDoubleToScalar(y2),
+ SkDoubleToScalar(x3), SkDoubleToScalar(y3));
+
+ pdfContext->fGraphicsState.fCurPosX = x3;
+ pdfContext->fGraphicsState.fCurPosY = y3;
+
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_y(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ if (pdfContext->fGraphicsState.fPathClosed) {
+ pdfContext->fGraphicsState.fPath.reset();
+ pdfContext->fGraphicsState.fPathClosed = false;
+ }
+
+ double y3 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double x3 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double y2 = pdfContext->fGraphicsState.fCurPosY;
+ double x2 = pdfContext->fGraphicsState.fCurPosX;
+ double y1 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double x1 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1),
+ SkDoubleToScalar(x2), SkDoubleToScalar(y2),
+ SkDoubleToScalar(x3), SkDoubleToScalar(y3));
+
+ pdfContext->fGraphicsState.fCurPosX = x3;
+ pdfContext->fGraphicsState.fCurPosY = y3;
+
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_re(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ if (pdfContext->fGraphicsState.fPathClosed) {
+ pdfContext->fGraphicsState.fPath.reset();
+ pdfContext->fGraphicsState.fPathClosed = false;
+ }
+
+ double height = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double width = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double y = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double x = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ pdfContext->fGraphicsState.fPath.addRect(SkDoubleToScalar(x), SkDoubleToScalar(y),
+ SkDoubleToScalar(x + width), SkDoubleToScalar(y + height));
+
+ pdfContext->fGraphicsState.fCurPosX = x;
+ pdfContext->fGraphicsState.fCurPosY = y + height;
+
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_h(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fGraphicsState.fPath.close();
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_fillAndStroke(PdfContext* pdfContext, SkCanvas* canvas, bool fill, bool stroke, bool close, bool evenOdd) {
+ SkPath path = pdfContext->fGraphicsState.fPath;
+
+ if (close) {
+ path.close();
+ }
+
+ canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
+
+ SkPaint paint;
+
+ SkPoint line[2];
+ if (fill && !stroke && path.isLine(line)) {
+ paint.setStyle(SkPaint::kStroke_Style);
+
+ pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
+ paint.setStrokeWidth(SkDoubleToScalar(0));
+
+ canvas->drawPath(path, paint);
+ } else {
+ if (fill) {
+ paint.setStyle(SkPaint::kFill_Style);
+ if (evenOdd) {
+ path.setFillType(SkPath::kEvenOdd_FillType);
+ }
+
+ pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
+
+ canvas->drawPath(path, paint);
+ }
+
+ if (stroke) {
+ paint.setStyle(SkPaint::kStroke_Style);
+
+ pdfContext->fGraphicsState.applyGraphicsState(&paint, true);
+
+ path.setFillType(SkPath::kWinding_FillType); // reset it, just in case it messes up the stroke
+ canvas->drawPath(path, paint);
+ }
+ }
+
+ pdfContext->fGraphicsState.fPath.reset();
+ // todo zoom ... other stuff ?
+
+ if (pdfContext->fGraphicsState.fHasClipPathToApply) {
+#ifndef PDF_DEBUG_NO_CLIPING
+ canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true);
+#endif
+ }
+
+ //pdfContext->fGraphicsState.fClipPath.reset();
+ pdfContext->fGraphicsState.fHasClipPathToApply = false;
+
+ return kPartial_PdfResult;
+
+}
+
+PdfResult PdfOp_S(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_fillAndStroke(pdfContext, canvas, false, true, false, false);
+}
+
+PdfResult PdfOp_s(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_fillAndStroke(pdfContext, canvas, false, true, true, false);
+}
+
+PdfResult PdfOp_F(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
+}
+
+PdfResult PdfOp_f(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
+}
+
+PdfResult PdfOp_f_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, true);
+}
+
+PdfResult PdfOp_B(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, false);
+}
+
+PdfResult PdfOp_B_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, true);
+}
+
+PdfResult PdfOp_b(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, false);
+}
+
+PdfResult PdfOp_b_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, true);
+}
+
+PdfResult PdfOp_n(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
+ if (pdfContext->fGraphicsState.fHasClipPathToApply) {
+#ifndef PDF_DEBUG_NO_CLIPING
+ canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true);
+#endif
+ }
+
+ //pdfContext->fGraphicsState.fClipPath.reset();
+ pdfContext->fGraphicsState.fHasClipPathToApply = false;
+
+ pdfContext->fGraphicsState.fPathClosed = true;
+
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_BT(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fGraphicsState.fTextBlock = true;
+ pdfContext->fGraphicsState.fMatrixTm = pdfContext->fGraphicsState.fMatrix;
+ pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix;
+
+ return kPartial_PdfResult;
+}
+
+PdfResult PdfOp_ET(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ if (!pdfContext->fGraphicsState.fTextBlock) {
+ return kIgnoreError_PdfResult;
+ }
+ // TODO(edisonn): anything else to be done once we are done with draw text? Like restore stack?
+ return kPartial_PdfResult;
+}
+
+//font size Tf Set the text font, Tf
+//, to font and the text font size, Tfs, to size. font is the name of a
+//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.
+PdfResult PdfOp_Tf(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fGraphicsState.fCurFontSize = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ std::string fontName = pdfContext->fObjectStack.top()->asName()->value(); pdfContext->fObjectStack.pop();
+
+#ifdef PDF_TRACE
+ printf("font name: %s\n", fontName.c_str());
+ std::string str;
+ pdfContext->fGraphicsState.fResources->podofo()->ToString(str);
+ printf("Print Tf Resources: %s\n", str.c_str());
+ pdfContext->fGraphicsState.fResources->Font()->podofo()->ToString(str);
+ printf("Print Tf Resources/Font: %s\n", str.c_str());
+#endif
+
+ SkPdfFontDictionary* fd = NULL;
+ if (pdfContext->fGraphicsState.fResources->Font()) {
+ SkPdfObject* objFont = pdfContext->fGraphicsState.fResources->Font()->get(fontName.c_str());
+ mapFontDictionary(*objFont, &fd);
+
+#ifdef PDF_TRACE
+ objFont->podofo()->ToString(str);
+ printf("Print Font loaded: %s\n", str.c_str());
+ fd->podofo()->ToString(str);
+ printf("Print Font loaded and resolved and upgraded: %s\n", str.c_str());
+#endif
+
+ }
+
+ SkPdfFont* skfont = SkPdfFont::fontFromPdfDictionary(fd);
+
+ if (skfont) {
+ pdfContext->fGraphicsState.fSkFont = skfont;
+ }
+
+ return kPartial_PdfResult;
+}
+
+PdfResult PdfOp_Tj(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ if (!pdfContext->fGraphicsState.fTextBlock) {
+ // TODO(edisonn): try to recover and draw it any way?
+ return kIgnoreError_PdfResult;
+ }
+
+ PdfResult ret = DrawText(pdfContext,
+ pdfContext->fObjectStack.top(),
+ canvas);
+ pdfContext->fObjectStack.pop();
+
+ return ret;
+}
+
+PdfResult PdfOp_quote(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ if (!pdfContext->fGraphicsState.fTextBlock) {
+ // TODO(edisonn): try to recover and draw it any way?
+ return kIgnoreError_PdfResult;
+ }
+
+ PdfOp_T_star(pdfContext, canvas, looper);
+ // Do not pop, and push, just transfer the param to Tj
+ return PdfOp_Tj(pdfContext, canvas, looper);
+}
+
+PdfResult PdfOp_doublequote(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ if (!pdfContext->fGraphicsState.fTextBlock) {
+ // TODO(edisonn): try to recover and draw it any way?
+ return kIgnoreError_PdfResult;
+ }
+
+ SkPdfObject* str = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+ SkPdfObject* ac = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+ SkPdfObject* aw = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
+
+ pdfContext->fObjectStack.push(aw);
+ PdfOp_Tw(pdfContext, canvas, looper);
+
+ pdfContext->fObjectStack.push(ac);
+ PdfOp_Tc(pdfContext, canvas, looper);
+
+ pdfContext->fObjectStack.push(str);
+ PdfOp_quote(pdfContext, canvas, looper);
+
+ return kPartial_PdfResult;
+}
+
+PdfResult PdfOp_TJ(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ if (!pdfContext->fGraphicsState.fTextBlock) {
+ // TODO(edisonn): try to recover and draw it any way?
+ return kIgnoreError_PdfResult;
+ }
+
+ SkPdfArray* array = pdfContext->fObjectStack.top()->asArray();
+ pdfContext->fObjectStack.pop();
+
+ for( int i=0; i<static_cast<int>(array->size()); i++ )
+ {
+ if( (*array)[i]->asString()) {
+ SkPdfObject* obj = (*array)[i];
+ DrawText(pdfContext,
+ obj,
+ canvas);
+ } else if ((*array)[i]->asInteger() || (*array)[i]->asNumber()) {
+ double dx = (*array)[i]->asNumber()->value();
+ SkMatrix matrix;
+ matrix.setAll(SkDoubleToScalar(1),
+ SkDoubleToScalar(0),
+ // TODO(edisonn): use writing mode, vertical/horizontal.
+ SkDoubleToScalar(-dx), // amount is substracted!!!
+ SkDoubleToScalar(0),
+ SkDoubleToScalar(1),
+ SkDoubleToScalar(0),
+ SkDoubleToScalar(0),
+ SkDoubleToScalar(0),
+ SkDoubleToScalar(1));
+
+ pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
+ }
+ }
+ return kPartial_PdfResult; // TODO(edisonn): Implement fully DrawText before returing OK.
+}
+
+PdfResult PdfOp_CS_cs(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
+ colorOperator->fColorSpace = pdfContext->fObjectStack.top()->asName()->value(); pdfContext->fObjectStack.pop();
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_CS(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
+}
+
+PdfResult PdfOp_cs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
+}
+
+PdfResult PdfOp_SC_sc(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
+ double c[4];
+ pdf_int64 v[4];
+
+ int n = GetColorSpaceComponents(colorOperator->fColorSpace);
+
+ bool doubles = true;
+ if (colorOperator->fColorSpace == "Indexed") {
+ doubles = false;
+ }
+
+#ifdef PDF_TRACE
+ printf("color space = %s, N = %i\n", colorOperator->fColorSpace.c_str(), n);
+#endif
+
+ for (int i = n - 1; i >= 0 ; i--) {
+ if (doubles) {
+ c[i] = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ } else {
+ v[i] = pdfContext->fObjectStack.top()->asInteger()->value(); pdfContext->fObjectStack.pop();
+ }
+ }
+
+ // TODO(edisonn): Now, set that color. Only DeviceRGB supported.
+ if (colorOperator->fColorSpace == "DeviceRGB") {
+ colorOperator->setRGBColor(SkColorSetRGB(255*c[0], 255*c[1], 255*c[2]));
+ }
+ return kPartial_PdfResult;
+}
+
+PdfResult PdfOp_SC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
+}
+
+PdfResult PdfOp_sc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
+}
+
+PdfResult PdfOp_SCN_scn(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
+ PdfString name;
+
+ if (pdfContext->fObjectStack.top()->asName()) {
+ pdfContext->fObjectStack.pop();
+ }
+
+ // TODO(edisonn): SCN supports more color spaces than SCN. Read and implement spec.
+ PdfOp_SC_sc(pdfContext, canvas, colorOperator);
+
+ return kPartial_PdfResult;
+}
+
+PdfResult PdfOp_SCN(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
+}
+
+PdfResult PdfOp_scn(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
+}
+
+PdfResult PdfOp_G_g(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
+ double gray = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ return kNYI_PdfResult;
+}
+
+PdfResult PdfOp_G(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
+}
+
+PdfResult PdfOp_g(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
+}
+
+PdfResult PdfOp_RG_rg(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
+ double b = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double g = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double r = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ colorOperator->fColorSpace = "DeviceRGB";
+ colorOperator->setRGBColor(SkColorSetRGB(255*r, 255*g, 255*b));
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_RG(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
+}
+
+PdfResult PdfOp_rg(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
+}
+
+PdfResult PdfOp_K_k(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
+ // TODO(edisonn): spec has some rules about overprint, implement them.
+ double k = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double y = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double m = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ double c = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ colorOperator->fColorSpace = "DeviceCMYK";
+ // TODO(edisonn): Set color.
+ return kNYI_PdfResult;
+}
+
+PdfResult PdfOp_K(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
+}
+
+PdfResult PdfOp_k(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
+}
+
+PdfResult PdfOp_W(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
+ pdfContext->fGraphicsState.fHasClipPathToApply = true;
+
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_W_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
+
+#ifdef PDF_TRACE
+ if (pdfContext->fGraphicsState.fClipPath.isRect(NULL)) {
+ printf("CLIP IS RECT\n");
+ }
+#endif
+
+ // TODO(edisonn): there seem to be a bug with clipPath of a rect with even odd.
+ pdfContext->fGraphicsState.fClipPath.setFillType(SkPath::kEvenOdd_FillType);
+ pdfContext->fGraphicsState.fHasClipPathToApply = true;
+
+ return kPartial_PdfResult;
+}
+
+PdfResult PdfOp_BX(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ *looper = new PdfCompatibilitySectionLooper();
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_EX(PdfContext* 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;
+}
+
+PdfResult PdfOp_BI(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ *looper = new PdfInlineImageLooper();
+ return kOK_PdfResult;
+}
+
+PdfResult PdfOp_ID(PdfContext* 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;
+}
+
+PdfResult PdfOp_EI(PdfContext* 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;
+}
+
+//lineWidth w Set the line width in the graphics state (see “Line Width” on page 152).
+PdfResult PdfOp_w(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ double lineWidth = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ pdfContext->fGraphicsState.fLineWidth = lineWidth;
+
+ return kOK_PdfResult;
+}
+
+//lineCap J Set the line cap style in the graphics state (see “Line Cap Style” on page 153).
+PdfResult PdfOp_J(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+ //double lineCap = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//lineJoin j Set the line join style in the graphics state (see “Line Join Style” on page 153).
+PdfResult PdfOp_j(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+ //double lineJoin = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//miterLimit M Set the miter limit in the graphics state (see “Miter Limit” on page 153).
+PdfResult PdfOp_M(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+ //double miterLimit = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//dashArray dashPhase d Set the line dash pattern in the graphics state (see “Line Dash Pattern” on
+//page 155).
+PdfResult PdfOp_d(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+ pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//intent ri (PDF 1.1) Set the color rendering intent in the graphics state (see “Rendering Intents” on page 197).
+PdfResult PdfOp_ri(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//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.
+PdfResult PdfOp_i(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//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).
+PdfResult PdfOp_gs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ std::string name = pdfContext->fObjectStack.top()->asName()->value(); pdfContext->fObjectStack.pop();
+
+#ifdef PDF_TRACE
+ std::string str;
+#endif
+
+ //Next, get the ExtGState Dictionary from the Resource Dictionary:
+ const SkPdfDictionary* extGStateDictionary = pdfContext->fGraphicsState.fResources->ExtGState();
+
+ if (extGStateDictionary == NULL) {
+#ifdef PDF_TRACE
+ printf("ExtGState is NULL!\n");
+#endif
+ return kIgnoreError_PdfResult;
+ }
+
+ SkPdfObject* value = extGStateDictionary->get(name.c_str());
+
+#ifdef PDF_TRACE
+// value->ToString(str);
+// printf("gs object value: %s\n", str.c_str());
+#endif
+
+ SkPdfGraphicsStateDictionary* gs = NULL;
+ mapGraphicsStateDictionary(*value, &gs);
+
+ // TODO(edisonn): now load all those properties in graphic state.
+ if (gs == NULL) {
+ return kIgnoreError_PdfResult;
+ }
+
+ if (gs->has_CA()) {
+ pdfContext->fGraphicsState.fStroking.fOpacity = gs->CA();
+ }
+
+ if (gs->has_ca()) {
+ pdfContext->fGraphicsState.fNonStroking.fOpacity = gs->ca();
+ }
+
+ if (gs->has_LW()) {
+ pdfContext->fGraphicsState.fLineWidth = gs->LW();
+ }
+
+
+
+ return kNYI_PdfResult;
+}
+
+//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) {
+ double charSpace = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ pdfContext->fGraphicsState.fCharSpace = charSpace;
+
+ return kOK_PdfResult;
+}
+
+//wordSpace Tw Set the word spacing, T
+//w
+//, 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) {
+ double wordSpace = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+ pdfContext->fGraphicsState.fWordSpace = wordSpace;
+
+ return kOK_PdfResult;
+}
+
+//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).
+PdfResult PdfOp_Tz(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ double scale = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//render Tr Set the text rendering mode, T
+//mode, to render, which is an integer. Initial value: 0.
+PdfResult PdfOp_Tr(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ double render = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+//rise Ts Set the text rise, Trise, to rise, which is a number expressed in unscaled text space
+//units. Initial value: 0.
+PdfResult PdfOp_Ts(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ double rise = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//wx wy d0
+PdfResult PdfOp_d0(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+ pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//wx wy llx lly urx ury d1
+PdfResult PdfOp_d1(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+ pdfContext->fObjectStack.pop();
+ pdfContext->fObjectStack.pop();
+ pdfContext->fObjectStack.pop();
+ pdfContext->fObjectStack.pop();
+ pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//name sh
+PdfResult PdfOp_sh(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//name Do
+PdfResult PdfOp_Do(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ std::string name = pdfContext->fObjectStack.top()->asName()->value(); pdfContext->fObjectStack.pop();
+
+ SkPdfDictionary* xObject = pdfContext->fGraphicsState.fResources->XObject();
+
+ if (xObject == NULL) {
+#ifdef PDF_TRACE
+ printf("XObject is NULL!\n");
+#endif
+ return kIgnoreError_PdfResult;
+ }
+
+ SkPdfObject* value = xObject->get(name.c_str());
+
+#ifdef PDF_TRACE
+// value->ToString(str);
+// printf("Do object value: %s\n", str.c_str());
+#endif
+
+ return doXObject(pdfContext, canvas, *value);
+}
+
+//tag MP Designate a marked-content point. tag is a name object indicating the role or
+//significance of the point.
+PdfResult PdfOp_MP(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//tag properties DP Designate a marked-content point with an associated property list. tag is a
+//name object indicating the role or significance of the point; properties is
+//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”).
+PdfResult PdfOp_DP(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+ pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//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.
+PdfResult PdfOp_BMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//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”).
+PdfResult PdfOp_BDC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ pdfContext->fObjectStack.pop();
+ pdfContext->fObjectStack.pop();
+
+ return kNYI_PdfResult;
+}
+
+//— EMC End a marked-content sequence begun by a BMC or BDC operator.
+PdfResult PdfOp_EMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+ return kNYI_PdfResult;
+}
+
+void initPdfOperatorRenderes() {
+ static bool gInitialized = false;
+ if (gInitialized) {
+ return;
+ }
+
+ gPdfOps["q"] = PdfOp_q;
+ gPdfOps["Q"] = PdfOp_Q;
+ gPdfOps["cm"] = PdfOp_cm;
+
+ gPdfOps["TD"] = PdfOp_TD;
+ gPdfOps["Td"] = PdfOp_Td;
+ gPdfOps["Tm"] = PdfOp_Tm;
+ gPdfOps["T*"] = PdfOp_T_star;
+
+ gPdfOps["m"] = PdfOp_m;
+ gPdfOps["l"] = PdfOp_l;
+ gPdfOps["c"] = PdfOp_c;
+ gPdfOps["v"] = PdfOp_v;
+ gPdfOps["y"] = PdfOp_y;
+ gPdfOps["h"] = PdfOp_h;
+ gPdfOps["re"] = PdfOp_re;
+
+ gPdfOps["S"] = PdfOp_S;
+ gPdfOps["s"] = PdfOp_s;
+ gPdfOps["f"] = PdfOp_f;
+ gPdfOps["F"] = PdfOp_F;
+ gPdfOps["f*"] = PdfOp_f_star;
+ gPdfOps["B"] = PdfOp_B;
+ gPdfOps["B*"] = PdfOp_B_star;
+ gPdfOps["b"] = PdfOp_b;
+ gPdfOps["b*"] = PdfOp_b_star;
+ gPdfOps["n"] = PdfOp_n;
+
+ gPdfOps["BT"] = PdfOp_BT;
+ gPdfOps["ET"] = PdfOp_ET;
+
+ gPdfOps["Tj"] = PdfOp_Tj;
+ gPdfOps["'"] = PdfOp_quote;
+ gPdfOps["\""] = PdfOp_doublequote;
+ gPdfOps["TJ"] = PdfOp_TJ;
+
+ gPdfOps["CS"] = PdfOp_CS;
+ gPdfOps["cs"] = PdfOp_cs;
+ gPdfOps["SC"] = PdfOp_SC;
+ gPdfOps["SCN"] = PdfOp_SCN;
+ gPdfOps["sc"] = PdfOp_sc;
+ gPdfOps["scn"] = PdfOp_scn;
+ gPdfOps["G"] = PdfOp_G;
+ gPdfOps["g"] = PdfOp_g;
+ gPdfOps["RG"] = PdfOp_RG;
+ gPdfOps["rg"] = PdfOp_rg;
+ gPdfOps["K"] = PdfOp_K;
+ gPdfOps["k"] = PdfOp_k;
+
+ gPdfOps["W"] = PdfOp_W;
+ gPdfOps["W*"] = PdfOp_W_star;
+
+ gPdfOps["BX"] = PdfOp_BX;
+ gPdfOps["EX"] = PdfOp_EX;
+
+ gPdfOps["BI"] = PdfOp_BI;
+ gPdfOps["ID"] = PdfOp_ID;
+ gPdfOps["EI"] = PdfOp_EI;
+
+ gPdfOps["w"] = PdfOp_w;
+ gPdfOps["J"] = PdfOp_J;
+ gPdfOps["j"] = PdfOp_j;
+ gPdfOps["M"] = PdfOp_M;
+ gPdfOps["d"] = PdfOp_d;
+ gPdfOps["ri"] = PdfOp_ri;
+ gPdfOps["i"] = PdfOp_i;
+ gPdfOps["gs"] = PdfOp_gs;
+
+ gPdfOps["Tc"] = PdfOp_Tc;
+ gPdfOps["Tw"] = PdfOp_Tw;
+ gPdfOps["Tz"] = PdfOp_Tz;
+ gPdfOps["TL"] = PdfOp_TL;
+ gPdfOps["Tf"] = PdfOp_Tf;
+ gPdfOps["Tr"] = PdfOp_Tr;
+ gPdfOps["Ts"] = PdfOp_Ts;
+
+ gPdfOps["d0"] = PdfOp_d0;
+ gPdfOps["d1"] = PdfOp_d1;
+
+ gPdfOps["sh"] = PdfOp_sh;
+
+ gPdfOps["Do"] = PdfOp_Do;
+
+ gPdfOps["MP"] = PdfOp_MP;
+ gPdfOps["DP"] = PdfOp_DP;
+ gPdfOps["BMC"] = PdfOp_BMC;
+ gPdfOps["BDC"] = PdfOp_BDC;
+ gPdfOps["EMC"] = PdfOp_EMC;
+
+ gInitialized = true;
+}
+
+class InitPdfOps {
+public:
+ InitPdfOps() {
+ initPdfOperatorRenderes();
+ }
+};
+
+InitPdfOps gInitPdfOps;
+
+void reportPdfRenderStats() {
+ std::map<std::string, int>::iterator iter;
+
+ for (int i = 0 ; i < kCount_PdfResult; i++) {
+ for (iter = gRenderStats[i].begin(); iter != gRenderStats[i].end(); ++iter) {
+ printf("%s: %s -> count %i\n", gRenderStatsNames[i], iter->first.c_str(), iter->second);
+ }
+ }
+}
+
+PdfResult PdfMainLooper::consumeToken(PdfToken& token) {
+ if (token.fType == kKeyword_TokenType)
+ {
+ // TODO(edisonn): log trace flag (verbose, error, info, warning, ...)
+ PdfOperatorRenderer pdfOperatorRenderer = gPdfOps[token.fKeyword];
+ if (pdfOperatorRenderer) {
+ // caller, main work is done by pdfOperatorRenderer(...)
+ PdfTokenLooper* childLooper = NULL;
+ gRenderStats[pdfOperatorRenderer(fPdfContext, fCanvas, &childLooper)][token.fKeyword]++;
+
+ if (childLooper) {
+ childLooper->setUp(this);
+ childLooper->loop();
+ delete childLooper;
+ }
+ } else {
+ gRenderStats[kUnsupported_PdfResult][token.fKeyword]++;
+ }
+ }
+ else if (token.fType == kObject_TokenType)
+ {
+ fPdfContext->fObjectStack.push( token.fObject );
+ }
+ else if ( token.fType == kImageData_TokenType) {
+ // TODO(edisonn): implement inline image.
+ }
+ else {
+ return kIgnoreError_PdfResult;
+ }
+ return kOK_PdfResult;
+}
+
+void PdfMainLooper::loop() {
+ PdfToken token;
+ while (readToken(fTokenizer, &token)) {
+ consumeToken(token);
+ }
+}
+
+PdfResult PdfInlineImageLooper::consumeToken(PdfToken& token) {
+ //pdfContext.fInlineImage.fKeyValuePairs[key] = value;
+ return kNYI_PdfResult;
+}
+
+void PdfInlineImageLooper::loop() {
+ PdfToken token;
+ while (readToken(fTokenizer, &token)) {
+ if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) {
+ PdfTokenLooper* looper = new PdfCompatibilitySectionLooper();
+ looper->setUp(this);
+ looper->loop();
+ } else {
+ if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EI") == 0) {
+ done();
+ return;
+ }
+
+ consumeToken(token);
+ }
+ }
+ // TODO(edisonn): report error/warning, EOF without EI.
+}
+
+PdfResult PdfInlineImageLooper::done() {
+
+ // TODO(edisonn): long to short names
+ // TODO(edisonn): set properties in a map
+ // TODO(edisonn): extract bitmap stream, check if PoDoFo has public utilities to uncompress
+ // the stream.
+
+ SkBitmap bitmap;
+ setup_bitmap(&bitmap, 50, 50, SK_ColorRED);
+
+ // TODO(edisonn): matrix use.
+ // Draw dummy red square, to show the prezence of the inline image.
+ fCanvas->drawBitmap(bitmap,
+ SkDoubleToScalar(0),
+ SkDoubleToScalar(0),
+ NULL);
+ return kNYI_PdfResult;
+}
+
+PdfResult PdfCompatibilitySectionLooper::consumeToken(PdfToken& token) {
+ return fParent->consumeToken(token);
+}
+
+void PdfCompatibilitySectionLooper::loop() {
+ // TODO(edisonn): save stacks position, or create a new stack?
+ // TODO(edisonn): what happens if we pop out more variables then when we started?
+ // restore them? fail? We could create a new operands stack for every new BX/EX section,
+ // pop-ing too much will not affect outside the section.
+ PdfToken token;
+ while (readToken(fTokenizer, &token)) {
+ if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) {
+ PdfTokenLooper* looper = new PdfCompatibilitySectionLooper();
+ looper->setUp(this);
+ looper->loop();
+ delete looper;
+ } else {
+ if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EX") == 0) break;
+ fParent->consumeToken(token);
+ }
+ }
+ // TODO(edisonn): restore stack.
+}
+
+// TODO(edisonn): fix PoDoFo load ~/crashing/Shading.pdf
+// TODO(edisonn): Add API for Forms viewing and editing
+// e.g. SkBitmap getPage(int page);
+// int formsCount();
+// SkForm getForm(int formID); // SkForm(SkRect, .. other data)
+// TODO (edisonn): Add intend when loading pdf, for example: for viewing, parsing all content, ...
+// if we load the first page, and we zoom to fit to screen horizontally, then load only those
+// resources needed, so the preview is fast.
+// TODO (edisonn): hide parser/tokenizer behind and interface and a query language, and resolve
+// references automatically.
+
+bool SkPdfViewer::load(const SkString inputFileName, SkPicture* out) {
+ try
+ {
+ std::cout << "Init: " << inputFileName.c_str() << std::endl;
+
+ SkPdfDoc doc(inputFileName.c_str());
+ if (!doc.pages())
+ {
+ std::cout << "ERROR: Empty Document" << inputFileName.c_str() << std::endl;
+ return false;
+ } else {
+
+ for (int pn = 0; pn < doc.pages(); ++pn) {
+ // TODO(edisonn): implement inheritance properties as per PDF spec
+ //SkRect rect = page->MediaBox();
+ SkRect rect = doc.MediaBox(pn);
+
+ #ifdef PDF_TRACE
+ printf("Page Width: %f, Page Height: %f\n", SkScalarToDouble(rect.width()), SkScalarToDouble(rect.height()));
+ #endif
+
+ // TODO(edisonn): page->GetCropBox(), page->GetTrimBox() ... how to use?
+
+ SkBitmap bitmap;
+ #ifdef PDF_DEBUG_3X
+ setup_bitmap(&bitmap, 3 * (int)SkScalarToDouble(rect.width()), 3 * (int)SkScalarToDouble(rect.height()));
+ #else
+ setup_bitmap(&bitmap, (int)SkScalarToDouble(rect.width()), (int)SkScalarToDouble(rect.height()));
+ #endif
+ SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
+ SkCanvas canvas(device);
+
+ gDumpBitmap = &bitmap;
+
+ doc.drawPage(pn, &canvas);
+
+ SkString out;
+ out.appendf("%s-%i.png", inputFileName.c_str(), pn);
+ SkImageEncoder::EncodeFile(out.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100);
+ }
+ return true;
+ }
+ }
+ catch( PdfError & e )
+ {
+ std::cout << "ERROR: PDF can't be parsed!" << inputFileName.c_str() << std::endl;
+ return false;
+ }
+
+ return true;
+}
+
+
diff --git a/experimental/PdfViewer/SkPdfParser.h b/experimental/PdfViewer/SkPdfParser.h
index 7e2cd0e..c156004 100644
--- a/experimental/PdfViewer/SkPdfParser.h
+++ b/experimental/PdfViewer/SkPdfParser.h
@@ -28,8 +28,8 @@
};
class SkPdfTokenizer {
- PdfContentsTokenizer* fTokenizer;
PdfMemDocument* fDoc;
+ PdfContentsTokenizer* fTokenizer;
char* fUncompressedStream;
pdf_long fUncompressedStreamLength;
@@ -39,8 +39,8 @@
PdfToken fPutBack;
public:
- SkPdfTokenizer(PdfMemDocument* doc = NULL, PdfContentsTokenizer* tokenizer = NULL) : fDoc(doc), fTokenizer(tokenizer), fEmpty(false), fUncompressedStream(NULL), fUncompressedStreamLength(0), fHasPutBack(false) {}
- SkPdfTokenizer(const SkPdfObject* objWithStream) : fDoc(NULL), fTokenizer(NULL), fHasPutBack(false), fEmpty(false) {
+ SkPdfTokenizer(PdfMemDocument* doc = NULL, PdfContentsTokenizer* tokenizer = NULL) : fDoc(doc), fTokenizer(tokenizer), fUncompressedStream(NULL), fUncompressedStreamLength(0), fEmpty(false), fHasPutBack(false) {}
+ SkPdfTokenizer(const SkPdfObject* objWithStream) : fDoc(NULL), fTokenizer(NULL), fEmpty(false), fHasPutBack(false) {
fUncompressedStream = NULL;
fUncompressedStreamLength = 0;
@@ -60,7 +60,7 @@
}
- SkPdfTokenizer(const char* buffer, int len) : fDoc(NULL), fTokenizer(NULL), fHasPutBack(false), fUncompressedStream(NULL), fUncompressedStreamLength(0), fEmpty(false) {
+ SkPdfTokenizer(const char* buffer, int len) : fDoc(NULL), fTokenizer(NULL), fUncompressedStream(NULL), fUncompressedStreamLength(0), fEmpty(false), fHasPutBack(false) {
try {
fTokenizer = new PdfContentsTokenizer(buffer, len);
} catch (PdfError& e) {
@@ -107,7 +107,7 @@
case ePdfContentsType_Variant: {
token->fType = kObject_TokenType;
PdfObject* obj = new PdfObject(var);
- PodofoMapper::map(*fDoc, *obj, &token->fObject);
+ mapObject(*fDoc, *obj, &token->fObject);
}
break;
@@ -127,6 +127,91 @@
}
};
+extern "C" PdfContext* gPdfContext;
+extern "C" SkBitmap* gDumpBitmap;
+extern "C" SkCanvas* gDumpCanvas;
+
+// TODO(edisonn): move in trace util.
+#ifdef PDF_TRACE
+static void SkTraceMatrix(const SkMatrix& matrix, const char* sz = "") {
+ printf("SkMatrix %s ", sz);
+ for (int i = 0 ; i < 9 ; i++) {
+ printf("%f ", SkScalarToDouble(matrix.get(i)));
+ }
+ printf("\n");
+}
+
+static void SkTraceRect(const SkRect& rect, const char* sz = "") {
+ printf("SkRect %s ", sz);
+ printf("x = %f ", SkScalarToDouble(rect.x()));
+ printf("y = %f ", SkScalarToDouble(rect.y()));
+ printf("w = %f ", SkScalarToDouble(rect.width()));
+ printf("h = %f ", SkScalarToDouble(rect.height()));
+ printf("\n");
+}
+
+#else
+#define SkTraceMatrix(a,b)
+#define SkTraceRect(a,b)
+#endif
+
+// TODO(edisonn): Document PdfTokenLooper and subclasses.
+class PdfTokenLooper {
+protected:
+ PdfTokenLooper* fParent;
+ SkPdfTokenizer* fTokenizer;
+ PdfContext* fPdfContext;
+ SkCanvas* fCanvas;
+
+public:
+ PdfTokenLooper(PdfTokenLooper* parent,
+ SkPdfTokenizer* tokenizer,
+ PdfContext* pdfContext,
+ SkCanvas* canvas)
+ : fParent(parent), fTokenizer(tokenizer), fPdfContext(pdfContext), fCanvas(canvas) {}
+
+ virtual PdfResult consumeToken(PdfToken& token) = 0;
+ virtual void loop() = 0;
+
+ void setUp(PdfTokenLooper* parent) {
+ fParent = parent;
+ fTokenizer = parent->fTokenizer;
+ fPdfContext = parent->fPdfContext;
+ fCanvas = parent->fCanvas;
+ }
+};
+
+class PdfMainLooper : public PdfTokenLooper {
+public:
+ PdfMainLooper(PdfTokenLooper* parent,
+ SkPdfTokenizer* tokenizer,
+ PdfContext* pdfContext,
+ SkCanvas* canvas)
+ : PdfTokenLooper(parent, tokenizer, pdfContext, canvas) {}
+
+ virtual PdfResult consumeToken(PdfToken& token);
+ virtual void loop();
+};
+
+class PdfInlineImageLooper : public PdfTokenLooper {
+public:
+ PdfInlineImageLooper()
+ : PdfTokenLooper(NULL, NULL, NULL, NULL) {}
+
+ virtual PdfResult consumeToken(PdfToken& token);
+ virtual void loop();
+ PdfResult done();
+};
+
+class PdfCompatibilitySectionLooper : public PdfTokenLooper {
+public:
+ PdfCompatibilitySectionLooper()
+ : PdfTokenLooper(NULL, NULL, NULL, NULL) {}
+
+ virtual PdfResult consumeToken(PdfToken& token);
+ virtual void loop();
+};
+
class SkPdfDoc {
PdfMemDocument fDoc;
public:
@@ -139,10 +224,20 @@
return fDoc.GetPageCount();
}
+ double width(int n) {
+ PdfRect rect = fDoc.GetPage(n)->GetMediaBox();
+ return rect.GetWidth() + rect.GetLeft();
+ }
+
+ double height(int n) {
+ PdfRect rect = fDoc.GetPage(n)->GetMediaBox();
+ return rect.GetHeight() + rect.GetBottom();
+ }
+
// Can return NULL
SkPdfPageObjectDictionary* page(int n) {
SkPdfPageObjectDictionary* page = NULL;
- PodofoMapper::map(fDoc, *fDoc.GetPage(n)->GetObject(), &page);
+ mapPageObjectDictionary(fDoc, *fDoc.GetPage(n)->GetObject(), &page);
return page;
}
@@ -155,10 +250,89 @@
return skrect;
}
+ void drawPage(int n, SkCanvas* canvas) {
+ SkPdfPageObjectDictionary* pg = page(n);
+ SkPdfTokenizer* tokenizer = tokenizerOfPage(n);
+
+ PdfContext pdfContext(this);
+ pdfContext.fOriginalMatrix = SkMatrix::I();
+ pdfContext.fGraphicsState.fResources = NULL;
+ mapResourceDictionary(*pg->Resources(), &pdfContext.fGraphicsState.fResources);
+
+ gPdfContext = &pdfContext;
+ gDumpCanvas = canvas;
+
+ // TODO(edisonn): get matrix stuff right.
+ // TODO(edisonn): add DPI/scale/zoom.
+ SkScalar z = SkIntToScalar(0);
+ SkRect rect = MediaBox(n);
+ SkScalar w = rect.width();
+ SkScalar h = rect.height();
+
+ SkPoint pdfSpace[4] = {SkPoint::Make(z, z), SkPoint::Make(w, z), SkPoint::Make(w, h), SkPoint::Make(z, h)};
+// SkPoint skiaSpace[4] = {SkPoint::Make(z, h), SkPoint::Make(w, h), SkPoint::Make(w, z), SkPoint::Make(z, z)};
+
+ // TODO(edisonn): add flag for this app to create sourunding buffer zone
+ // TODO(edisonn): add flagg for no clipping.
+ // Use larger image to make sure we do not draw anything outside of page
+ // could be used in tests.
+
+#ifdef PDF_DEBUG_3X
+ SkPoint skiaSpace[4] = {SkPoint::Make(w+z, h+h), SkPoint::Make(w+w, h+h), SkPoint::Make(w+w, h+z), SkPoint::Make(w+z, h+z)};
+#else
+ SkPoint skiaSpace[4] = {SkPoint::Make(z, h), SkPoint::Make(w, h), SkPoint::Make(w, z), SkPoint::Make(z, z)};
+#endif
+ //SkPoint pdfSpace[2] = {SkPoint::Make(z, z), SkPoint::Make(w, h)};
+ //SkPoint skiaSpace[2] = {SkPoint::Make(w, z), SkPoint::Make(z, h)};
+
+ //SkPoint pdfSpace[2] = {SkPoint::Make(z, z), SkPoint::Make(z, h)};
+ //SkPoint skiaSpace[2] = {SkPoint::Make(z, h), SkPoint::Make(z, z)};
+
+ //SkPoint pdfSpace[3] = {SkPoint::Make(z, z), SkPoint::Make(z, h), SkPoint::Make(w, h)};
+ //SkPoint skiaSpace[3] = {SkPoint::Make(z, h), SkPoint::Make(z, z), SkPoint::Make(w, 0)};
+
+ SkAssertResult(pdfContext.fOriginalMatrix.setPolyToPoly(pdfSpace, skiaSpace, 4));
+ SkTraceMatrix(pdfContext.fOriginalMatrix, "Original matrix");
+
+
+ pdfContext.fGraphicsState.fMatrix = pdfContext.fOriginalMatrix;
+ pdfContext.fGraphicsState.fMatrixTm = pdfContext.fGraphicsState.fMatrix;
+ pdfContext.fGraphicsState.fMatrixTlm = pdfContext.fGraphicsState.fMatrix;
+
+ canvas->setMatrix(pdfContext.fOriginalMatrix);
+
+#ifndef PDF_DEBUG_NO_PAGE_CLIPING
+ canvas->clipRect(SkRect::MakeXYWH(z, z, w, h), SkRegion::kIntersect_Op, true);
+#endif
+
+// erase with red before?
+// SkPaint paint;
+// paint.setColor(SK_ColorRED);
+// canvas->drawRect(rect, paint);
+
+ PdfMainLooper looper(NULL, tokenizer, &pdfContext, canvas);
+ looper.loop();
+
+ delete tokenizer;
+
+
+ canvas->flush();
+ }
+
SkPdfTokenizer* tokenizerOfPage(int n) {
PdfContentsTokenizer* t = new PdfContentsTokenizer(fDoc.GetPage(n));
return new SkPdfTokenizer(&fDoc, t);
}
};
+// TODO(edisonn): move in another file
+class SkPdfViewer : public SkRefCnt {
+public:
+
+ bool load(const SkString inputFileName, SkPicture* out);
+ bool write(void*) const { return false; }
+};
+
+void reportPdfRenderStats();
+
#endif // SkPdfParser_DEFINED
diff --git a/experimental/PdfViewer/SkPdfUtils.cpp b/experimental/PdfViewer/SkPdfUtils.cpp
index e69de29..29e3548 100644
--- a/experimental/PdfViewer/SkPdfUtils.cpp
+++ b/experimental/PdfViewer/SkPdfUtils.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfUtils.h"
+
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ SkPdfArray* data) {return false;}
+
+bool FileSpecFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ SkPdfFileSpec* data) {return false;}
+
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ SkPdfStream** data);
+
+bool TreeFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ SkPdfTree** data) {return false;}
+
+bool DateFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ SkPdfDate* data) {return false;}
+
+bool FunctionFromDictionary(const PdfMemDocument* pdfDoc,
+ const PdfDictionary& dict,
+ const char* key,
+ const char* abr,
+ SkPdfFunction* data) {return false;}
diff --git a/experimental/PdfViewer/SkPdfUtils.h b/experimental/PdfViewer/SkPdfUtils.h
index 970b6c1..858ab8e 100644
--- a/experimental/PdfViewer/SkPdfUtils.h
+++ b/experimental/PdfViewer/SkPdfUtils.h
@@ -39,20 +39,17 @@
const char* key,
const char* abr,
std::string* data);
-
+/*
class SkPdfDictionary;
bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc,
const PdfDictionary& dict,
const char* key,
const char* abr,
SkPdfDictionary** data);
+*/
-template <typename T>
-bool DictionaryFromDictionary2(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- T** data);
+bool skpdfmap(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out);
+
class SkPdfObject;
bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
@@ -118,9 +115,10 @@
const char* abr,
SkPdfFunction* data);
-bool skpdfmap(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out);
SkMatrix SkMatrixFromPdfArray(SkPdfArray* pdfArray);
PdfResult doType3Char(PdfContext* pdfContext, SkCanvas* canvas, SkPdfObject* skobj, SkRect bBox, SkMatrix matrix, double textSize);
+#include "SkPdfPodofoMapper_autogen.h"
+
#endif // __DEFINED__SkPdfUtils
diff --git a/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..38d8fb8
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfALinkAnnotationDictionary_autogen.h"
+
+std::string SkPdfALinkAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfALinkAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfALinkAnnotationDictionary::getDestAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfALinkAnnotationDictionary::getDestAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfALinkAnnotationDictionary::getDestAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfALinkAnnotationDictionary::H() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfALinkAnnotationDictionary::PA() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.h
index 920043b..e2ba74e 100644
--- a/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Optional; PDF 1.4) An alternate representation of the annotation's contents in
* human-readable form, useful when extracting the document's contents in sup-
* port of accessibility to disabled users or for other purposes (see Section 9.8.2,
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Optional; not permitted if an A entry is present) A destination to be displayed
* when the annotation is activated (see Section 8.2.1, "Destinations"; see also
* implementation note 66 in Appendix H).
@@ -569,39 +557,21 @@
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getDestAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getDestAsArray() const;
bool isDestAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getDestAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getDestAsName() const;
bool isDestAString() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getDestAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getDestAsString() const;
/** (Optional; PDF 1.2) The annotation's highlighting mode, the visual effect to be
* used when the mouse button is pressed or held down inside its active area:
* N (None) No highlighting.
@@ -620,13 +590,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", NULL));
}
- std::string H() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string H() const;
/** (Optional; PDF 1.3) A URI action (see "URI Actions" on page 523) formerly
* associated with this annotation. When Web Capture (Section 9.9, "Web Cap-
* ture") changes an annotation from a URI to a go-to action ("Go-To Actions"
@@ -638,13 +602,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PA", "", NULL));
}
- SkPdfDictionary* PA() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* PA() const;
};
#endif // __DEFINED__SkPdfALinkAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.cpp
new file mode 100644
index 0000000..ed91efc
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfActionDictionary_autogen.h"
+
+std::string SkPdfActionDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfActionDictionary::getNextAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfActionDictionary::getNextAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.h
index b7fa6d0..56f648e 100644
--- a/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The type of action that this dictionary describes; see Table 8.34
* on page 518 for specific values.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Optional; PDF 1.2) The next action, or sequence of actions, to be per-
* formed after this one. The value is either a single action dictionary or an
* array of action dictionaries to be performed in order; see below for fur-
@@ -568,26 +556,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getNextAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getNextAsDictionary() const;
bool isNextAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getNextAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getNextAsArray() const;
};
#endif // __DEFINED__SkPdfActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.cpp
new file mode 100644
index 0000000..3d262e4
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfAlternateImageDictionary_autogen.h"
+
+SkPdfStream* SkPdfAlternateImageDictionary::Image() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Image", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+bool SkPdfAlternateImageDictionary::DefaultForPrinting() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DefaultForPrinting", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.h
index 5ab6a9d..4e9b886 100644
--- a/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.h
@@ -531,13 +531,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Image", "", NULL));
}
- SkPdfStream* Image() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Image", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Image() const;
/** (Optional) A flag indicating whether this alternate image is the default ver-
* sion to be used for printing. At most one alternate for a given base image may
* be so designated. If no alternate has this entry set to true, the base image itself
@@ -547,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DefaultForPrinting", "", NULL));
}
- bool DefaultForPrinting() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DefaultForPrinting", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool DefaultForPrinting() const;
};
#endif // __DEFINED__SkPdfAlternateImageDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.cpp
new file mode 100644
index 0000000..183dbd1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfAnnotationActionsDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfAnnotationActionsDictionary::E() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationActionsDictionary::X() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "X", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationActionsDictionary::D() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationActionsDictionary::U() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationActionsDictionary::Fo() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fo", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationActionsDictionary::Bl() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bl", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.h
index 01e1ffe..9ded5ee 100644
--- a/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", NULL));
}
- SkPdfDictionary* E() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* E() const;
/** (Optional; PDF 1.2) An action to be performed when the cursor exits the annotation's
* active area.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "X", "", NULL));
}
- SkPdfDictionary* X() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "X", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* X() const;
/** (Optional; PDF 1.2) An action to be performed when the mouse button is pressed
* inside the annotation's active area. (The name D stands for "down.")
**/
@@ -560,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", NULL));
}
- SkPdfDictionary* D() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* D() const;
/** (Optional; PDF 1.2) An action to be performed when the mouse button is released
* inside the annotation's active area. (The name U stands for "up.")
* Note: For backward compatibility, the A entry in an annotation dictionary, if present,
@@ -576,13 +558,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", NULL));
}
- SkPdfDictionary* U() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* U() const;
/** (Optional; PDF 1.2; widget annotations only) An action to be performed when the
* annotation receives the input focus.
**/
@@ -590,13 +566,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fo", "", NULL));
}
- SkPdfDictionary* Fo() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fo", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Fo() const;
/** (Optional; PDF 1.2; widget annotations only) (Uppercase B, lowercase L) An action to
* be performed when the annotation loses the input focus. (The name Bl stands for
* "blurred.")
@@ -605,13 +575,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bl", "", NULL));
}
- SkPdfDictionary* Bl() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bl", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Bl() const;
};
#endif // __DEFINED__SkPdfAnnotationActionsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..0e29966
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.cpp
@@ -0,0 +1,135 @@
+#include "SkPdfAnnotationDictionary_autogen.h"
+
+std::string SkPdfAnnotationDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfAnnotationDictionary::P() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkRect* SkPdfAnnotationDictionary::Rect() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rect", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDate SkPdfAnnotationDictionary::getMAsDate() const {
+ SkPdfDate ret = SkPdfDate();
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
+std::string SkPdfAnnotationDictionary::getMAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfAnnotationDictionary::F() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfDictionary* SkPdfAnnotationDictionary::BS() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfAnnotationDictionary::Border() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Border", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationDictionary::AP() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfAnnotationDictionary::AS() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfAnnotationDictionary::C() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+double SkPdfAnnotationDictionary::CA() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfAnnotationDictionary::T() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfAnnotationDictionary::Popup() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Popup", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationDictionary::A() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationDictionary::AA() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfAnnotationDictionary::StructParent() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.h
index 5276f64..9b7f08a 100644
--- a/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The type of annotation that this dictionary describes; see Table
* 8.14 on page 499 for specific values.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required or optional, depending on the annotation type) Text to be displayed
* for the annotation or, if this type of annotation does not display text, an al-
* ternate description of the annotation's contents in human-readable form. In
@@ -564,13 +552,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Optional; PDF 1.3; not used in FDF files) An indirect reference to the page
* object with which this annotation is associated.
**/
@@ -578,13 +560,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", NULL));
}
- SkPdfDictionary* P() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* P() const;
/** (Required) The annotation rectangle, defining the location of the annotation
* on the page in default user space units.
**/
@@ -592,13 +568,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rect", "", NULL));
}
- SkRect* Rect() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rect", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* Rect() const;
/** (Optional; PDF 1.4) The annotation name, a text string uniquely identifying
* it among all the annotations on its page.
**/
@@ -621,26 +591,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfDate getMAsDate() const {
- SkPdfDate ret = SkPdfDate();
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate getMAsDate() const;
bool isMAString() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getMAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getMAsString() const;
/** (Optional; PDF 1.1) A set of flags specifying various characteristics of the an-
* notation (see Section 8.4.2, "Annotation Flags"). Default value: 0.
**/
@@ -648,13 +606,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- long F() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long F() const;
/** (Optional; PDF 1.2) A border style dictionary specifying the characteristics of
* the annotation's border (see Section 8.4.3, "Border Styles"; see also imple-
* mentation note 60 in Appendix H).
@@ -666,13 +618,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", NULL));
}
- SkPdfDictionary* BS() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* BS() const;
/** (Optional) An array specifying the characteristics of the annotation's border.
* The border is specified as a "rounded rectangle."
* In PDF 1.0, the array consists of three numbers defining the horizontal cor-
@@ -700,13 +646,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Border", "", NULL));
}
- SkPdfArray* Border() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Border", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Border() const;
/** (Optional; PDF 1.2) An appearance dictionary specifying how the annotation
* is presented visually on the page (see Section 8.4.4, "Appearance Streams";
* see also implementation note 60 in Appendix H).
@@ -715,13 +655,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", NULL));
}
- SkPdfDictionary* AP() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* AP() const;
/** (Required if the appearance dictionary AP contains one or more subdictionaries;
* PDF 1.2) The annotation's appearance state, which selects the applicable
* appearance stream from an appearance subdictionary (see Section 8.4.4,
@@ -731,13 +665,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AS", "", NULL));
}
- std::string AS() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string AS() const;
/** (Optional; PDF 1.1) An array of three numbers in the range 0.0 to 1.0, repre-
* senting the components of a color in the DeviceRGB color space. This color
* will be used for the following purposes:
@@ -749,13 +677,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
}
- SkPdfArray* C() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* C() const;
/** (Optional; PDF 1.4) The constant opacity value to be used in painting the
* annotation (see Sections 7.1, "Overview of Transparency," and 7.2.6, "Shape
* and Opacity Computations"). This value applies to all visible elements of
@@ -777,13 +699,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", NULL));
}
- double CA() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double CA() const;
/** (Optional; PDF 1.1) The text label to be displayed in the title bar of the anno-
* tation's pop-up window when open and active.
**/
@@ -791,13 +707,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
}
- std::string T() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string T() const;
/** (Optional; PDF 1.3) An indirect reference to a pop-up annotation for enter-
* ing or editing the text associated with this annotation.
**/
@@ -805,13 +715,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Popup", "", NULL));
}
- SkPdfDictionary* Popup() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Popup", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Popup() const;
/** (Optional; PDF 1.1) An action to be performed when the annotation is acti-
* vated (see Section 8.5, "Actions").
* Note: This entry is not permitted in link annotations if a Dest entry is present
@@ -822,13 +726,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", NULL));
}
- SkPdfDictionary* A() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* A() const;
/** (Optional; PDF 1.2) An additional-actions dictionary defining the anno-
* tation's behavior in response to various trigger events (see Section 8.5.2,
* "Trigger Events"). At the time of publication, this entry is used only by wid-
@@ -838,13 +736,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", NULL));
}
- SkPdfDictionary* AA() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* AA() const;
/** (Required if the annotation is a structural content item; PDF 1.3) The integer
* key of the annotation's entry in the structural parent tree (see "Finding Struc-
* ture Elements from Content Items" on page 600).
@@ -853,13 +745,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", NULL));
}
- long StructParent() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long StructParent() const;
};
#endif // __DEFINED__SkPdfAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.cpp
new file mode 100644
index 0000000..96b6b4e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.cpp
@@ -0,0 +1,79 @@
+#include "SkPdfAppearanceCharacteristicsDictionary_autogen.h"
+
+long SkPdfAppearanceCharacteristicsDictionary::R() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfAppearanceCharacteristicsDictionary::BC() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfAppearanceCharacteristicsDictionary::BG() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfAppearanceCharacteristicsDictionary::CA() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfAppearanceCharacteristicsDictionary::RC() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RC", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfAppearanceCharacteristicsDictionary::AC() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AC", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfAppearanceCharacteristicsDictionary::I() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfAppearanceCharacteristicsDictionary::RI() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfAppearanceCharacteristicsDictionary::IX() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IX", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfAppearanceCharacteristicsDictionary::IF() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfAppearanceCharacteristicsDictionary::TP() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TP", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.h
index 75a0038..a3814a6 100644
--- a/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", NULL));
}
- long R() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long R() const;
/** (Optional) An array of numbers in the range 0.0 to 1.0 specifying the color of the
* widget annotation's border. The number of array elements determines the color
* space in which the color is defined:
@@ -552,13 +546,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", NULL));
}
- SkPdfArray* BC() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* BC() const;
/** (Optional) An array of numbers in the range 0.0 to 1.0 specifying the color of the
* widget annotation's background. The number of array elements determines the
* color space, as described above for BC.
@@ -567,13 +555,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", NULL));
}
- SkPdfArray* BG() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* BG() const;
/** (Optional; button fields only) The widget annotation's normal caption, displayed
* when it is not interacting with the user.
* Note: Unlike the remaining entries listed below, which apply only to widget annota-
@@ -585,13 +567,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", NULL));
}
- std::string CA() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string CA() const;
/** (Optional; pushbutton fields only) The widget annotation's rollover caption, dis-
* played when the user rolls the cursor into its active area without pressing the
* mouse button.
@@ -600,13 +576,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RC", "", NULL));
}
- std::string RC() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RC", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string RC() const;
/** (Optional; pushbutton fields only) The widget annotation's alternate (down)
* caption, displayed when the mouse button is pressed within its active area.
**/
@@ -614,13 +584,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AC", "", NULL));
}
- std::string AC() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AC", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string AC() const;
/** (Optional; pushbutton fields only; must be an indirect reference) A form XObject
* defining the widget annotation's normal icon, displayed when it is not inter-
* acting with the user.
@@ -629,13 +593,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", NULL));
}
- SkPdfStream* I() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* I() const;
/** (Optional; pushbutton fields only; must be an indirect reference) A form XObject
* defining the widget annotation's rollover icon, displayed when the user rolls the
* cursor into its active area without pressing the mouse button.
@@ -644,13 +602,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", NULL));
}
- SkPdfStream* RI() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* RI() const;
/** (Optional; pushbutton fields only; must be an indirect reference) A form XObject
* defining the widget annotation's alternate (down) icon, displayed when the
* mouse button is pressed within its active area.
@@ -659,13 +611,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IX", "", NULL));
}
- SkPdfStream* IX() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IX", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* IX() const;
/** (Optional; pushbutton fields only) An icon fit dictionary (see Table 8.73 on page
* 566) specifying how to display the widget annotation's icon within its
* annotation rectangle. If present, the icon fit dictionary applies to all of the anno-
@@ -675,13 +621,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", NULL));
}
- SkPdfDictionary* IF() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* IF() const;
/** (Optional; pushbutton fields only) A code indicating where to position the text of
* the widget annotation's caption relative to its icon:
* 0 No icon; caption only
@@ -697,13 +637,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TP", "", NULL));
}
- long TP() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TP", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long TP() const;
};
#endif // __DEFINED__SkPdfAppearanceCharacteristicsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.cpp
new file mode 100644
index 0000000..54ba878
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfAppearanceDictionary_autogen.h"
+
+SkPdfStream* SkPdfAppearanceDictionary::getNAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfAppearanceDictionary::getNAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfAppearanceDictionary::getRAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfAppearanceDictionary::getRAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfAppearanceDictionary::getDAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfAppearanceDictionary::getDAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.h
index 1554916..3e8782b 100644
--- a/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.h
@@ -537,26 +537,14 @@
return ret->podofo()->HasStream();
}
- SkPdfStream* getNAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getNAsStream() const;
bool isNADictionary() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getNAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getNAsDictionary() const;
/** (Optional) The annotation's rollover appearance. Default value: the value of
* the N entry.
**/
@@ -570,26 +558,14 @@
return ret->podofo()->HasStream();
}
- SkPdfStream* getRAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getRAsStream() const;
bool isRADictionary() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getRAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getRAsDictionary() const;
/** (Optional) The annotation's down appearance. Default value: the value of the
* N entry.
**/
@@ -603,26 +579,14 @@
return ret->podofo()->HasStream();
}
- SkPdfStream* getDAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getDAsStream() const;
bool isDADictionary() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getDAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getDAsDictionary() const;
};
#endif // __DEFINED__SkPdfAppearanceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.cpp
new file mode 100644
index 0000000..ff3a3a1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfApplicationDataDictionary_autogen.h"
+
+SkPdfDate SkPdfApplicationDataDictionary::LastModified() const {
+ SkPdfDate ret;
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
+SkPdfObject* SkPdfApplicationDataDictionary::Private() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Private", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.h
index 4bf61d8..e82ecc3 100644
--- a/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", NULL));
}
- SkPdfDate LastModified() const {
- SkPdfDate ret;
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate LastModified() const;
/** (Optional) Any private data appropriate to the application, typically
* in the form of a dictionary.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Private", "", NULL));
}
- SkPdfObject* Private() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Private", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* Private() const;
};
#endif // __DEFINED__SkPdfApplicationDataDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfArray_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfArray_autogen.cpp
new file mode 100644
index 0000000..fd25276
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfArray_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfArray_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.cpp
new file mode 100644
index 0000000..bac501d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfArtifactsDictionary_autogen.h"
+
+std::string SkPdfArtifactsDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkRect* SkPdfArtifactsDictionary::BBox() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfArtifactsDictionary::Attached() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Attached", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.h
index 9cae252..d63a649 100644
--- a/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Optional) An array of four numbers in default user space units giving the coor-
* dinates of the left, bottom, right, and top edges, respectively, of the artifact's
* bounding box (the rectangle that completely encloses its visible extent).
@@ -547,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", NULL));
}
- SkRect* BBox() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* BBox() const;
/** (Optional; pagination artifacts only) An array of name objects containing one to
* four of the names Top, Bottom, Left, and Right, specifying the edges of the page, if
* any, to which the artifact is logically attached. Page edges are defined by the
@@ -565,13 +553,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Attached", "", NULL));
}
- SkPdfArray* Attached() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Attached", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Attached() const;
};
#endif // __DEFINED__SkPdfArtifactsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.cpp
new file mode 100644
index 0000000..7810f46
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfAttributeObjectDictionary_autogen.h"
+
+std::string SkPdfAttributeObjectDictionary::O() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.h
index d389fc4..6c07fa8 100644
--- a/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", NULL));
}
- std::string O() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string O() const;
};
#endif // __DEFINED__SkPdfAttributeObjectDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.cpp
new file mode 100644
index 0000000..69c6b07
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfBeadDictionary_autogen.h"
+
+std::string SkPdfBeadDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfBeadDictionary::T() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfBeadDictionary::N() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfBeadDictionary::V() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfBeadDictionary::P() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkRect* SkPdfBeadDictionary::R() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.h
index 4b479c0..24611f7 100644
--- a/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required for the first bead of a thread; optional for all others; must be an indirect refer-
* ence) The thread to which this bead belongs.
* Note: In PDF 1.1, this entry is permitted only for the first bead of a thread. In PDF 1.2
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
}
- SkPdfDictionary* T() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* T() const;
/** (Required; must be an indirect reference) The next bead in the thread. In the last bead,
* this entry points to the first.
**/
@@ -562,13 +550,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", NULL));
}
- SkPdfDictionary* N() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* N() const;
/** (Required; must be an indirect reference) The previous bead in the thread. In the first
* bead, this entry points to the last.
**/
@@ -576,13 +558,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
}
- SkPdfDictionary* V() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* V() const;
/** (Required; must be an indirect reference) The page object representing the page on
* which this bead appears.
**/
@@ -590,26 +566,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", NULL));
}
- SkPdfDictionary* P() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* P() const;
/** (Required) A rectangle specifying the location of this bead on the page.
**/
bool has_R() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", NULL));
}
- SkRect* R() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* R() const;
};
#endif // __DEFINED__SkPdfBeadDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.cpp
new file mode 100644
index 0000000..720eaca
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.cpp
@@ -0,0 +1,93 @@
+#include "SkPdfBlockLevelStructureElementsDictionary_autogen.h"
+
+double SkPdfBlockLevelStructureElementsDictionary::SpaceBefore() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceBefore", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfBlockLevelStructureElementsDictionary::SpaceAfter() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceAfter", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfBlockLevelStructureElementsDictionary::StartIndent() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StartIndent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfBlockLevelStructureElementsDictionary::EndIndent() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndIndent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfBlockLevelStructureElementsDictionary::TextIndent() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextIndent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfBlockLevelStructureElementsDictionary::TextAlign() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextAlign", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkRect* SkPdfBlockLevelStructureElementsDictionary::BBox() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+double SkPdfBlockLevelStructureElementsDictionary::getWidthAsNumber() const {
+ double ret = 0;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfBlockLevelStructureElementsDictionary::getWidthAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+double SkPdfBlockLevelStructureElementsDictionary::getHeightAsNumber() const {
+ double ret = 0;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfBlockLevelStructureElementsDictionary::getHeightAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfBlockLevelStructureElementsDictionary::BlockAlign() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlockAlign", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfBlockLevelStructureElementsDictionary::InlineAlign() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InlineAlign", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.h
index 88dd0c7..777911a 100644
--- a/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.h
@@ -538,13 +538,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceBefore", "", NULL));
}
- double SpaceBefore() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceBefore", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double SpaceBefore() const;
/** (Optional) The amount of extra space following the after edge of the BLSE,
* measured in default user space units in the block-progression direction. This
* value is added to any adjustments induced by the LineHeight attributes of
@@ -558,13 +552,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceAfter", "", NULL));
}
- double SpaceAfter() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceAfter", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double SpaceAfter() const;
/** (Optional) The distance from the start edge of the reference area to that of the
* BLSE, measured in default user space units in the inline-progression direc-
* tion. This attribute applies only to structure elements with a Placement
@@ -584,13 +572,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StartIndent", "", NULL));
}
- double StartIndent() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StartIndent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double StartIndent() const;
/** (Optional) The distance from the end edge of the BLSE to that of the ref-
* erence area, measured in default user space units in the inline-progression
* direction. This attribute applies only to structure elements with a Placement
@@ -608,13 +590,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndIndent", "", NULL));
}
- double EndIndent() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndIndent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double EndIndent() const;
/** (Optional; applies only to some BLSEs, as described below) The additional
* distance, measured in default user space units in the inline-progression
* direction, from the start edge of the BLSE, as specified by StartIndent
@@ -628,13 +604,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextIndent", "", NULL));
}
- double TextIndent() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextIndent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double TextIndent() const;
/** (Optional; applies only to BLSEs containing text) The alignment, in the inline-
* progression direction, of text and other content within lines of the BLSE:
* Start Aligned with the start edge.
@@ -650,13 +620,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextAlign", "", NULL));
}
- std::string TextAlign() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextAlign", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string TextAlign() const;
/** (Illustrations and tables only; required if the element appears in its entirety on a
* single page) An array of four numbers in default user space units giving the
* coordinates of the left, bottom, right, and top edges, respectively, of the ele-
@@ -668,13 +632,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", NULL));
}
- SkRect* BBox() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* BBox() const;
/** (Optional; illustrations, tables, table headers, and table cells only; strongly
* recommended for table cells) The desired width of the element's content
* rectangle (see "Content and Allocation Rectangles" on page 648), measured
@@ -695,26 +653,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Real || ret->podofo()->GetDataType() == ePdfDataType_Number;
}
- double getWidthAsNumber() const {
- double ret = 0;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double getWidthAsNumber() const;
bool isWidthAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getWidthAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getWidthAsName() const;
/** (Optional; illustrations, tables, table headers, and table cells only) The desired
* height of the element's content rectangle (see "Content and Allocation
* Rectangles" on page 648), measured in default user space units in the block-
@@ -734,26 +680,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Real || ret->podofo()->GetDataType() == ePdfDataType_Number;
}
- double getHeightAsNumber() const {
- double ret = 0;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double getHeightAsNumber() const;
bool isHeightAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getHeightAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getHeightAsName() const;
/** (Optional; table cells only) The alignment, in the block-progression direction,
* of content within the table cell:
* Before Before edge of the first child's allocation rectangle aligned
@@ -780,13 +714,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlockAlign", "", NULL));
}
- std::string BlockAlign() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlockAlign", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string BlockAlign() const;
/** (Optional; table cells only) The alignment, in the inline-progression direction,
* of content within the table cell:
* Start Start edge of each child's allocation rectangle aligned with
@@ -807,13 +735,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InlineAlign", "", NULL));
}
- std::string InlineAlign() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InlineAlign", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string InlineAlign() const;
};
#endif // __DEFINED__SkPdfBlockLevelStructureElementsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfBoolean_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfBoolean_autogen.cpp
new file mode 100644
index 0000000..1528b04
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfBoolean_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfBoolean_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.cpp
new file mode 100644
index 0000000..f26588a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfBorderStyleDictionary_autogen.h"
+
+std::string SkPdfBorderStyleDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+double SkPdfBorderStyleDictionary::W() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfBorderStyleDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfBorderStyleDictionary::D() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.h
index 5513a0e..e4d66b9 100644
--- a/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Optional) The border width in points. If this value is 0, no border is drawn. Default
* value: 1.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", NULL));
}
- double W() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double W() const;
/** (Optional) The border style:
* S (Solid) A solid rectangle surrounding the annotation.
* D (Dashed) A dashed rectangle surrounding the annotation. The dash pattern
@@ -569,13 +557,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Optional) A dash array defining a pattern of dashes and gaps to be used in drawing a
* dashed border (border style D above). The dash array is specified in the same format
* as in the line dash pattern parameter of the graphics state (see "Line Dash Pattern" on
@@ -587,13 +569,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", NULL));
}
- SkPdfArray* D() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* D() const;
};
#endif // __DEFINED__SkPdfBorderStyleDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.cpp
new file mode 100644
index 0000000..7ce6524
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfBoxColorInformationDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfBoxColorInformationDictionary::CropBox() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfBoxColorInformationDictionary::BleedBox() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfBoxColorInformationDictionary::TrimBox() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfBoxColorInformationDictionary::ArtBox() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.h
index c50cfea..bd28198 100644
--- a/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", NULL));
}
- SkPdfDictionary* CropBox() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* CropBox() const;
/** (Optional) A box style dictionary (see Table 9.42) specifying the visual characteris-
* tics for displaying guidelines for the page's bleed box. This entry is ignored if no
* bleed box is defined in the page object.
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", NULL));
}
- SkPdfDictionary* BleedBox() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* BleedBox() const;
/** (Optional) A box style dictionary (see Table 9.42) specifying the visual characteris-
* tics for displaying guidelines for the page's trim box. This entry is ignored if no trim
* box is defined in the page object.
@@ -563,13 +551,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", NULL));
}
- SkPdfDictionary* TrimBox() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* TrimBox() const;
/** (Optional) A box style dictionary (see Table 9.42) specifying the visual characteris-
* tics for displaying guidelines for the page's art box. This entry is ignored if no art
* box is defined in the page object.
@@ -578,13 +560,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", NULL));
}
- SkPdfDictionary* ArtBox() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* ArtBox() const;
};
#endif // __DEFINED__SkPdfBoxColorInformationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.cpp
new file mode 100644
index 0000000..d2dccef
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfBoxStyleDictionary_autogen.h"
+
+SkPdfArray* SkPdfBoxStyleDictionary::C() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+double SkPdfBoxStyleDictionary::W() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfBoxStyleDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfBoxStyleDictionary::D() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.h
index d68b868..92d2b5a 100644
--- a/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.h
@@ -533,26 +533,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
}
- SkPdfArray* C() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* C() const;
/** (Optional) The guideline width in default user space units. Default value: 1.
**/
bool has_W() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", NULL));
}
- double W() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double W() const;
/** (Optional) The guideline style:
* S (Solid) A solid rectangle.
* D (Dashed) A dashed rectangle. The dash pattern is specified by the D entry
@@ -563,13 +551,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Optional) A dash array defining a pattern of dashes and gaps to be used in drawing
* dashed guidelines (guideline style D above). The dash array is specified in default
* user space units, in the same format as in the line dash pattern parameter of the
@@ -581,13 +563,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", NULL));
}
- SkPdfArray* D() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* D() const;
};
#endif // __DEFINED__SkPdfBoxStyleDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.cpp
new file mode 100644
index 0000000..56ece28
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfCIDFontDescriptorDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfCIDFontDescriptorDictionary::Style() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Style", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfCIDFontDescriptorDictionary::Lang() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfCIDFontDescriptorDictionary::FD() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FD", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfCIDFontDescriptorDictionary::CIDSet() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSet", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.h
index 4693429..f544eaa 100644
--- a/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Style", "", NULL));
}
- SkPdfDictionary* Style() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Style", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Style() const;
/** (Optional) A name specifying the language of the font, used for encodings where
* the language is not implied by the encoding itself. The possible values are the
* 2-character language codes defined by ISO 639-for example, en for English and ja
@@ -549,13 +543,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", NULL));
}
- std::string Lang() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Lang() const;
/** (Optional) A dictionary whose keys identify a class of characters in a CIDFont.
* Each value is a dictionary containing entries that override the corresponding
* values in the main font descriptor dictionary for that class of characters (see "FD,"
@@ -565,13 +553,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FD", "", NULL));
}
- SkPdfDictionary* FD() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FD", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* FD() const;
/** (Optional) A stream identifying which CIDs are present in the CIDFont file. If this
* entry is present, the CIDFont contains only a subset of the glyphs in the character
* collection defined by the CIDSystemInfo dictionary. If it is absent, the only indica-
@@ -585,13 +567,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSet", "", NULL));
}
- SkPdfStream* CIDSet() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSet", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* CIDSet() const;
};
#endif // __DEFINED__SkPdfCIDFontDescriptorDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.cpp
new file mode 100644
index 0000000..069a631
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.cpp
@@ -0,0 +1,79 @@
+#include "SkPdfCIDFontDictionary_autogen.h"
+
+std::string SkPdfCIDFontDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfCIDFontDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfCIDFontDictionary::BaseFont() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfCIDFontDictionary::CIDSystemInfo() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfCIDFontDictionary::FontDescriptor() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfCIDFontDictionary::DW() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfCIDFontDictionary::W() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfCIDFontDictionary::DW2() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfCIDFontDictionary::W2() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfCIDFontDictionary::getCIDToGIDMapAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfCIDFontDictionary::getCIDToGIDMapAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.h
index c213bad..1ebc2ee 100644
--- a/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.h
@@ -49,26 +49,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The type of CIDFont; CIDFontType0 or CIDFontType2.
**/
bool has_Subtype() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) The PostScript name of the CIDFont. For Type 0 CIDFonts, this
* is usually the value of the CIDFontName entry in the CIDFont program. For
* Type 2 CIDFonts, it is derived the same way as for a simple TrueType font;
@@ -79,13 +67,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", NULL));
}
- std::string BaseFont() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string BaseFont() const;
/** (Required) A dictionary containing entries that define the character collec-
* tion of the CIDFont. See Table 5.12 on page 337.
**/
@@ -93,13 +75,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", NULL));
}
- SkPdfDictionary* CIDSystemInfo() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* CIDSystemInfo() const;
/** (Required; must be an indirect reference) A font descriptor describing the
* CIDFont's default metrics other than its glyph widths (see Section 5.7,
* "Font Descriptors").
@@ -108,13 +84,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", NULL));
}
- SkPdfDictionary* FontDescriptor() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* FontDescriptor() const;
/** (Optional) The default width for glyphs in the CIDFont (see "Glyph Met-
* rics in CIDFonts" on page 340). Default value: 1000.
**/
@@ -122,13 +92,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW", "", NULL));
}
- long DW() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long DW() const;
/** (Optional) A description of the widths for the glyphs in the CIDFont. The
* array's elements have a variable format that can specify individual widths
* for consecutive CIDs or one width for a range of CIDs (see "Glyph Metrics
@@ -139,13 +103,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", NULL));
}
- SkPdfArray* W() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* W() const;
/** (Optional; applies only to CIDFonts used for vertical writing) An array of two
* numbers specifying the default metrics for vertical writing (see "Glyph
* Metrics in CIDFonts" on page 340). Default value: [880 -1000].
@@ -154,13 +112,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW2", "", NULL));
}
- SkPdfArray* DW2() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* DW2() const;
/** (Optional; applies only to CIDFonts used for vertical writing) A description of
* the metrics for vertical writing for the glyphs in the CIDFont (see "Glyph
* Metrics in CIDFonts" on page 340). Default value: none (the DW2 value is
@@ -170,13 +122,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W2", "", NULL));
}
- SkPdfArray* W2() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* W2() const;
/** (Optional; Type 2 CIDFonts only) A specification of the mapping from CIDs
* to glyph indices. If the value is a stream, the bytes in the stream contain the
* mapping from CIDs to glyph indices: the glyph index for a particular CID
@@ -197,26 +143,14 @@
return ret->podofo()->HasStream();
}
- SkPdfStream* getCIDToGIDMapAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getCIDToGIDMapAsStream() const;
bool isCIDToGIDMapAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getCIDToGIDMapAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getCIDToGIDMapAsName() const;
};
#endif // __DEFINED__SkPdfCIDFontDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.cpp
new file mode 100644
index 0000000..37223f1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfCIDSystemInfoDictionary_autogen.h"
+
+std::string SkPdfCIDSystemInfoDictionary::Registry() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Registry", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfCIDSystemInfoDictionary::Ordering() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ordering", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfCIDSystemInfoDictionary::Supplement() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Supplement", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.h
index a23f106..9dfcb72 100644
--- a/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.h
@@ -534,13 +534,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Registry", "", NULL));
}
- std::string Registry() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Registry", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Registry() const;
/** (Required) A string that uniquely names the character collection within the speci-
* fied registry-for example, Japan1.
**/
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ordering", "", NULL));
}
- std::string Ordering() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ordering", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Ordering() const;
/** (Required) The supplement number of the character collection. An original charac-
* ter collection has a supplement number of 0. Whenever additional CIDs are
* assigned in a character collection, the supplement number is increased. Supple-
@@ -565,13 +553,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Supplement", "", NULL));
}
- long Supplement() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Supplement", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Supplement() const;
};
#endif // __DEFINED__SkPdfCIDSystemInfoDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.cpp
new file mode 100644
index 0000000..203dca4
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfCMapDictionary_autogen.h"
+
+std::string SkPdfCMapDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfCMapDictionary::CMapName() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CMapName", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfCMapDictionary::getCIDSystemInfoAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfCMapDictionary::getCIDSystemInfoAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfCMapDictionary::WMode() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WMode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfCMapDictionary::getUseCMapAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfCMapDictionary::getUseCMapAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.h
index 98d95f4..4f4538b 100644
--- a/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The PostScript name of the CMap. This should be the same as the
* value of CMapName in the CMap file itself.
**/
@@ -547,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CMapName", "", NULL));
}
- std::string CMapName() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CMapName", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string CMapName() const;
/** (Required) A dictionary or array containing entries that define the character
* collection for the CIDFont or CIDFonts associated with the CMap. If the
* CMap selects only font number 0 and specifies character selectors that are
@@ -580,26 +568,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getCIDSystemInfoAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getCIDSystemInfoAsDictionary() const;
bool isCIDSystemInfoAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getCIDSystemInfoAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getCIDSystemInfoAsArray() const;
/** (Optional) A code that determines the writing mode for any CIDFont with
* which this CMap is combined:
* 0 Horizontal
@@ -612,13 +588,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WMode", "", NULL));
}
- long WMode() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WMode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long WMode() const;
/** (Optional) The name of a predefined CMap, or a stream containing a CMap,
* that is to be used as the base for this CMap. This allows the CMap to be de-
* fined differentially, specifying only the character mappings that differ from
@@ -634,26 +604,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getUseCMapAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getUseCMapAsName() const;
bool isUseCMapAStream() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return false;
return ret->podofo()->HasStream();
}
- SkPdfStream* getUseCMapAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getUseCMapAsStream() const;
};
#endif // __DEFINED__SkPdfCMapDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.cpp
new file mode 100644
index 0000000..72e9cc7
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfCalgrayColorSpaceDictionary_autogen.h"
+
+SkPdfArray* SkPdfCalgrayColorSpaceDictionary::WhitePoint() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfCalgrayColorSpaceDictionary::BlackPoint() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+double SkPdfCalgrayColorSpaceDictionary::Gamma() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.h
index e7b79e1..635ba2e 100644
--- a/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.h
@@ -534,13 +534,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", NULL));
}
- SkPdfArray* WhitePoint() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* WhitePoint() const;
/** (Optional) An array of three numbers [ XB YB ZB ] specifying the tristimulus
* value, in the CIE 1931 XYZ space, of the diffuse black point; see "CalRGB
* Color Spaces," below, for further discussion. All three of these numbers must
@@ -550,13 +544,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", NULL));
}
- SkPdfArray* BlackPoint() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* BlackPoint() const;
/** (Optional) A number G defining the gamma for the gray (A) component. G
* must be positive and will generally be greater than or equal to 1. Default
* value: 1.
@@ -565,13 +553,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", NULL));
}
- double Gamma() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double Gamma() const;
};
#endif // __DEFINED__SkPdfCalgrayColorSpaceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.cpp
new file mode 100644
index 0000000..f2faeaf
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfCalrgbColorSpaceDictionary_autogen.h"
+
+SkPdfArray* SkPdfCalrgbColorSpaceDictionary::WhitePoint() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfCalrgbColorSpaceDictionary::BlackPoint() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfCalrgbColorSpaceDictionary::Gamma() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfCalrgbColorSpaceDictionary::Matrix() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.h
index b3b5a3d..500fad6 100644
--- a/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", NULL));
}
- SkPdfArray* WhitePoint() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* WhitePoint() const;
/** (Optional) An array of three numbers [ XB YB ZB ] specifying the tristimulus value, in
* the CIE 1931 XYZ space, of the diffuse black point; see below for further discussion.
* All three of these numbers must be nonnegative. Default value: [0.0 0.0 0.0].
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", NULL));
}
- SkPdfArray* BlackPoint() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* BlackPoint() const;
/** (Optional) An array of three numbers [ GR GG GB ] specifying the gamma for the red,
* green, and blue (A, B, and C) components of the color space. Default value:
* [1.0 1.0 1.0].
@@ -563,13 +551,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", NULL));
}
- SkPdfArray* Gamma() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Gamma() const;
/** (Optional) An array of nine numbers [ XA YA ZA XB YB ZB XC YC ZC ] specifying
* the linear interpretation of the decoded A, B, and C components of the color space
* with respect to the final XYZ representation. Default value: the identity matrix
@@ -579,13 +561,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", NULL));
}
- SkPdfArray* Matrix() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Matrix() const;
};
#endif // __DEFINED__SkPdfCalrgbColorSpaceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.cpp
new file mode 100644
index 0000000..bbe7861
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.cpp
@@ -0,0 +1,163 @@
+#include "SkPdfCatalogDictionary_autogen.h"
+
+std::string SkPdfCatalogDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfCatalogDictionary::Version() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::Pages() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+double SkPdfCatalogDictionary::getPageLabelsAsNumber() const {
+ double ret = 0;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfTree* SkPdfCatalogDictionary::getPageLabelsAsTree() const {
+ SkPdfTree* ret = NULL;
+ if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::Names() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::Dests() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::ViewerPreferences() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewerPreferences", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfCatalogDictionary::PageLayout() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLayout", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfCatalogDictionary::PageMode() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageMode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::Outlines() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Outlines", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfCatalogDictionary::Threads() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Threads", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfCatalogDictionary::getOpenActionAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::getOpenActionAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::AA() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::URI() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::AcroForm() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AcroForm", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfCatalogDictionary::Metadata() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::StructTreeRoot() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructTreeRoot", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::MarkInfo() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkInfo", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfCatalogDictionary::Lang() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::SpiderInfo() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpiderInfo", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfCatalogDictionary::OutputIntents() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputIntents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.h
index 021f118..f98e413 100644
--- a/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Optional; PDF 1.4) The version of the PDF specification to which the
* document conforms (for example, 1.4), if later than the version specified
* in the file's header (see Section 3.4.1, "File Header"). If the header speci-
@@ -555,13 +549,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", NULL));
}
- std::string Version() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Version() const;
/** (Required; must be an indirect reference) The page tree node that is the
* root of the document's page tree (see Section 3.6.2, "Page Tree").
**/
@@ -569,13 +557,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", NULL));
}
- SkPdfDictionary* Pages() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Pages() const;
/** (Optional; PDF 1.3) A number tree (see Section 3.8.5, "Number Trees")
* defining the page labeling for the document. The keys in this tree are
* page indices; the corresponding values are page label dictionaries (see
@@ -593,26 +575,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Real || ret->podofo()->GetDataType() == ePdfDataType_Number;
}
- double getPageLabelsAsNumber() const {
- double ret = 0;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double getPageLabelsAsNumber() const;
bool isPageLabelsATree() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfTree* getPageLabelsAsTree() const {
- SkPdfTree* ret = NULL;
- if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfTree* getPageLabelsAsTree() const;
/** (Optional; PDF 1.2) The document's name dictionary (see Section 3.6.3,
* "Name Dictionary").
**/
@@ -620,13 +590,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", NULL));
}
- SkPdfDictionary* Names() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Names() const;
/** (Optional; PDF 1.1; must be an indirect reference) A dictionary of names
* and corresponding destinations (see "Named Destinations" on page
* 476).
@@ -635,13 +599,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", NULL));
}
- SkPdfDictionary* Dests() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Dests() const;
/** (Optional; PDF 1.2) A viewer preferences dictionary (see Section 8.1,
* "Viewer Preferences") specifying the way the document is to be dis-
* played on the screen. If this entry is absent, viewer applications should
@@ -651,13 +609,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewerPreferences", "", NULL));
}
- SkPdfDictionary* ViewerPreferences() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewerPreferences", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* ViewerPreferences() const;
/** (Optional) A name object specifying the page layout to be used when the
* document is opened:
* SinglePage Display one page at a time.
@@ -672,13 +624,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLayout", "", NULL));
}
- std::string PageLayout() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLayout", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string PageLayout() const;
/** (Optional) A name object specifying how the document should be dis-
* played when opened:
* UseNone Neither document outline nor thumbnail im-
@@ -693,13 +639,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageMode", "", NULL));
}
- std::string PageMode() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageMode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string PageMode() const;
/** (Optional; must be an indirect reference) The outline dictionary that is the
* root of the document's outline hierarchy (see Section 8.2.2, "Document
* Outline").
@@ -708,13 +648,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Outlines", "", NULL));
}
- SkPdfDictionary* Outlines() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Outlines", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Outlines() const;
/** (Optional; PDF 1.1; must be an indirect reference) An array of thread
* dictionaries representing the document's article threads (see Section
* 8.3.2, "Articles").
@@ -723,13 +657,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Threads", "", NULL));
}
- SkPdfArray* Threads() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Threads", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Threads() const;
/** (Optional; PDF 1.1) A value specifying a destination to be displayed or
* an action to be performed when the document is opened. The value is
* either an array defining a destination (see Section 8.2.1, "Destinations")
@@ -747,26 +675,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getOpenActionAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getOpenActionAsArray() const;
bool isOpenActionADictionary() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getOpenActionAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getOpenActionAsDictionary() const;
/** (Optional; PDF 1.4) An additional-actions dictionary defining the actions
* to be taken in response to various trigger events affecting the document
* as a whole (see "Trigger Events" on page 514). (See also implementation
@@ -776,13 +692,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", NULL));
}
- SkPdfDictionary* AA() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* AA() const;
/** (Optional) A URI dictionary containing document-level information for
* URI (uniform resource identifier) actions (see "URI Actions" on page
* 523).
@@ -791,13 +701,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", NULL));
}
- SkPdfDictionary* URI() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* URI() const;
/** (Optional; PDF 1.2) The document's interactive form (AcroForm) dic-
* tionary (see Section 8.6.1, "Interactive Form Dictionary").
**/
@@ -805,13 +709,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AcroForm", "", NULL));
}
- SkPdfDictionary* AcroForm() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AcroForm", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* AcroForm() const;
/** (Optional; PDF 1.4; must be an indirect reference) A metadata stream
* containing metadata for the document (see Section 9.2.2, "Metadata
* Streams").
@@ -820,13 +718,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
}
- SkPdfStream* Metadata() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Metadata() const;
/** (Optional; PDF 1.3) The document's structure tree root dictionary (see
* Section 9.6.1, "Structure Hierarchy").
**/
@@ -834,13 +726,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructTreeRoot", "", NULL));
}
- SkPdfDictionary* StructTreeRoot() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructTreeRoot", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* StructTreeRoot() const;
/** (Optional; PDF 1.4) A mark information dictionary containing informa-
* tion about the document's usage of Tagged PDF conventions (see Sec-
* tion 9.7.1, "Mark Information Dictionary").
@@ -849,13 +735,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkInfo", "", NULL));
}
- SkPdfDictionary* MarkInfo() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkInfo", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* MarkInfo() const;
/** (Optional; PDF 1.4) A language identifier specifying the natural language
* for all text in the document except where overridden by language speci-
* fications for structure elements or marked content (see Section 9.8.1,
@@ -866,13 +746,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", NULL));
}
- std::string Lang() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Lang() const;
/** (Optional; PDF 1.3) A Web Capture information dictionary containing
* state information used by the Acrobat Web Capture (AcroSpider) plug-
* in extension (see Section 9.9.1, "Web Capture Information Dictionary").
@@ -881,13 +755,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpiderInfo", "", NULL));
}
- SkPdfDictionary* SpiderInfo() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpiderInfo", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* SpiderInfo() const;
/** (Optional; PDF 1.4) An array of output intent dictionaries describing the
* color characteristics of output devices on which the document might be
* rendered (see "Output Intents" on page 684).
@@ -896,13 +764,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputIntents", "", NULL));
}
- SkPdfArray* OutputIntents() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputIntents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* OutputIntents() const;
};
#endif // __DEFINED__SkPdfCatalogDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.cpp
new file mode 100644
index 0000000..a7da6c6
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.cpp
@@ -0,0 +1,58 @@
+#include "SkPdfCcittfaxdecodeFilterDictionary_autogen.h"
+
+long SkPdfCcittfaxdecodeFilterDictionary::K() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+bool SkPdfCcittfaxdecodeFilterDictionary::EndOfLine() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfLine", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+bool SkPdfCcittfaxdecodeFilterDictionary::EncodedByteAlign() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncodedByteAlign", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+long SkPdfCcittfaxdecodeFilterDictionary::Columns() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfCcittfaxdecodeFilterDictionary::Rows() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rows", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+bool SkPdfCcittfaxdecodeFilterDictionary::EndOfBlock() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfBlock", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+bool SkPdfCcittfaxdecodeFilterDictionary::BlackIs1() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackIs1", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+long SkPdfCcittfaxdecodeFilterDictionary::DamagedRowsBeforeError() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DamagedRowsBeforeError", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.h
index d4701fb..a594476 100644
--- a/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.h
@@ -539,13 +539,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", NULL));
}
- long K() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long K() const;
/** ()A flag indicating whether end-of-line bit patterns are required to be
* present in the encoding. The CCITTFaxDecode filter always accepts
* end-of-line bit patterns, but requires them only if EndOfLine is true.
@@ -555,13 +549,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfLine", "", NULL));
}
- bool EndOfLine() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfLine", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool EndOfLine() const;
/** ()A flag indicating whether the filter expects extra 0 bits before each
* encoded line so that the line begins on a byte boundary. If true, the
* filter skips over encoded bits to begin decoding each line at a byte
@@ -572,13 +560,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncodedByteAlign", "", NULL));
}
- bool EncodedByteAlign() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncodedByteAlign", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool EncodedByteAlign() const;
/** ()The width of the image in pixels. If the value is not a multiple of 8,
* the filter adjusts the width of the unencoded image to the next mul-
* tiple of 8, so that each line starts on a byte boundary. Default value:
@@ -588,13 +570,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", NULL));
}
- long Columns() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Columns() const;
/** ()The height of the image in scan lines. If the value is 0 or absent, the
* image's height is not predetermined, and the encoded data must be
* terminated by an end-of-block bit pattern or by the end of the fil-
@@ -604,13 +580,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rows", "", NULL));
}
- long Rows() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rows", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Rows() const;
/** ()A flag indicating whether the filter expects the encoded data to be
* terminated by an end-of-block pattern, overriding the Rows pa-
* rameter. If false, the filter stops when it has decoded the number of
@@ -623,13 +593,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfBlock", "", NULL));
}
- bool EndOfBlock() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfBlock", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool EndOfBlock() const;
/** ()A flag indicating whether 1 bits are to be interpreted as black pixels
* and 0 bits as white pixels, the reverse of the normal PDF convention
* for image data. Default value: false.
@@ -638,13 +602,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackIs1", "", NULL));
}
- bool BlackIs1() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackIs1", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool BlackIs1() const;
/** ()The number of damaged rows of data to be tolerated before an
* error occurs. This entry applies only if EndOfLine is true and K is
* nonnegative. Tolerating a damaged row means locating its end in
@@ -657,13 +615,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DamagedRowsBeforeError", "", NULL));
}
- long DamagedRowsBeforeError() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DamagedRowsBeforeError", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long DamagedRowsBeforeError() const;
};
#endif // __DEFINED__SkPdfCcittfaxdecodeFilterDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..947fdf4
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfCheckboxFieldDictionary_autogen.h"
+
+std::string SkPdfCheckboxFieldDictionary::Opt() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.h
index 9661ed9..1509c97 100644
--- a/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", NULL));
}
- std::string Opt() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Opt() const;
};
#endif // __DEFINED__SkPdfCheckboxFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..39ba54c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfChoiceFieldDictionary_autogen.h"
+
+SkPdfArray* SkPdfChoiceFieldDictionary::Opt() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfChoiceFieldDictionary::TI() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TI", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfChoiceFieldDictionary::I() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.h
index 6aec3e8..17d74ba 100644
--- a/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.h
@@ -535,13 +535,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", NULL));
}
- SkPdfArray* Opt() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Opt() const;
/** (Optional; inheritable) For scrollable list boxes, the top index (the index in the Opt array
* of the first option visible in the list).
**/
@@ -549,13 +543,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TI", "", NULL));
}
- long TI() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TI", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long TI() const;
/** (Sometimes required, otherwise optional; inheritable; PDF 1.4) For choice fields that allow
* multiple selection (MultiSelect flag set), an array of integers, sorted in ascending order,
* representing the zero-based indices in the Opt array of the currently selected option
@@ -568,13 +556,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", NULL));
}
- SkPdfArray* I() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* I() const;
};
#endif // __DEFINED__SkPdfChoiceFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.cpp
new file mode 100644
index 0000000..80b5cf3
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfComponentsWithMetadataDictionary_autogen.h"
+
+SkPdfStream* SkPdfComponentsWithMetadataDictionary::Metadata() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.h
index 401b090..7d77ce7 100644
--- a/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.h
@@ -531,13 +531,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
}
- SkPdfStream* Metadata() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Metadata() const;
};
#endif // __DEFINED__SkPdfComponentsWithMetadataDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.cpp
new file mode 100644
index 0000000..66ff159
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfDctdecodeFilterDictionary_autogen.h"
+
+long SkPdfDctdecodeFilterDictionary::ColorTransform() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorTransform", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.h
index 7d13d01..71f1a83 100644
--- a/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.h
@@ -548,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorTransform", "", NULL));
}
- long ColorTransform() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorTransform", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long ColorTransform() const;
};
#endif // __DEFINED__SkPdfDctdecodeFilterDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.cpp
new file mode 100644
index 0000000..c41bc24
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfDeviceNColorSpaceDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfDeviceNColorSpaceDictionary::Colorants() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.h
index ec96dbc..b1bd765 100644
--- a/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.h
@@ -542,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", NULL));
}
- SkPdfDictionary* Colorants() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Colorants() const;
};
#endif // __DEFINED__SkPdfDeviceNColorSpaceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfDictionary_autogen.cpp
new file mode 100644
index 0000000..ca56507
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfDictionary_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfDictionary_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.cpp
new file mode 100644
index 0000000..78df9e3
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfDocumentCatalogActionsDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfDocumentCatalogActionsDictionary::DC() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DC", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfDocumentCatalogActionsDictionary::WS() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfDocumentCatalogActionsDictionary::DS() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfDocumentCatalogActionsDictionary::WP() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WP", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfDocumentCatalogActionsDictionary::DP() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DP", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.h
index 515825a..201792f 100644
--- a/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DC", "", NULL));
}
- SkPdfDictionary* DC() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DC", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* DC() const;
/** (Optional; PDF 1.4) A JavaScript action to be performed before saving a document.
* (The name WS stands for "will save.")
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WS", "", NULL));
}
- SkPdfDictionary* WS() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* WS() const;
/** (Optional; PDF 1.4) A JavaScript action to be performed after saving a document. (The
* name DS stands for "did save.")
**/
@@ -560,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DS", "", NULL));
}
- SkPdfDictionary* DS() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* DS() const;
/** (Optional; PDF 1.4) A JavaScript action to be performed before printing a document.
* (The name WP stands for "will print.")
**/
@@ -574,13 +556,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WP", "", NULL));
}
- SkPdfDictionary* WP() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WP", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* WP() const;
/** (Optional; PDF 1.4) A JavaScript action to be performed after printing a document.
* (The name DP stands for "did print.")
**/
@@ -588,13 +564,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DP", "", NULL));
}
- SkPdfDictionary* DP() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DP", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* DP() const;
};
#endif // __DEFINED__SkPdfDocumentCatalogActionsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.cpp
new file mode 100644
index 0000000..1b0cb1c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.cpp
@@ -0,0 +1,65 @@
+#include "SkPdfDocumentInformationDictionary_autogen.h"
+
+std::string SkPdfDocumentInformationDictionary::Title() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfDocumentInformationDictionary::Author() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Author", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfDocumentInformationDictionary::Subject() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subject", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfDocumentInformationDictionary::Keywords() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Keywords", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfDocumentInformationDictionary::Creator() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfDocumentInformationDictionary::Producer() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Producer", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDate SkPdfDocumentInformationDictionary::CreationDate() const {
+ SkPdfDate ret;
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
+SkPdfDate SkPdfDocumentInformationDictionary::ModDate() const {
+ SkPdfDate ret;
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
+std::string SkPdfDocumentInformationDictionary::Trapped() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trapped", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.h
index 34e88fa..e4e80e0 100644
--- a/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.h
@@ -531,52 +531,28 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", NULL));
}
- std::string Title() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Title() const;
/** (Optional) The name of the person who created the document.
**/
bool has_Author() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Author", "", NULL));
}
- std::string Author() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Author", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Author() const;
/** (Optional; PDF 1.1) The subject of the document.
**/
bool has_Subject() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subject", "", NULL));
}
- std::string Subject() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subject", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subject() const;
/** (Optional; PDF 1.1) Keywords associated with the document.
**/
bool has_Keywords() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Keywords", "", NULL));
}
- std::string Keywords() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Keywords", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Keywords() const;
/** (Optional) If the document was converted to PDF from another format, the
* name of the application (for example, Adobe FrameMaker(R)) that created the
* original document from which it was converted.
@@ -585,13 +561,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", NULL));
}
- std::string Creator() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Creator() const;
/** (Optional) If the document was converted to PDF from another format, the
* name of the application (for example, Acrobat Distiller) that converted it to
* PDF.
@@ -600,13 +570,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Producer", "", NULL));
}
- std::string Producer() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Producer", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Producer() const;
/** (Optional) The date and time the document was created, in human-readable
* form (see Section 3.8.2, "Dates").
**/
@@ -614,13 +578,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", NULL));
}
- SkPdfDate CreationDate() const {
- SkPdfDate ret;
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate CreationDate() const;
/** (Optional; PDF 1.1) The date and time the document was most recently
* modified, in human-readable form (see Section 3.8.2, "Dates").
**/
@@ -628,13 +586,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", NULL));
}
- SkPdfDate ModDate() const {
- SkPdfDate ret;
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate ModDate() const;
/** (Optional; PDF 1.3) A name object indicating whether the document has
* been modified to include trapping information (see Section 9.10.5, "Trap-
* ping Support"):
@@ -656,13 +608,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trapped", "", NULL));
}
- std::string Trapped() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trapped", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Trapped() const;
};
#endif // __DEFINED__SkPdfDocumentInformationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.cpp
new file mode 100644
index 0000000..86e0a2b
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfEmbeddedFileParameterDictionary_autogen.h"
+
+long SkPdfEmbeddedFileParameterDictionary::Size() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfDate SkPdfEmbeddedFileParameterDictionary::CreationDate() const {
+ SkPdfDate ret;
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
+SkPdfDate SkPdfEmbeddedFileParameterDictionary::ModDate() const {
+ SkPdfDate ret;
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
+SkPdfDictionary* SkPdfEmbeddedFileParameterDictionary::Mac() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfEmbeddedFileParameterDictionary::CheckSum() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CheckSum", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.h
index fedb722..7248bfb 100644
--- a/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.h
@@ -531,39 +531,21 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", NULL));
}
- long Size() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Size() const;
/** (Optional) The date and time when the embedded file was created.
**/
bool has_CreationDate() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", NULL));
}
- SkPdfDate CreationDate() const {
- SkPdfDate ret;
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate CreationDate() const;
/** (Optional) The date and time when the embedded file was last modified.
**/
bool has_ModDate() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", NULL));
}
- SkPdfDate ModDate() const {
- SkPdfDate ret;
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate ModDate() const;
/** (Optional) A subdictionary containing additional information specific to
* Mac OS files (see Table 3.35).
**/
@@ -571,13 +553,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", NULL));
}
- SkPdfDictionary* Mac() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Mac() const;
/** (Optional) A 16-byte string that is the checksum of the bytes of the uncom-
* pressed embedded file. The checksum is calculated by applying the standard
* MD5 message-digest algorithm (described in Internet RFC 1321, The MD5
@@ -588,13 +564,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CheckSum", "", NULL));
}
- std::string CheckSum() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CheckSum", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string CheckSum() const;
};
#endif // __DEFINED__SkPdfEmbeddedFileParameterDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.cpp
new file mode 100644
index 0000000..1f3367f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfEmbeddedFileStreamDictionary_autogen.h"
+
+std::string SkPdfEmbeddedFileStreamDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfEmbeddedFileStreamDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfEmbeddedFileStreamDictionary::Params() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Params", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.h
index 96479fc..cd43e74 100644
--- a/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Optional) The subtype of the embedded file. The value of this entry must be
* a first-class name, as defined in Appendix E. Names without a registered pre-
* fix must conform to the MIME media type names defined in Internet RFC
@@ -551,13 +545,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Optional) An embedded file parameter dictionary containing additional, file-
* specific information (see Table 3.34).
**/
@@ -565,13 +553,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Params", "", NULL));
}
- SkPdfDictionary* Params() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Params", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Params() const;
};
#endif // __DEFINED__SkPdfEmbeddedFileStreamDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.cpp
new file mode 100644
index 0000000..8b01a5d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfEmbeddedFontStreamDictionary_autogen.h"
+
+long SkPdfEmbeddedFontStreamDictionary::Length1() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length1", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfEmbeddedFontStreamDictionary::Length2() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfEmbeddedFontStreamDictionary::Length3() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length3", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfEmbeddedFontStreamDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfEmbeddedFontStreamDictionary::Metadata() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.h
index 1c55026..25e12d8 100644
--- a/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length1", "", NULL));
}
- long Length1() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length1", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Length1() const;
/** (Required for Type 1 fonts) The length in bytes of the encrypted portion of the Type 1
* font program (see below) after it has been decoded using the filters specified by the
* stream's Filter entry.
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length2", "", NULL));
}
- long Length2() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Length2() const;
/** (Required for Type 1 fonts) The length in bytes of the fixed-content portion of the
* Type 1 font program (see below), after it has been decoded using the filters specified
* by the stream's Filter entry. If Length3 is 0, it indicates that the 512 zeros and clearto-
@@ -564,13 +552,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length3", "", NULL));
}
- long Length3() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length3", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Length3() const;
/** (Required if referenced from FontFile3; PDF 1.2) A name specifying the format of the
* embedded font program. The name must be Type1C for Type 1 compact fonts or CID-
* FontType0C for Type 0 compact CIDFonts. When additional font formats are added
@@ -580,13 +562,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Optional; PDF 1.4) A metadata stream containing metadata for the embedded font
* program (see Section 9.2.2, "Metadata Streams").
**/
@@ -594,13 +570,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
}
- SkPdfStream* Metadata() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Metadata() const;
};
#endif // __DEFINED__SkPdfEmbeddedFontStreamDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.cpp
new file mode 100644
index 0000000..c305d3b
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfEncodingDictionary_autogen.h"
+
+std::string SkPdfEncodingDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfEncodingDictionary::BaseEncoding() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseEncoding", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfEncodingDictionary::Differences() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.h
index 293bba4..6ec291b 100644
--- a/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Optional) The base encoding-that is, the encoding from which the Differences
* entry (if present) describes differences-specified as the name of a predefined
* encoding MacRomanEncoding, MacExpertEncoding, or WinAnsiEncoding (see
@@ -554,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseEncoding", "", NULL));
}
- std::string BaseEncoding() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseEncoding", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string BaseEncoding() const;
/** (Optional; not recommended with TrueType fonts) An array describing the differ-
* ences from the encoding specified by BaseEncoding or, if BaseEncoding is ab-
* sent, from an implicit base encoding. The Differences array is described above.
@@ -583,13 +571,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", NULL));
}
- SkPdfArray* Differences() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Differences() const;
};
#endif // __DEFINED__SkPdfEncodingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.cpp
new file mode 100644
index 0000000..3126cf0
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.h"
+
+long SkPdfEncryptedEmbeddedFileStreamDictionary::EncryptionRevision() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncryptionRevision", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.h
index 77be6d7..2cad87b 100644
--- a/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncryptionRevision", "", NULL));
}
- long EncryptionRevision() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncryptionRevision", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long EncryptionRevision() const;
};
#endif // __DEFINED__SkPdfEncryptedEmbeddedFileStreamDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.cpp
new file mode 100644
index 0000000..a38f329
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfEncryptionCommonDictionary_autogen.h"
+
+std::string SkPdfEncryptionCommonDictionary::Filter() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+double SkPdfEncryptionCommonDictionary::V() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfEncryptionCommonDictionary::Length() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.h
index 5470b9b..4716986 100644
--- a/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", NULL));
}
- std::string Filter() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Filter() const;
/** (Optional but strongly recommended) A code specifying the algorithm to be used in en-
* crypting and decrypting the document:
* 0 An algorithm that is undocumented and no longer supported, and whose use is
@@ -557,13 +551,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
}
- double V() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double V() const;
/** (Optional; PDF 1.4; only if V is 2 or 3) The length of the encryption key, in bits. The value
* must be a multiple of 8, in the range 40 to 128. Default value: 40.
**/
@@ -571,13 +559,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", NULL));
}
- long Length() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Length() const;
};
#endif // __DEFINED__SkPdfEncryptionCommonDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.cpp
new file mode 100644
index 0000000..e57079e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfFDFCatalogDictionary_autogen.h"
+
+std::string SkPdfFDFCatalogDictionary::Version() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfFDFCatalogDictionary::FDF() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDF", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.h
index baddd5f..77f066f 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.h
@@ -538,26 +538,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", NULL));
}
- std::string Version() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Version() const;
/** (Required) The FDF dictionary for this file (see Table 8.69).
**/
bool has_FDF() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDF", "", NULL));
}
- SkPdfDictionary* FDF() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDF", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* FDF() const;
};
#endif // __DEFINED__SkPdfFDFCatalogDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.cpp
new file mode 100644
index 0000000..0f749e1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.cpp
@@ -0,0 +1,79 @@
+#include "SkPdfFDFDictionary_autogen.h"
+
+SkPdfFileSpec SkPdfFDFDictionary::F() const {
+ SkPdfFileSpec ret;
+ if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFileSpec();
+}
+
+SkPdfArray* SkPdfFDFDictionary::ID() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfFDFDictionary::Fields() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfFDFDictionary::Status() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Status", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfFDFDictionary::Pages() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfFDFDictionary::Encoding() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfFDFDictionary::Annots() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfFDFDictionary::Differences() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfFDFDictionary::Target() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Target", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfFDFDictionary::EmbeddedFDFs() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFDFs", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFDFDictionary::JavaScript() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.h
index af7fc69..cd73ba9 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- SkPdfFileSpec F() const {
- SkPdfFileSpec ret;
- if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFileSpec();
- }
-
+ SkPdfFileSpec F() const;
/** (Optional) An array of two strings constituting a file identifier (see
* Section 9.3, "File Identifiers") for the source or target file designated
* by F, taken from the ID entry in the file's trailer dictionary (see Sec-
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
}
- SkPdfArray* ID() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* ID() const;
/** (Optional) An array of FDF field dictionaries (see "FDF Fields" on
* page 564) describing the root fields (those with no ancestors in
* the field hierarchy) to be exported or imported. This entry and
@@ -564,13 +552,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", NULL));
}
- SkPdfArray* Fields() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Fields() const;
/** (Optional) A status string to be displayed indicating the result of an
* action, typically a submit-form action (see "Submit-Form Actions"
* on page 550). The string is encoded with PDFDocEncoding. (See
@@ -581,13 +563,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Status", "", NULL));
}
- std::string Status() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Status", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Status() const;
/** (Optional; PDF 1.3) An array of FDF page dictionaries (see "FDF
* Pages" on page 566) describing new pages to be added to a PDF
* target document. The Fields and Status entries may not be present
@@ -597,13 +573,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", NULL));
}
- SkPdfArray* Pages() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Pages() const;
/** (Optional; PDF 1.3) The encoding to be used for any FDF field
* value or option (V or Opt in the field dictionary; see Table 8.72 on
* page 564) that is a string and does not begin with the Unicode pre-
@@ -614,13 +584,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", NULL));
}
- std::string Encoding() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Encoding() const;
/** (Optional; PDF 1.3) An array of FDF annotation dictionaries (see
* "FDF Annotation Dictionaries" on page 568). The array can in-
* clude annotations of any of the standard types listed in Table 8.14
@@ -630,13 +594,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", NULL));
}
- SkPdfArray* Annots() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Annots() const;
/** (Optional; PDF 1.4) A stream containing all the bytes in all incre-
* mental updates made to the underlying PDF document since it was
* opened (see Section 3.4.5, "Incremental Updates"). If a submit-
@@ -660,13 +618,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", NULL));
}
- SkPdfStream* Differences() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Differences() const;
/** (Optional; PDF 1.4) The name of a browser frame in which the un-
* derlying PDF document is to be opened. This mimics the behavior
* of the target attribute in HTML <href> tags.
@@ -675,13 +627,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Target", "", NULL));
}
- std::string Target() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Target", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Target() const;
/** (Optional; PDF 1.4) An array of file specifications (see Section 3.10,
* "File Specifications") representing other FDF files embedded with-
* in this one (Section 3.10.3, "Embedded File Streams").
@@ -690,13 +636,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFDFs", "", NULL));
}
- SkPdfArray* EmbeddedFDFs() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFDFs", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* EmbeddedFDFs() const;
/** (Optional; PDF 1.4) A JavaScript dictionary (see Table 8.71) defin-
* ing document-level JavaScript scripts.
**/
@@ -704,13 +644,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", NULL));
}
- SkPdfDictionary* JavaScript() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* JavaScript() const;
};
#endif // __DEFINED__SkPdfFDFDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..a16545f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.cpp
@@ -0,0 +1,107 @@
+#include "SkPdfFDFFieldDictionary_autogen.h"
+
+SkPdfArray* SkPdfFDFFieldDictionary::Kids() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfFDFFieldDictionary::T() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfObject* SkPdfFDFFieldDictionary::V() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfFDFFieldDictionary::Ff() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfFDFFieldDictionary::SetFf() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetFf", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfFDFFieldDictionary::ClrFf() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrFf", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfFDFFieldDictionary::F() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfFDFFieldDictionary::SetF() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetF", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfFDFFieldDictionary::ClrF() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrF", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfDictionary* SkPdfFDFFieldDictionary::AP() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFDFFieldDictionary::APRef() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "APRef", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFDFFieldDictionary::IF() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfFDFFieldDictionary::Opt() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFDFFieldDictionary::A() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFDFFieldDictionary::AA() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.h
index 9ece7a9..bcdf0c5 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.h
@@ -533,26 +533,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", NULL));
}
- SkPdfArray* Kids() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Kids() const;
/** (Required) The partial field name (see "Field Names" on page 532).
**/
bool has_T() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
}
- std::string T() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string T() const;
/** (Optional) The field's value, whose format varies depending on the field type; see
* the descriptions of individual field types in Section 8.6.3 for further information.
**/
@@ -560,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
}
- SkPdfObject* V() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* V() const;
/** (Optional) A set of flags specifying various characteristics of the field (see Tables
* 8.50 on page 532, 8.53 on page 538, 8.56 on page 543, and 8.58 on page 546). When
* imported into an interactive form, the value of this entry replaces that of the Ff
@@ -577,13 +559,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", NULL));
}
- long Ff() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Ff() const;
/** (Optional) A set of flags to be set (turned on) in the Ff entry of the form's cor-
* responding field dictionary. Bits equal to 1 in SetFf cause the corresponding bits in
* Ff to be set to 1. This entry is ignored if an Ff entry is present in the FDF field
@@ -593,13 +569,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetFf", "", NULL));
}
- long SetFf() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetFf", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long SetFf() const;
/** (Optional) A set of flags to be cleared (turned off) in the Ff entry of the form's cor-
* responding field dictionary. Bits equal to 1 in ClrFf cause the corresponding bits in
* Ff to be set to 0. If a SetFf entry is also present in the FDF field dictionary, it is
@@ -610,13 +580,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrFf", "", NULL));
}
- long ClrFf() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrFf", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long ClrFf() const;
/** (Optional) A set of flags specifying various characteristics of the field's widget anno-
* tation (see Section 8.4.2, "Annotation Flags"). When imported into an interactive
* form, the value of this entry replaces that of the F entry in the form's corresponding
@@ -627,13 +591,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- long F() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long F() const;
/** (Optional) A set of flags to be set (turned on) in the F entry of the form's corre-
* sponding widget annotation dictionary. Bits equal to 1 in SetF cause the corre-
* sponding bits in F to be set to 1. This entry is ignored if an F entry is present in the
@@ -643,13 +601,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetF", "", NULL));
}
- long SetF() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetF", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long SetF() const;
/** (Optional) A set of flags to be cleared (turned off) in the F entry of the form's corre-
* sponding widget annotation dictionary. Bits equal to 1 in ClrF cause the corre-
* sponding bits in F to be set to 0. If a SetF entry is also present in the FDF field
@@ -660,13 +612,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrF", "", NULL));
}
- long ClrF() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrF", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long ClrF() const;
/** (Optional) An appearance dictionary specifying the appearance of a pushbutton
* field (see "Pushbuttons" on page 539). The appearance dictionary's contents are as
* shown in Table 8.13 on page 497, except that the values of the N, R, and D entries
@@ -676,13 +622,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", NULL));
}
- SkPdfDictionary* AP() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* AP() const;
/** (Optional; PDF 1.3) A dictionary holding references to external PDF files contain-
* ing the pages to use for the appearances of a pushbutton field. This dictionary is
* similar to an appearance dictionary (see Table 8.13 on page 497), except that the
@@ -693,13 +633,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "APRef", "", NULL));
}
- SkPdfDictionary* APRef() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "APRef", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* APRef() const;
/** (Optional; PDF 1.3; button fields only) An icon fit dictionary (see Table 8.73) speci-
* fying how to display a button field's icon within the annotation rectangle of its wid-
* get annotation.
@@ -708,13 +642,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", NULL));
}
- SkPdfDictionary* IF() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* IF() const;
/** (Required; choice fields only) An array of options to be presented to the user. Each
* element of the array can take either of two forms:
* * A text string representing one of the available options
@@ -726,13 +654,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", NULL));
}
- SkPdfArray* Opt() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Opt() const;
/** (Optional) An action to be performed when this field's widget annotation is activat-
* ed (see Section 8.5, "Actions").
**/
@@ -740,13 +662,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", NULL));
}
- SkPdfDictionary* A() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* A() const;
/** (Optional) An additional-actions dictionary defining the field's behavior in re-
* sponse to various trigger events (see Section 8.5.2, "Trigger Events").
**/
@@ -754,13 +670,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", NULL));
}
- SkPdfDictionary* AA() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* AA() const;
};
#endif // __DEFINED__SkPdfFDFFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..f34d1d6
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfFDFFileAnnotationDictionary_autogen.h"
+
+long SkPdfFDFFileAnnotationDictionary::Page() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.h
index 1e5b26a..dab235e 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", NULL));
}
- long Page() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Page() const;
};
#endif // __DEFINED__SkPdfFDFFileAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.cpp
new file mode 100644
index 0000000..9fdda2d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfFDFNamedPageReferenceDictionary_autogen.h"
+
+std::string SkPdfFDFNamedPageReferenceDictionary::Name() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfFileSpec SkPdfFDFNamedPageReferenceDictionary::F() const {
+ SkPdfFileSpec ret;
+ if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFileSpec();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.h
index 41b765f..6cdbe93 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.h
@@ -531,13 +531,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
}
- std::string Name() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Name() const;
/** (Optional) The file containing the named page. If this key is absent, it is
* assumed that the page resides in the associated PDF file.
**/
@@ -545,13 +539,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- SkPdfFileSpec F() const {
- SkPdfFileSpec ret;
- if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFileSpec();
- }
-
+ SkPdfFileSpec F() const;
};
#endif // __DEFINED__SkPdfFDFNamedPageReferenceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.cpp
new file mode 100644
index 0000000..6e25ecb
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfFDFPageDictionary_autogen.h"
+
+SkPdfArray* SkPdfFDFPageDictionary::Templates() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFDFPageDictionary::Info() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.h
index 509bd7b..32d1719 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", NULL));
}
- SkPdfArray* Templates() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Templates() const;
/** (Optional) An FDF page information dictionary containing additional informa-
* tion about the page. At the time of publication, no entries have been defined for
* this dictionary.
@@ -547,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", NULL));
}
- SkPdfDictionary* Info() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Info() const;
};
#endif // __DEFINED__SkPdfFDFPageDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.cpp
new file mode 100644
index 0000000..9aa27b7
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfFDFTemplateDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfFDFTemplateDictionary::TRef() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TRef", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfFDFTemplateDictionary::Fields() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+bool SkPdfFDFTemplateDictionary::Rename() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rename", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.h
index 92bfa1a..3123a93 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TRef", "", NULL));
}
- SkPdfDictionary* TRef() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TRef", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* TRef() const;
/** (Optional) An array of references to FDF field dictionaries (see Table 8.72 on
* page 564) describing the root fields to be imported (those with no ancestors in
* the field hierarchy).
@@ -547,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", NULL));
}
- SkPdfArray* Fields() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Fields() const;
/** (Optional) A flag specifying whether fields imported from the template may be
* renamed in the event of name conflicts with existing fields; see below for further
* discussion. Default value: true.
@@ -562,13 +550,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rename", "", NULL));
}
- bool Rename() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rename", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool Rename() const;
};
#endif // __DEFINED__SkPdfFDFTemplateDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.cpp
new file mode 100644
index 0000000..f376306
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfFDFTrailerDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfFDFTrailerDictionary::Root() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.h
index 12ac84c..ca381e0 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", NULL));
}
- SkPdfDictionary* Root() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Root() const;
};
#endif // __DEFINED__SkPdfFDFTrailerDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..94f3a21
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.cpp
@@ -0,0 +1,72 @@
+#include "SkPdfFieldDictionary_autogen.h"
+
+std::string SkPdfFieldDictionary::FT() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FT", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfFieldDictionary::Parent() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfFieldDictionary::Kids() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfFieldDictionary::T() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfFieldDictionary::TU() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TU", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfFieldDictionary::TM() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TM", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfFieldDictionary::Ff() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfObject* SkPdfFieldDictionary::V() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfObject* SkPdfFieldDictionary::DV() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DV", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFieldDictionary::AA() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.h
index 6a67ff4..8333eba 100644
--- a/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.h
@@ -541,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FT", "", NULL));
}
- std::string FT() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FT", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string FT() const;
/** (Required if this field is the child of another in the field hierarchy; absent other-
* wise) The field that is the immediate parent of this one (the field, if any,
* whose Kids array includes this field). A field can have at most one parent; that
@@ -557,13 +551,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", NULL));
}
- SkPdfDictionary* Parent() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Parent() const;
/** (Optional) An array of indirect references to the immediate children of this
* field.
**/
@@ -571,13 +559,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", NULL));
}
- SkPdfArray* Kids() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Kids() const;
/** (Optional) The partial field name (see "Field Names," below; see also imple-
* mentation notes 82 and 83 in Appendix H).
**/
@@ -585,13 +567,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
}
- std::string T() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string T() const;
/** (Optional; PDF 1.3) An alternate field name, to be used in place of the actual
* field name wherever the field must be identified in the user interface (such as
* in error or status messages referring to the field). This text is also useful
@@ -603,13 +579,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TU", "", NULL));
}
- std::string TU() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TU", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string TU() const;
/** (Optional; PDF 1.3) The mapping name to be used when exporting inter-
* active form field data from the document.
**/
@@ -617,13 +587,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TM", "", NULL));
}
- std::string TM() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TM", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string TM() const;
/** (Optional; inheritable) A set of flags specifying various characteristics of the
* field (see Table 8.50). Default value: 0.
**/
@@ -631,13 +595,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", NULL));
}
- long Ff() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Ff() const;
/** (Optional; inheritable) The field's value, whose format varies depending on
* the field type; see the descriptions of individual field types for further infor-
* mation.
@@ -646,13 +604,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
}
- SkPdfObject* V() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* V() const;
/** (Optional; inheritable) The default value to which the field reverts when a
* reset-form action is executed (see "Reset-Form Actions" on page 554). The
* format of this value is the same as that of V.
@@ -661,13 +613,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DV", "", NULL));
}
- SkPdfObject* DV() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DV", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* DV() const;
/** (Optional; PDF 1.2) An additional-actions dictionary defining the field's
* behavior in response to various trigger events (see Section 8.5.2, "Trigger
* Events"). This entry has exactly the same meaning as the AA entry in an
@@ -677,13 +623,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", NULL));
}
- SkPdfDictionary* AA() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* AA() const;
};
#endif // __DEFINED__SkPdfFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..fed0cf6
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfFileAttachmentAnnotationDictionary_autogen.h"
+
+std::string SkPdfFileAttachmentAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfFileSpec SkPdfFileAttachmentAnnotationDictionary::FS() const {
+ SkPdfFileSpec ret;
+ if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFileSpec();
+}
+
+std::string SkPdfFileAttachmentAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfFileAttachmentAnnotationDictionary::Name() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.h
index 2187f76..99b60af 100644
--- a/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.h
@@ -532,26 +532,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) The file associated with this annotation.
**/
bool has_FS() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", NULL));
}
- SkPdfFileSpec FS() const {
- SkPdfFileSpec ret;
- if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFileSpec();
- }
-
+ SkPdfFileSpec FS() const;
/** (Required) The text to be displayed in the pop-up window when the annota-
* tion is opened. Carriage returns may be used to separate the text into para-
* graphs.
@@ -560,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Optional) The name of an icon to be used in displaying the annotation.
* Viewer applications should provide predefined icon appearances for at least
* the following standard names:
@@ -581,13 +563,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
}
- std::string Name() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Name() const;
};
#endif // __DEFINED__SkPdfFileAttachmentAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.cpp
new file mode 100644
index 0000000..e87539e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.cpp
@@ -0,0 +1,72 @@
+#include "SkPdfFileSpecificationDictionary_autogen.h"
+
+std::string SkPdfFileSpecificationDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfFileSpecificationDictionary::FS() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfFileSpecificationDictionary::F() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfFileSpecificationDictionary::DOS() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DOS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfFileSpecificationDictionary::Mac() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfFileSpecificationDictionary::Unix() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfFileSpecificationDictionary::ID() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+bool SkPdfFileSpecificationDictionary::V() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+SkPdfDictionary* SkPdfFileSpecificationDictionary::EF() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EF", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFileSpecificationDictionary::RF() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RF", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.h
index d233724..494b0d6 100644
--- a/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Optional) The name of the file system to be used to interpret this file specification. If
* this entry is present, all other entries in the dictionary are interpreted by the desig-
* nated file system. PDF defines only one standard file system, URL (see Section 3.10.4,
@@ -550,13 +544,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", NULL));
}
- std::string FS() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string FS() const;
/** (Required if the DOS, Mac, and Unix entries are all absent) A file specification string of
* the form described in Section 3.10.1, "File Specification Strings," or (if the file system
* is URL) a uniform resource locator, as described in Section 3.10.4, "URL Specifica-
@@ -566,13 +554,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- std::string F() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string F() const;
/** (Optional) A file specification string (see Section 3.10.1, "File Specification Strings")
* representing a DOS file name.
**/
@@ -580,13 +562,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DOS", "", NULL));
}
- std::string DOS() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DOS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string DOS() const;
/** (Optional) A file specification string (see Section 3.10.1, "File Specification Strings")
* representing a Mac OS file name.
**/
@@ -594,13 +570,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", NULL));
}
- std::string Mac() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Mac() const;
/** (Optional) A file specification string (see Section 3.10.1, "File Specification Strings")
* representing a UNIX file name.
**/
@@ -608,13 +578,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", NULL));
}
- std::string Unix() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Unix() const;
/** (Optional) An array of two strings constituting a file identifier (see Section 9.3, "File
* Identifiers") that is also included in the referenced file. The use of this entry improves
* a viewer application's chances of finding the intended file and allows it to warn the
@@ -624,13 +588,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
}
- SkPdfArray* ID() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* ID() const;
/** (Optional; PDF 1.2) A flag indicating whether the file referenced by the file specifica-
* tion is volatile (changes frequently with time). If the value is true, viewer applications
* should never cache a copy of the file. For example, a movie annotation referencing a
@@ -641,13 +599,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
}
- bool V() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool V() const;
/** (Required if RF is present; PDF 1.3) A dictionary containing a subset of the keys F,
* DOS, Mac, and Unix, corresponding to the entries by those names in the file specifica-
* tion dictionary. The value of each such key is an embedded file stream (see Section
@@ -659,13 +611,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EF", "", NULL));
}
- SkPdfDictionary* EF() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EF", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* EF() const;
/** (Optional; PDF 1.3) A dictionary with the same structure as the EF dictionary, which
* must also be present. Each key in the RF dictionary must also be present in the EF dic-
* tionary. Each value is a related files array (see "Related Files Arrays" on page 125)
@@ -677,13 +623,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RF", "", NULL));
}
- SkPdfDictionary* RF() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RF", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* RF() const;
};
#endif // __DEFINED__SkPdfFileSpecificationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.cpp
new file mode 100644
index 0000000..7b82356
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfFileTrailerDictionary_autogen.h"
+
+long SkPdfFileTrailerDictionary::Size() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfFileTrailerDictionary::Prev() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfDictionary* SkPdfFileTrailerDictionary::Root() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFileTrailerDictionary::Encrypt() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encrypt", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFileTrailerDictionary::Info() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfFileTrailerDictionary::ID() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.h
index 4978695..2cec231 100644
--- a/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", NULL));
}
- long Size() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Size() const;
/** (Present only if the file has more than one cross-reference section) The byte offset from
* the beginning of the file to the beginning of the previous cross-reference section.
**/
@@ -547,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", NULL));
}
- long Prev() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Prev() const;
/** (Required; must be an indirect reference) The catalog dictionary for the PDF docu-
* ment contained in the file (see Section 3.6.1, "Document Catalog").
**/
@@ -561,13 +549,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", NULL));
}
- SkPdfDictionary* Root() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Root() const;
/** (Required if document is encrypted; PDF 1.1) The document's encryption dictionary
* (see Section 3.5, "Encryption").
**/
@@ -575,13 +557,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encrypt", "", NULL));
}
- SkPdfDictionary* Encrypt() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encrypt", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Encrypt() const;
/** (Optional; must be an indirect reference) The document's information dictionary
* (see Section 9.2.1, "Document Information Dictionary").
**/
@@ -589,13 +565,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", NULL));
}
- SkPdfDictionary* Info() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Info() const;
/** (Optional; PDF 1.1) An array of two strings constituting a file identifier (see Section
* 9.3, "File Identifiers") for the file.
**/
@@ -603,13 +573,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
}
- SkPdfArray* ID() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* ID() const;
};
#endif // __DEFINED__SkPdfFileTrailerDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.cpp
new file mode 100644
index 0000000..58a2a47
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.cpp
@@ -0,0 +1,135 @@
+#include "SkPdfFontDescriptorDictionary_autogen.h"
+
+std::string SkPdfFontDescriptorDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfFontDescriptorDictionary::FontName() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontName", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfFontDescriptorDictionary::Flags() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkRect* SkPdfFontDescriptorDictionary::FontBBox() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+double SkPdfFontDescriptorDictionary::ItalicAngle() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ItalicAngle", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfFontDescriptorDictionary::Ascent() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ascent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfFontDescriptorDictionary::Descent() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Descent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfFontDescriptorDictionary::Leading() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Leading", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfFontDescriptorDictionary::CapHeight() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CapHeight", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfFontDescriptorDictionary::XHeight() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XHeight", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfFontDescriptorDictionary::StemV() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemV", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfFontDescriptorDictionary::StemH() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemH", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfFontDescriptorDictionary::AvgWidth() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AvgWidth", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfFontDescriptorDictionary::MaxWidth() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxWidth", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfFontDescriptorDictionary::MissingWidth() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MissingWidth", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfStream* SkPdfFontDescriptorDictionary::FontFile() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfFontDescriptorDictionary::FontFile2() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfFontDescriptorDictionary::FontFile3() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile3", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfFontDescriptorDictionary::CharSet() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharSet", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.h
index 2d57f71..724c8fa 100644
--- a/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The PostScript name of the font. This should be the same as the
* value of BaseFont in the font or CIDFont dictionary that refers to this font
* descriptor.
@@ -547,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontName", "", NULL));
}
- std::string FontName() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontName", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string FontName() const;
/** (Required) A collection of flags defining various characteristics of the font
* (see Section 5.7.1, "Font Descriptor Flags").
**/
@@ -561,13 +549,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", NULL));
}
- long Flags() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Flags() const;
/** (Required) A rectangle (see Section 3.8.3, "Rectangles"), expressed in the
* glyph coordinate system, specifying the font bounding box. This is the small-
* est rectangle enclosing the shape that would result if all of the glyphs of the
@@ -577,13 +559,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", NULL));
}
- SkRect* FontBBox() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* FontBBox() const;
/** (Required) The angle, expressed in degrees counterclockwise from the verti-
* cal, of the dominant vertical strokes of the font. (For example, the 9-o'clock
* position is 90 degrees, and the 3-o'clock position is '90 degrees.) The value is
@@ -593,13 +569,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ItalicAngle", "", NULL));
}
- double ItalicAngle() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ItalicAngle", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double ItalicAngle() const;
/** (Required) The maximum height above the baseline reached by glyphs in this
* font, excluding the height of glyphs for accented characters.
**/
@@ -607,13 +577,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ascent", "", NULL));
}
- double Ascent() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ascent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double Ascent() const;
/** (Required) The maximum depth below the baseline reached by glyphs in this
* font. The value is a negative number.
**/
@@ -621,13 +585,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Descent", "", NULL));
}
- double Descent() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Descent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double Descent() const;
/** (Optional) The desired spacing between baselines of consecutive lines of text.
* Default value: 0.
**/
@@ -635,13 +593,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Leading", "", NULL));
}
- double Leading() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Leading", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double Leading() const;
/** (Required) The vertical coordinate of the top of flat capital letters, measured
* from the baseline.
**/
@@ -649,13 +601,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CapHeight", "", NULL));
}
- double CapHeight() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CapHeight", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double CapHeight() const;
/** (Optional) The font's x height: the vertical coordinate of the top of flat non-
* ascending lowercase letters (like the letter x), measured from the baseline.
* Default value: 0.
@@ -664,13 +610,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XHeight", "", NULL));
}
- double XHeight() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XHeight", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double XHeight() const;
/** (Required) The thickness, measured horizontally, of the dominant vertical
* stems of glyphs in the font.
**/
@@ -678,13 +618,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemV", "", NULL));
}
- double StemV() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemV", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double StemV() const;
/** (Optional) The thickness, measured invertically, of the dominant horizontal
* stems of glyphs in the font. Default value: 0.
**/
@@ -692,39 +626,21 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemH", "", NULL));
}
- double StemH() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemH", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double StemH() const;
/** (Optional) The average width of glyphs in the font. Default value: 0.
**/
bool has_AvgWidth() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AvgWidth", "", NULL));
}
- double AvgWidth() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AvgWidth", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double AvgWidth() const;
/** (Optional) The maximum width of glyphs in the font. Default value: 0.
**/
bool has_MaxWidth() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxWidth", "", NULL));
}
- double MaxWidth() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxWidth", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double MaxWidth() const;
/** (Optional) The width to use for character codes whose widths are not speci-
* fied in a font dictionary's Widths array. This has a predictable effect only if all
* such codes map to glyphs whose actual widths are the same as the Missing-
@@ -734,13 +650,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MissingWidth", "", NULL));
}
- double MissingWidth() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MissingWidth", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double MissingWidth() const;
/** (Optional) A stream containing a Type 1 font program (see Section 5.8,
* "Embedded Font Programs").
**/
@@ -748,13 +658,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile", "", NULL));
}
- SkPdfStream* FontFile() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* FontFile() const;
/** (Optional; PDF 1.1) A stream containing a TrueType font program (see Sec-
* tion 5.8, "Embedded Font Programs").
**/
@@ -762,13 +666,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile2", "", NULL));
}
- SkPdfStream* FontFile2() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* FontFile2() const;
/** (Optional; PDF 1.2) A stream containing a font program other than Type 1 or
* TrueType. The format of the font program is specified by the Subtype entry
* in the stream dictionary (see Section 5.8, "Embedded Font Programs," and
@@ -780,13 +678,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile3", "", NULL));
}
- SkPdfStream* FontFile3() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile3", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* FontFile3() const;
/** (Optional; meaningful only in Type 1 fonts; PDF 1.1) A string listing the char-
* acter names defined in a font subset. The names in this string must be in PDF
* syntax-that is, each name preceded by a slash (/). The names can appear in
@@ -798,13 +690,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharSet", "", NULL));
}
- std::string CharSet() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharSet", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string CharSet() const;
};
#endif // __DEFINED__SkPdfFontDescriptorDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFontDictionary_autogen.cpp
new file mode 100644
index 0000000..759cbf5
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFontDictionary_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfFontDictionary_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.cpp
new file mode 100644
index 0000000..7a5eb41
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfFormFieldActionsDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfFormFieldActionsDictionary::K() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFormFieldActionsDictionary::F() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFormFieldActionsDictionary::V() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfFormFieldActionsDictionary::C() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.h
index 2792bf1..0b7573f 100644
--- a/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", NULL));
}
- SkPdfDictionary* K() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* K() const;
/** (Optional; PDF 1.3) A JavaScript action to be performed before the field is formatted
* to display its current value. This allows the field's value to be modified before format-
* ting.
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- SkPdfDictionary* F() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* F() const;
/** (Optional; PDF 1.3) A JavaScript action to be performed when the field's value is
* changed. This allows the new value to be checked for validity. (The name V stands for
* "validate.")
@@ -563,13 +551,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
}
- SkPdfDictionary* V() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* V() const;
/** (Optional; PDF 1.3) A JavaScript action to be performed in order to recalculate the
* value of this field when that of another field changes. (The name C stands for
* "calculate.") The order in which the document's fields are recalculated is defined by the
@@ -580,13 +562,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
}
- SkPdfDictionary* C() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* C() const;
};
#endif // __DEFINED__SkPdfFormFieldActionsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..0a1929f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfFreeTextAnnotationDictionary_autogen.h"
+
+std::string SkPdfFreeTextAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfFreeTextAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfFreeTextAnnotationDictionary::DA() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfFreeTextAnnotationDictionary::Q() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.h
index 795e9bf..ebbf92e 100644
--- a/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.h
@@ -532,26 +532,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) The text to be displayed.
**/
bool has_Contents() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Required) The default appearance string to be used in formatting the text (see
* "Variable Text" on page 533).
* Note: The annotation dictionary's AP entry, if present, takes precedence over the DA
@@ -561,13 +549,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", NULL));
}
- std::string DA() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string DA() const;
/** (Optional; PDF 1.4) A code specifying the form of quadding (justification) to be
* used in displaying the annotation's text:
* 0 Left-justified
@@ -579,13 +561,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", NULL));
}
- long Q() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Q() const;
};
#endif // __DEFINED__SkPdfFreeTextAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.cpp
new file mode 100644
index 0000000..ac63bae
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfFunctionCommonDictionary_autogen.h"
+
+long SkPdfFunctionCommonDictionary::FunctionType() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FunctionType", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfFunctionCommonDictionary::Domain() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfFunctionCommonDictionary::Range() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.h
index 5633dcb..f308a0c 100644
--- a/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.h
@@ -535,13 +535,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FunctionType", "", NULL));
}
- long FunctionType() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FunctionType", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long FunctionType() const;
/** (Required) An array of 2 x m numbers, where m is the number of input
* values. For each i from 0 to m - 1, Domain2i must be less than or equal to
* Domain2i+1 , and the ith input value, xi , must lie in the interval
@@ -552,13 +546,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", NULL));
}
- SkPdfArray* Domain() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Domain() const;
/** (Required for type 0 and type 4 functions, optional otherwise; see below) An
* array of 2 x n numbers, where n is the number of output values. For each j
* from 0 to n - 1, Range2j must be less than or equal to Range2j+1 , and the jth
@@ -570,13 +558,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", NULL));
}
- SkPdfArray* Range() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Range() const;
};
#endif // __DEFINED__SkPdfFunctionCommonDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.cpp
new file mode 100644
index 0000000..2b3fbc3
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfGoToActionDictionary_autogen.h"
+
+std::string SkPdfGoToActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfGoToActionDictionary::getDAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfGoToActionDictionary::getDAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfGoToActionDictionary::getDAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.h
index 2e04730..3f40dc3 100644
--- a/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) The destination to jump to (see Section 8.2.1, "Destinations").
**/
bool has_D() const {
@@ -551,39 +545,21 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getDAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getDAsName() const;
bool isDAString() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getDAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getDAsString() const;
bool isDAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getDAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getDAsArray() const;
};
#endif // __DEFINED__SkPdfGoToActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.cpp
new file mode 100644
index 0000000..440588c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.cpp
@@ -0,0 +1,261 @@
+#include "SkPdfGraphicsStateDictionary_autogen.h"
+
+std::string SkPdfGraphicsStateDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+double SkPdfGraphicsStateDictionary::LW() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LW", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfGraphicsStateDictionary::LC() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LC", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfGraphicsStateDictionary::LJ() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LJ", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfGraphicsStateDictionary::ML() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ML", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfGraphicsStateDictionary::D() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfGraphicsStateDictionary::RI() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+bool SkPdfGraphicsStateDictionary::OP() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OP", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+bool SkPdfGraphicsStateDictionary::op() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "op", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+long SkPdfGraphicsStateDictionary::OPM() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPM", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfGraphicsStateDictionary::Font() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfFunction SkPdfGraphicsStateDictionary::BG() const {
+ SkPdfFunction ret;
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+SkPdfFunction SkPdfGraphicsStateDictionary::getBG2AsFunction() const {
+ SkPdfFunction ret = SkPdfFunction();
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+std::string SkPdfGraphicsStateDictionary::getBG2AsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfFunction SkPdfGraphicsStateDictionary::UCR() const {
+ SkPdfFunction ret;
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+SkPdfFunction SkPdfGraphicsStateDictionary::getUCR2AsFunction() const {
+ SkPdfFunction ret = SkPdfFunction();
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+std::string SkPdfGraphicsStateDictionary::getUCR2AsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfFunction SkPdfGraphicsStateDictionary::getTRAsFunction() const {
+ SkPdfFunction ret = SkPdfFunction();
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+SkPdfArray* SkPdfGraphicsStateDictionary::getTRAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfGraphicsStateDictionary::getTRAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfFunction SkPdfGraphicsStateDictionary::getTR2AsFunction() const {
+ SkPdfFunction ret = SkPdfFunction();
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+SkPdfArray* SkPdfGraphicsStateDictionary::getTR2AsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfGraphicsStateDictionary::getTR2AsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfGraphicsStateDictionary::getHTAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfGraphicsStateDictionary::getHTAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfGraphicsStateDictionary::getHTAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+double SkPdfGraphicsStateDictionary::FL() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FL", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfGraphicsStateDictionary::SM() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SM", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+bool SkPdfGraphicsStateDictionary::SA() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+std::string SkPdfGraphicsStateDictionary::getBMAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfGraphicsStateDictionary::getBMAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfGraphicsStateDictionary::getSMaskAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfGraphicsStateDictionary::getSMaskAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+double SkPdfGraphicsStateDictionary::CA() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfGraphicsStateDictionary::ca() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ca", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+bool SkPdfGraphicsStateDictionary::AIS() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AIS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+bool SkPdfGraphicsStateDictionary::TK() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TK", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.h
index 7cb5f01..63947df 100644
--- a/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.h
@@ -532,65 +532,35 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Optional; PDF 1.3) The line width (see "Line Width" on page 152).
**/
bool has_LW() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LW", "", NULL));
}
- double LW() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LW", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double LW() const;
/** (Optional; PDF 1.3) The line cap style (see "Line Cap Style" on page 153).
**/
bool has_LC() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LC", "", NULL));
}
- long LC() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LC", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long LC() const;
/** (Optional; PDF 1.3) The line join style (see "Line Join Style" on page 153).
**/
bool has_LJ() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LJ", "", NULL));
}
- long LJ() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LJ", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long LJ() const;
/** (Optional; PDF 1.3) The miter limit (see "Miter Limit" on page 153).
**/
bool has_ML() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ML", "", NULL));
}
- double ML() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ML", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double ML() const;
/** (Optional; PDF 1.3) The line dash pattern, expressed as an array of the form
* [dashArray dashPhase], where dashArray is itself an array and dashPhase is an
* integer (see "Line Dash Pattern" on page 155).
@@ -599,13 +569,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", NULL));
}
- SkPdfArray* D() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* D() const;
/** (Optional; PDF 1.3) The name of the rendering intent (see "Rendering
* Intents" on page 197).
**/
@@ -613,13 +577,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", NULL));
}
- std::string RI() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string RI() const;
/** (Optional) A flag specifying whether to apply overprint (see Section 4.5.6,
* "Overprint Control"). In PDF 1.2 and earlier, there is a single overprint
* parameter that applies to all painting operations. Beginning with PDF 1.3,
@@ -632,13 +590,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OP", "", NULL));
}
- bool OP() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OP", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool OP() const;
/** (Optional; PDF 1.3) A flag specifying whether to apply overprint (see Section
* 4.5.6, "Overprint Control") for painting operations other than stroking. If
* this entry is absent, the OP entry, if any, sets this parameter.
@@ -647,13 +599,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "op", "", NULL));
}
- bool op() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "op", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool op() const;
/** (Optional; PDF 1.3) The overprint mode (see Section 4.5.6, "Overprint Con-
* trol").
**/
@@ -661,13 +607,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPM", "", NULL));
}
- long OPM() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPM", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long OPM() const;
/** (Optional; PDF 1.3) An array of the form [font size], where font is an indirect
* reference to a font dictionary and size is a number expressed in text space
* units. These two objects correspond to the operands of the Tf operator (see
@@ -678,13 +618,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", NULL));
}
- SkPdfArray* Font() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Font() const;
/** (Optional) The black-generation function, which maps the interval [0.0 1.0]
* to the interval [0.0 1.0] (see Section 6.2.3, "Conversion from DeviceRGB to
* DeviceCMYK").
@@ -693,13 +627,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", NULL));
}
- SkPdfFunction BG() const {
- SkPdfFunction ret;
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction BG() const;
/** (Optional; PDF 1.3) Same as BG except that the value may also be the name
* Default, denoting the black-generation function that was in effect at the start
* of the page. If both BG and BG2 are present in the same graphics state param-
@@ -715,26 +643,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfFunction getBG2AsFunction() const {
- SkPdfFunction ret = SkPdfFunction();
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction getBG2AsFunction() const;
bool isBG2AName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getBG2AsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getBG2AsName() const;
/** (Optional) The undercolor-removal function, which maps the interval
* [0.0 1.0] to the interval [-1.0 1.0] (see Section 6.2.3, "Conversion from
* DeviceRGB to DeviceCMYK").
@@ -743,13 +659,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR", "", NULL));
}
- SkPdfFunction UCR() const {
- SkPdfFunction ret;
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction UCR() const;
/** (Optional; PDF 1.3) Same as UCR except that the value may also be the name
* Default, denoting the undercolor-removal function that was in effect at the
* start of the page. If both UCR and UCR2 are present in the same graphics state
@@ -765,26 +675,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfFunction getUCR2AsFunction() const {
- SkPdfFunction ret = SkPdfFunction();
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction getUCR2AsFunction() const;
bool isUCR2AName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getUCR2AsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getUCR2AsName() const;
/** (Optional) The transfer function, which maps the interval [0.0 1.0] to the
* interval [0.0 1.0] (see Section 6.3, "Transfer Functions"). The value is either
* a single function (which applies to all process colorants) or an array of four
@@ -801,39 +699,21 @@
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfFunction getTRAsFunction() const {
- SkPdfFunction ret = SkPdfFunction();
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction getTRAsFunction() const;
bool isTRAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getTRAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getTRAsArray() const;
bool isTRAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getTRAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getTRAsName() const;
/** (Optional; PDF 1.3) Same as TR except that the value may also be the name
* Default, denoting the transfer function that was in effect at the start of the
* page. If both TR and TR2 are present in the same graphics state parameter dic-
@@ -849,39 +729,21 @@
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfFunction getTR2AsFunction() const {
- SkPdfFunction ret = SkPdfFunction();
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction getTR2AsFunction() const;
bool isTR2AArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getTR2AsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getTR2AsArray() const;
bool isTR2AName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getTR2AsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getTR2AsName() const;
/** (Optional) The halftone dictionary or stream (see Section 6.4, "Halftones")
* or the name Default, denoting the halftone that was in effect at the start of the
* page.
@@ -896,39 +758,21 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getHTAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getHTAsDictionary() const;
bool isHTAStream() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return false;
return ret->podofo()->HasStream();
}
- SkPdfStream* getHTAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getHTAsStream() const;
bool isHTAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getHTAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getHTAsName() const;
/** (Optional; PDF 1.3) The flatness tolerance (see Section 6.5.1, "Flatness Toler-
* ance").
**/
@@ -936,13 +780,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FL", "", NULL));
}
- double FL() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FL", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double FL() const;
/** (Optional; PDF 1.3) The smoothness tolerance (see Section 6.5.2, "Smooth-
* ness Tolerance").
**/
@@ -950,13 +788,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SM", "", NULL));
}
- double SM() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SM", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double SM() const;
/** (Optional) A flag specifying whether to apply automatic stroke adjustment
* (see Section 6.5.4, "Automatic Stroke Adjustment").
**/
@@ -964,13 +796,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SA", "", NULL));
}
- bool SA() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool SA() const;
/** (Optional; PDF 1.4) The current blend mode to be used in the transparent
* imaging model (see Sections 7.2.4, "Blend Mode," and 7.5.2, "Specifying
* Blending Color Space and Blend Mode").
@@ -985,26 +811,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getBMAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getBMAsName() const;
bool isBMAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getBMAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getBMAsArray() const;
/** (Optional; PDF 1.4) The current soft mask, specifying the mask shape or
* mask opacity values to be used in the transparent imaging model (see
* "Source Shape and Opacity" on page 421 and "Mask Shape and Opacity" on
@@ -1024,26 +838,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getSMaskAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getSMaskAsDictionary() const;
bool isSMaskAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getSMaskAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getSMaskAsName() const;
/** (Optional; PDF 1.4) The current stroking alpha constant, specifying the con-
* stant shape or constant opacity value to be used for stroking operations in the
* transparent imaging model (see "Source Shape and Opacity" on page 421
@@ -1053,26 +855,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", NULL));
}
- double CA() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double CA() const;
/** (Optional; PDF 1.4) Same as CA, but for nonstroking operations.
**/
bool has_ca() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ca", "", NULL));
}
- double ca() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ca", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double ca() const;
/** (Optional; PDF 1.4) The alpha source flag ("alpha is shape"), specifying
* whether the current soft mask and alpha constant are to be interpreted as
* shape values (true) or opacity values (false).
@@ -1081,13 +871,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AIS", "", NULL));
}
- bool AIS() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AIS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool AIS() const;
/** (Optional; PDF 1.4) The text knockout flag, which determines the behavior
* of overlapping glyphs within a text object in the transparent imaging model
* (see Section 5.2.7, "Text Knockout").
@@ -1096,13 +880,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TK", "", NULL));
}
- bool TK() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TK", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool TK() const;
};
#endif // __DEFINED__SkPdfGraphicsStateDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.cpp
new file mode 100644
index 0000000..17d0354
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfGroupAttributesDictionary_autogen.h"
+
+std::string SkPdfGroupAttributesDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfGroupAttributesDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.h
index 7ac962b..e630507 100644
--- a/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The group subtype, which identifies the type of group whose at-
* tributes this dictionary describes and determines the format and meaning of the
* dictionary's remaining entries. The only group subtype defined in PDF 1.4 is
@@ -550,13 +544,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
};
#endif // __DEFINED__SkPdfGroupAttributesDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfHeaders_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfHeaders_autogen.cpp
new file mode 100644
index 0000000..86217e1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfHeaders_autogen.cpp
@@ -0,0 +1,180 @@
+#include "SkPdfHeaders_autogen.h"
+#include "SkPdfJavascriptActionDictionary_autogen.cpp"
+#include "SkPdfMovieAnnotationDictionary_autogen.cpp"
+#include "SkPdfMetadataStreamDictionary_autogen.cpp"
+#include "SkPdfPageTreeNodeDictionary_autogen.cpp"
+#include "SkPdfWebCaptureCommandDictionary_autogen.cpp"
+#include "SkPdfAnnotationActionsDictionary_autogen.cpp"
+#include "SkPdfInkAnnotationDictionary_autogen.cpp"
+#include "SkPdfWindowsLaunchActionDictionary_autogen.cpp"
+#include "SkPdfBeadDictionary_autogen.cpp"
+#include "SkPdfPageObjectDictionary_autogen.cpp"
+#include "SkPdfType16HalftoneDictionary_autogen.cpp"
+#include "SkPdfObject_autogen.cpp"
+#include "SkPdfFontDescriptorDictionary_autogen.cpp"
+#include "SkPdfLaunchActionDictionary_autogen.cpp"
+#include "SkPdfType3FontDictionary_autogen.cpp"
+#include "SkPdfMovieActionDictionary_autogen.cpp"
+#include "SkPdfBorderStyleDictionary_autogen.cpp"
+#include "SkPdfNamedActionsDictionary_autogen.cpp"
+#include "SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.cpp"
+#include "SkPdfTrueTypeFontDictionary_autogen.cpp"
+#include "SkPdfJavascriptDictionary_autogen.cpp"
+#include "SkPdfFDFTrailerDictionary_autogen.cpp"
+#include "SkPdfMultiMasterFontDictionary_autogen.cpp"
+#include "SkPdfEmbeddedFileStreamDictionary_autogen.cpp"
+#include "SkPdfAppearanceDictionary_autogen.cpp"
+#include "SkPdfRadioButtonFieldDictionary_autogen.cpp"
+#include "SkPdfType6HalftoneDictionary_autogen.cpp"
+#include "SkPdfFDFNamedPageReferenceDictionary_autogen.cpp"
+#include "SkPdfReference_autogen.cpp"
+#include "SkPdfWebCaptureImageSetDictionary_autogen.cpp"
+#include "SkPdfBlockLevelStructureElementsDictionary_autogen.cpp"
+#include "SkPdfViewerPreferencesDictionary_autogen.cpp"
+#include "SkPdfType3FunctionDictionary_autogen.cpp"
+#include "SkPdfFieldDictionary_autogen.cpp"
+#include "SkPdfAnnotationDictionary_autogen.cpp"
+#include "SkPdfType3ShadingDictionary_autogen.cpp"
+#include "SkPdfType1HalftoneDictionary_autogen.cpp"
+#include "SkPdfActionDictionary_autogen.cpp"
+#include "SkPdfDocumentInformationDictionary_autogen.cpp"
+#include "SkPdfStructureElementDictionary_autogen.cpp"
+#include "SkPdfIccProfileStreamDictionary_autogen.cpp"
+#include "SkPdfType1FontDictionary_autogen.cpp"
+#include "SkPdfTextFieldDictionary_autogen.cpp"
+#include "SkPdfGroupAttributesDictionary_autogen.cpp"
+#include "SkPdfFileSpecificationDictionary_autogen.cpp"
+#include "SkPdfRubberStampAnnotationDictionary_autogen.cpp"
+#include "SkPdfSoftMaskImageDictionary_autogen.cpp"
+#include "SkPdfTrapNetworkAnnotationDictionary_autogen.cpp"
+#include "SkPdfRemoteGoToActionDictionary_autogen.cpp"
+#include "SkPdfMarkInformationDictionary_autogen.cpp"
+#include "SkPdfComponentsWithMetadataDictionary_autogen.cpp"
+#include "SkPdfString_autogen.cpp"
+#include "SkPdfAlternateImageDictionary_autogen.cpp"
+#include "SkPdfArtifactsDictionary_autogen.cpp"
+#include "SkPdfPrinterMarkFormDictionary_autogen.cpp"
+#include "SkPdfFreeTextAnnotationDictionary_autogen.cpp"
+#include "SkPdfLineAnnotationDictionary_autogen.cpp"
+#include "SkPdfFDFFileAnnotationDictionary_autogen.cpp"
+#include "SkPdfWebCaptureDictionary_autogen.cpp"
+#include "SkPdfPageObjectActionsDictionary_autogen.cpp"
+#include "SkPdfSeparationDictionary_autogen.cpp"
+#include "SkPdfSoftMaskDictionary_autogen.cpp"
+#include "SkPdfURLAliasDictionary_autogen.cpp"
+#include "SkPdfListAttributeDictionary_autogen.cpp"
+#include "SkPdfResourceDictionary_autogen.cpp"
+#include "SkPdfNameTreeNodeDictionary_autogen.cpp"
+#include "SkPdfIconFitDictionary_autogen.cpp"
+#include "SkPdfImportDataActionDictionary_autogen.cpp"
+#include "SkPdfTransparencyGroupDictionary_autogen.cpp"
+#include "SkPdfInteractiveFormDictionary_autogen.cpp"
+#include "SkPdfMovieActivationDictionary_autogen.cpp"
+#include "SkPdfPageLabelDictionary_autogen.cpp"
+#include "SkPdfLabColorSpaceDictionary_autogen.cpp"
+#include "SkPdfFDFCatalogDictionary_autogen.cpp"
+#include "SkPdfALinkAnnotationDictionary_autogen.cpp"
+#include "SkPdfAppearanceCharacteristicsDictionary_autogen.cpp"
+#include "SkPdfStream_autogen.cpp"
+#include "SkPdfTransitionDictionary_autogen.cpp"
+#include "SkPdfApplicationDataDictionary_autogen.cpp"
+#include "SkPdfFileAttachmentAnnotationDictionary_autogen.cpp"
+#include "SkPdfGraphicsStateDictionary_autogen.cpp"
+#include "SkPdfType0FontDictionary_autogen.cpp"
+#include "SkPdfMacOsFileInformationDictionary_autogen.cpp"
+#include "SkPdfWebCapturePageSetDictionary_autogen.cpp"
+#include "SkPdfNumberTreeNodeDictionary_autogen.cpp"
+#include "SkPdfURIActionDictionary_autogen.cpp"
+#include "SkPdfVariableTextFieldDictionary_autogen.cpp"
+#include "SkPdfJbig2DecodeFilterDictionary_autogen.cpp"
+#include "SkPdfSourceInformationDictionary_autogen.cpp"
+#include "SkPdfFDFDictionary_autogen.cpp"
+#include "SkPdfThreadActionDictionary_autogen.cpp"
+#include "SkPdfReferenceDictionary_autogen.cpp"
+#include "SkPdfEncodingDictionary_autogen.cpp"
+#include "SkPdfFDFFieldDictionary_autogen.cpp"
+#include "SkPdfAttributeObjectDictionary_autogen.cpp"
+#include "SkPdfCIDSystemInfoDictionary_autogen.cpp"
+#include "SkPdfMarkedContentReferenceDictionary_autogen.cpp"
+#include "SkPdfResetFormActionDictionary_autogen.cpp"
+#include "SkPdfDictionary_autogen.cpp"
+#include "SkPdfCalgrayColorSpaceDictionary_autogen.cpp"
+#include "SkPdfSquareOrCircleAnnotation_autogen.cpp"
+#include "SkPdfTableAttributesDictionary_autogen.cpp"
+#include "SkPdfSubmitFormActionDictionary_autogen.cpp"
+#include "SkPdfType2FunctionDictionary_autogen.cpp"
+#include "SkPdfCheckboxFieldDictionary_autogen.cpp"
+#include "SkPdfBoxStyleDictionary_autogen.cpp"
+#include "SkPdfInteger_autogen.cpp"
+#include "SkPdfType1PatternDictionary_autogen.cpp"
+#include "SkPdfHexString_autogen.cpp"
+#include "SkPdfPagePieceDictionary_autogen.cpp"
+#include "SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.cpp"
+#include "SkPdfWebCaptureCommandSettingsDictionary_autogen.cpp"
+#include "SkPdfType2ShadingDictionary_autogen.cpp"
+#include "SkPdfInlineLevelStructureElementsDictionary_autogen.cpp"
+#include "SkPdfMarkupAnnotationsDictionary_autogen.cpp"
+#include "SkPdfPopUpAnnotationDictionary_autogen.cpp"
+#include "SkPdfFormFieldActionsDictionary_autogen.cpp"
+#include "SkPdfTrapNetworkAppearanceStreamDictionary_autogen.cpp"
+#include "SkPdfSoundObjectDictionary_autogen.cpp"
+#include "SkPdfOutlineItemDictionary_autogen.cpp"
+#include "SkPdfCIDFontDescriptorDictionary_autogen.cpp"
+#include "SkPdfCMapDictionary_autogen.cpp"
+#include "SkPdfNumber_autogen.cpp"
+#include "SkPdfTextAnnotationDictionary_autogen.cpp"
+#include "SkPdfType2PatternDictionary_autogen.cpp"
+#include "SkPdfPSXobjectDictionary_autogen.cpp"
+#include "SkPdfOutlineDictionary_autogen.cpp"
+#include "SkPdfThreadDictionary_autogen.cpp"
+#include "SkPdfImageDictionary_autogen.cpp"
+#include "SkPdfCIDFontDictionary_autogen.cpp"
+#include "SkPdfType5ShadingDictionary_autogen.cpp"
+#include "SkPdfType5HalftoneDictionary_autogen.cpp"
+#include "SkPdfOpiVersionDictionary_autogen.cpp"
+#include "SkPdfStructureElementAccessDictionary_autogen.cpp"
+#include "SkPdfDocumentCatalogActionsDictionary_autogen.cpp"
+#include "SkPdfDeviceNColorSpaceDictionary_autogen.cpp"
+#include "SkPdfMovieDictionary_autogen.cpp"
+#include "SkPdfWidgetAnnotationDictionary_autogen.cpp"
+#include "SkPdfShadingDictionary_autogen.cpp"
+#include "SkPdfCatalogDictionary_autogen.cpp"
+#include "SkPdfStructureTreeRootDictionary_autogen.cpp"
+#include "SkPdfType6ShadingDictionary_autogen.cpp"
+#include "SkPdfFileTrailerDictionary_autogen.cpp"
+#include "SkPdfFDFTemplateDictionary_autogen.cpp"
+#include "SkPdfEmbeddedFileParameterDictionary_autogen.cpp"
+#include "SkPdfBoxColorInformationDictionary_autogen.cpp"
+#include "SkPdfXObjectDictionary_autogen.cpp"
+#include "SkPdfGoToActionDictionary_autogen.cpp"
+#include "SkPdfObjectReferenceDictionary_autogen.cpp"
+#include "SkPdfBoolean_autogen.cpp"
+#include "SkPdfWebCaptureInformationDictionary_autogen.cpp"
+#include "SkPdfStreamCommonDictionary_autogen.cpp"
+#include "SkPdfDctdecodeFilterDictionary_autogen.cpp"
+#include "SkPdfPrinterMarkAnnotationDictionary_autogen.cpp"
+#include "SkPdfStandardStructureDictionary_autogen.cpp"
+#include "SkPdfName_autogen.cpp"
+#include "SkPdfEncryptionCommonDictionary_autogen.cpp"
+#include "SkPdfStandardSecurityHandlerDictionary_autogen.cpp"
+#include "SkPdfSoundAnnotationDictionary_autogen.cpp"
+#include "SkPdfChoiceFieldDictionary_autogen.cpp"
+#include "SkPdfPDF_XOutputIntentDictionary_autogen.cpp"
+#include "SkPdfType4ShadingDictionary_autogen.cpp"
+#include "SkPdfSoundActionDictionary_autogen.cpp"
+#include "SkPdfNull_autogen.cpp"
+#include "SkPdfType10HalftoneDictionary_autogen.cpp"
+#include "SkPdfEmbeddedFontStreamDictionary_autogen.cpp"
+#include "SkPdfType1ShadingDictionary_autogen.cpp"
+#include "SkPdfNameDictionary_autogen.cpp"
+#include "SkPdfCcittfaxdecodeFilterDictionary_autogen.cpp"
+#include "SkPdfType1FormDictionary_autogen.cpp"
+#include "SkPdfFontDictionary_autogen.cpp"
+#include "SkPdfFunctionCommonDictionary_autogen.cpp"
+#include "SkPdfHideActionDictionary_autogen.cpp"
+#include "SkPdfURIDictionary_autogen.cpp"
+#include "SkPdfSignatureDictionary_autogen.cpp"
+#include "SkPdfArray_autogen.cpp"
+#include "SkPdfType0FunctionDictionary_autogen.cpp"
+#include "SkPdfFDFPageDictionary_autogen.cpp"
+#include "SkPdfCalrgbColorSpaceDictionary_autogen.cpp"
diff --git a/experimental/PdfViewer/autogen/SkPdfHexString_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfHexString_autogen.cpp
new file mode 100644
index 0000000..18d112d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfHexString_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfHexString_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.cpp
new file mode 100644
index 0000000..8c80d7a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfHideActionDictionary_autogen.h"
+
+std::string SkPdfHideActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfHideActionDictionary::getTAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfHideActionDictionary::getTAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfHideActionDictionary::getTAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+bool SkPdfHideActionDictionary::H() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.h
index e7a97fd..125f339 100644
--- a/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) The annotation or annotations to be hidden or shown, specified in any
* of the following forms:
* * An indirect reference to an annotation dictionary
@@ -557,39 +551,21 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getTAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getTAsDictionary() const;
bool isTAString() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getTAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getTAsString() const;
bool isTAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getTAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getTAsArray() const;
/** (Optional) A flag indicating whether to hide the annotation (true) or show it (false).
* Default value: true.
**/
@@ -597,13 +573,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", NULL));
}
- bool H() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool H() const;
};
#endif // __DEFINED__SkPdfHideActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.cpp
new file mode 100644
index 0000000..4bffd73
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfIccProfileStreamDictionary_autogen.h"
+
+long SkPdfIccProfileStreamDictionary::N() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfIccProfileStreamDictionary::getAlternateAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfIccProfileStreamDictionary::getAlternateAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfIccProfileStreamDictionary::Range() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfIccProfileStreamDictionary::Metadata() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.h
index 565cb34..e163528 100644
--- a/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", NULL));
}
- long N() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long N() const;
/** (Optional) An alternate color space to be used in case the one specified in the stream
* data is not supported (for example, by viewer applications designed for earlier
* versions of PDF). The alternate space may be any valid color space (except a Pattern
@@ -562,26 +556,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getAlternateAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getAlternateAsArray() const;
bool isAlternateAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getAlternateAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getAlternateAsName() const;
/** (Optional) An array of 2 x N numbers [min0 max0 min1 max1 ... ] specifying the
* minimum and maximum valid values of the corresponding color components.
* These values must match the information in the ICC profile. Default value:
@@ -591,13 +573,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", NULL));
}
- SkPdfArray* Range() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Range() const;
/** (Optional; PDF 1.4) A metadata stream containing metadata for the color space (see
* Section 9.2.2, "Metadata Streams").
**/
@@ -605,13 +581,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
}
- SkPdfStream* Metadata() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Metadata() const;
};
#endif // __DEFINED__SkPdfIccProfileStreamDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.cpp
new file mode 100644
index 0000000..d271706
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfIconFitDictionary_autogen.h"
+
+std::string SkPdfIconFitDictionary::SW() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SW", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfIconFitDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfIconFitDictionary::A() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.h
index 60f7889..b9b49cb 100644
--- a/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.h
@@ -537,13 +537,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SW", "", NULL));
}
- std::string SW() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SW", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string SW() const;
/** (Required) The type of scaling to use:
* A Anamorphic scaling: scale the icon to fill the annotation rectangle exactly, with-
* out regard to its original aspect ratio (ratio of width to height).
@@ -557,13 +551,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) An array of two numbers between 0.0 and 1.0 indicating the fraction of left-
* over space to allocate at the left and bottom of the icon. A value of [0.0 0.0] positions the
* icon at the bottom-left corner of the annotation rectangle; a value of [0.5 0.5] centers it
@@ -574,13 +562,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", NULL));
}
- SkPdfArray* A() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* A() const;
};
#endif // __DEFINED__SkPdfIconFitDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.cpp
new file mode 100644
index 0000000..a2c5eef
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.cpp
@@ -0,0 +1,142 @@
+#include "SkPdfImageDictionary_autogen.h"
+
+std::string SkPdfImageDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfImageDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfImageDictionary::Width() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfImageDictionary::Height() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfImageDictionary::getColorSpaceAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfImageDictionary::getColorSpaceAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfImageDictionary::BitsPerComponent() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfImageDictionary::Intent() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Intent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+bool SkPdfImageDictionary::ImageMask() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ImageMask", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+SkPdfStream* SkPdfImageDictionary::getMaskAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfImageDictionary::getMaskAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfImageDictionary::SMask() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfImageDictionary::Decode() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+bool SkPdfImageDictionary::Interpolate() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Interpolate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+SkPdfArray* SkPdfImageDictionary::Alternates() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternates", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfImageDictionary::Name() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfImageDictionary::StructParent() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfImageDictionary::ID() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfImageDictionary::OPI() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfImageDictionary::Metadata() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.h
index c46cf5f..8eb481a 100644
--- a/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.h
@@ -37,13 +37,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The type of XObject that this dictionary describes; must be
* Image for an image XObject.
**/
@@ -51,39 +45,21 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) The width of the image, in samples.
**/
bool has_Width() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", NULL));
}
- long Width() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Width() const;
/** (Required) The height of the image, in samples.
**/
bool has_Height() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", NULL));
}
- long Height() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Height() const;
/** (Required except for image masks; not allowed for image masks) The color
* space in which image samples are specified. This may be any type of color
* space except Pattern.
@@ -98,26 +74,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getColorSpaceAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getColorSpaceAsName() const;
bool isColorSpaceAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getColorSpaceAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getColorSpaceAsArray() const;
/** (Required except for image masks; optional for image masks) The number of
* bits used to represent each color component. Only a single value may be
* specified; the number of bits is the same for all color components. Valid
@@ -134,13 +98,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", NULL));
}
- long BitsPerComponent() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long BitsPerComponent() const;
/** (Optional; PDF 1.1) The name of a color rendering intent to be used in
* rendering the image (see "Rendering Intents" on page 197). Default value:
* the current rendering intent in the graphics state.
@@ -149,13 +107,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Intent", "", NULL));
}
- std::string Intent() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Intent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Intent() const;
/** (Optional) A flag indicating whether the image is to be treated as an image
* mask (see Section 4.8.5, "Masked Images"). If this flag is true, the value of
* BitsPerComponent must be 1 and Mask and ColorSpace should not be
@@ -166,13 +118,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ImageMask", "", NULL));
}
- bool ImageMask() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ImageMask", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool ImageMask() const;
/** (Optional except for image masks; not allowed for image masks; PDF 1.3) An
* image XObject defining an image mask to be applied to this image (see
* "Explicit Masking" on page 277), or an array specifying a range of colors
@@ -190,26 +136,14 @@
return ret->podofo()->HasStream();
}
- SkPdfStream* getMaskAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getMaskAsStream() const;
bool isMaskAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getMaskAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getMaskAsArray() const;
/** (Optional; PDF 1.4) A subsidiary image XObject defining a soft-mask
* image (see "Soft-Mask Images" on page 447) to be used as a source of
* mask shape or mask opacity values in the transparent imaging model. The
@@ -225,13 +159,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", NULL));
}
- SkPdfStream* SMask() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* SMask() const;
/** (Optional) An array of numbers describing how to map image samples
* into the range of values appropriate for the image's color space (see
* "Decode Arrays" on page 271). If ImageMask is true, the array must be
@@ -243,13 +171,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", NULL));
}
- SkPdfArray* Decode() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Decode() const;
/** (Optional) A flag indicating whether image interpolation is to be per-
* formed (see "Image Interpolation" on page 273). Default value: false.
**/
@@ -257,13 +179,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Interpolate", "", NULL));
}
- bool Interpolate() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Interpolate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool Interpolate() const;
/** (Optional; PDF 1.3) An array of alternate image dictionaries for this image
* (see "Alternate Images" on page 273). The order of elements within the
* array has no significance. This entry may not be present in an image
@@ -273,13 +189,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternates", "", NULL));
}
- SkPdfArray* Alternates() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternates", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Alternates() const;
/** (Required in PDF 1.0; optional otherwise) The name by which this image
* XObject is referenced in the XObject subdictionary of the current resource
* dictionary (see Section 3.7.2, "Resource Dictionaries").
@@ -290,13 +200,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
}
- std::string Name() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Name() const;
/** (Required if the image is a structural content item; PDF 1.3) The integer key
* of the image's entry in the structural parent tree (see "Finding Structure
* Elements from Content Items" on page 600).
@@ -305,13 +209,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", NULL));
}
- long StructParent() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long StructParent() const;
/** (Optional; PDF 1.3; indirect reference preferred) The digital identifier of the
* image's parent Web Capture content set (see Section 9.9.5, "Object At-
* tributes Related to Web Capture").
@@ -320,13 +218,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
}
- std::string ID() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string ID() const;
/** (Optional; PDF 1.2) An OPI version dictionary for the image (see Section
* 9.10.6, "Open Prepress Interface (OPI)"). If ImageMask is true, this entry
* is ignored.
@@ -335,13 +227,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", NULL));
}
- SkPdfDictionary* OPI() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* OPI() const;
/** (Optional; PDF 1.4) A metadata stream containing metadata for the image
* (see Section 9.2.2, "Metadata Streams").
**/
@@ -349,13 +235,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
}
- SkPdfStream* Metadata() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Metadata() const;
};
#endif // __DEFINED__SkPdfImageDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.cpp
new file mode 100644
index 0000000..0b1d026
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfImportDataActionDictionary_autogen.h"
+
+std::string SkPdfImportDataActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfFileSpec SkPdfImportDataActionDictionary::F() const {
+ SkPdfFileSpec ret;
+ if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFileSpec();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.h
index 896dd6b..8c51cd2 100644
--- a/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) The FDF file from which to import the data. (See implementation
* notes 87 and 88 in Appendix H.)
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- SkPdfFileSpec F() const {
- SkPdfFileSpec ret;
- if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFileSpec();
- }
-
+ SkPdfFileSpec F() const;
};
#endif // __DEFINED__SkPdfImportDataActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..351d9cc
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfInkAnnotationDictionary_autogen.h"
+
+std::string SkPdfInkAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfInkAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfInkAnnotationDictionary::InkList() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InkList", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfInkAnnotationDictionary::BS() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.h
index 7347299..943846b 100644
--- a/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) The text to be displayed in the pop-up window when the annotation
* is opened. Carriage returns may be used to separate the text into paragraphs.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Required) An array of n arrays, each representing a stroked path. Each array is a
* series of alternating horizontal and vertical coordinates in default user space,
* specifying points along the path. When drawn, the points are connected by
@@ -563,13 +551,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InkList", "", NULL));
}
- SkPdfArray* InkList() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InkList", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* InkList() const;
/** (Optional) A border style dictionary (see Table 8.12 on page 495) specifying the
* line width and dash pattern to be used in drawing the paths.
* Note: The annotation dictionary's AP entry, if present, takes precedence over the
@@ -580,13 +562,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", NULL));
}
- SkPdfDictionary* BS() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* BS() const;
};
#endif // __DEFINED__SkPdfInkAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.cpp
new file mode 100644
index 0000000..495d722
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfInlineLevelStructureElementsDictionary_autogen.h"
+
+double SkPdfInlineLevelStructureElementsDictionary::getLineHeightAsNumber() const {
+ double ret = 0;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfInlineLevelStructureElementsDictionary::getLineHeightAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.h
index 1c8a9bd..1fad174 100644
--- a/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.h
@@ -547,26 +547,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Real || ret->podofo()->GetDataType() == ePdfDataType_Number;
}
- double getLineHeightAsNumber() const {
- double ret = 0;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double getLineHeightAsNumber() const;
bool isLineHeightAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getLineHeightAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getLineHeightAsName() const;
};
#endif // __DEFINED__SkPdfInlineLevelStructureElementsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfInteger_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfInteger_autogen.cpp
new file mode 100644
index 0000000..a95fd0d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfInteger_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfInteger_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.cpp
new file mode 100644
index 0000000..301c91d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfInteractiveFormDictionary_autogen.h"
+
+SkPdfArray* SkPdfInteractiveFormDictionary::Fields() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+bool SkPdfInteractiveFormDictionary::NeedAppearances() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NeedAppearances", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+long SkPdfInteractiveFormDictionary::SigFlags() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SigFlags", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfInteractiveFormDictionary::CO() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfInteractiveFormDictionary::DR() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfInteractiveFormDictionary::DA() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfInteractiveFormDictionary::Q() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.h
index 2837857..8720dce 100644
--- a/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", NULL));
}
- SkPdfArray* Fields() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Fields() const;
/** (Optional) A flag specifying whether to construct appearance streams and
* appearance dictionaries for all widget annotations in the document (see
* "Variable Text" on page 533). Default value: false.
@@ -547,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NeedAppearances", "", NULL));
}
- bool NeedAppearances() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NeedAppearances", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool NeedAppearances() const;
/** (Optional; PDF 1.3) A set of flags specifying various document-level char-
* acteristics related to signature fields (see Table 8.48, below, and "Signature
* Fields" on page 547). Default value: 0.
@@ -562,13 +550,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SigFlags", "", NULL));
}
- long SigFlags() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SigFlags", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long SigFlags() const;
/** (Required if any fields in the document have additional-actions dictionaries
* containing a C entry; PDF 1.3) An array of indirect references to field dic-
* tionaries with calculation actions, defining the calculation order in which
@@ -579,13 +561,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", NULL));
}
- SkPdfArray* CO() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* CO() const;
/** (Optional) A document-wide default value for the DR attribute of variable
* text fields (see "Variable Text" on page 533).
**/
@@ -593,13 +569,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", NULL));
}
- SkPdfDictionary* DR() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* DR() const;
/** (Optional) A document-wide default value for the DA attribute of variable
* text fields (see "Variable Text" on page 533).
**/
@@ -607,13 +577,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", NULL));
}
- std::string DA() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string DA() const;
/** (Optional) A document-wide default value for the Q attribute of variable
* text fields (see "Variable Text" on page 533).
**/
@@ -621,13 +585,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", NULL));
}
- long Q() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Q() const;
};
#endif // __DEFINED__SkPdfInteractiveFormDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.cpp
new file mode 100644
index 0000000..c31145f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfJavascriptActionDictionary_autogen.h"
+
+std::string SkPdfJavascriptActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfJavascriptActionDictionary::getJSAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfJavascriptActionDictionary::getJSAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.h
index fdac070..fa3a1ae 100644
--- a/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) A string or stream containing the JavaScript script to be executed.
* Note: PDFDocEncoding or Unicode encoding (the latter identified by the Unicode
* prefix U+ FEFF) is used to encode the contents of the string or stream. (See imple-
@@ -554,26 +548,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getJSAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getJSAsString() const;
bool isJSAStream() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return false;
return ret->podofo()->HasStream();
}
- SkPdfStream* getJSAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getJSAsStream() const;
};
#endif // __DEFINED__SkPdfJavascriptActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.cpp
new file mode 100644
index 0000000..8204e69
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfJavascriptDictionary_autogen.h"
+
+std::string SkPdfJavascriptDictionary::getBeforeAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfJavascriptDictionary::getBeforeAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfJavascriptDictionary::getAfterAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfJavascriptDictionary::getAfterAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfJavascriptDictionary::Doc() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Doc", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.h
index 4a1ee00..42f3ba5 100644
--- a/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.h
@@ -538,26 +538,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getBeforeAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getBeforeAsString() const;
bool isBeforeAStream() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return false;
return ret->podofo()->HasStream();
}
- SkPdfStream* getBeforeAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getBeforeAsStream() const;
/** (Optional) A string or stream containing a JavaScript script to be executed
* just after the FDF file is imported.
**/
@@ -571,26 +559,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getAfterAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getAfterAsString() const;
bool isAfterAStream() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return false;
return ret->podofo()->HasStream();
}
- SkPdfStream* getAfterAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getAfterAsStream() const;
/** (Optional) An array defining additional JavaScript scripts to be added to
* those defined in the JavaScript entry of the document's name dictionary (see
* Section 3.6.3, "Name Dictionary"). The array contains an even number of
@@ -605,13 +581,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Doc", "", NULL));
}
- SkPdfArray* Doc() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Doc", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Doc() const;
};
#endif // __DEFINED__SkPdfJavascriptDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.cpp
new file mode 100644
index 0000000..d86a9cf
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfJbig2DecodeFilterDictionary_autogen.h"
+
+SkPdfStream* SkPdfJbig2DecodeFilterDictionary::JBIG2Globals() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JBIG2Globals", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.h
index 2f457fb..ecb6fc7 100644
--- a/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JBIG2Globals", "", NULL));
}
- SkPdfStream* JBIG2Globals() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JBIG2Globals", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* JBIG2Globals() const;
};
#endif // __DEFINED__SkPdfJbig2DecodeFilterDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.cpp
new file mode 100644
index 0000000..ddc3a19
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfLabColorSpaceDictionary_autogen.h"
+
+SkPdfArray* SkPdfLabColorSpaceDictionary::WhitePoint() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfLabColorSpaceDictionary::BlackPoint() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfLabColorSpaceDictionary::Range() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.h
index 52fb023..bc8dd7e 100644
--- a/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.h
@@ -534,13 +534,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", NULL));
}
- SkPdfArray* WhitePoint() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* WhitePoint() const;
/** (Optional) An array of three numbers [ XB YB ZB ] specifying the tristimulus value, in
* the CIE 1931 XYZ space, of the diffuse black point; see "CalRGB Color Spaces" on
* page 184 for further discussion. All three of these numbers must be nonnegative.
@@ -550,13 +544,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", NULL));
}
- SkPdfArray* BlackPoint() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* BlackPoint() const;
/** (Optional) An array of four numbers [ amin amax bmin bmax ] specifying the range of
* valid values for the a* and b* (B and C) components of the color space-that is,
* a min <= a* <= a max
@@ -569,13 +557,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", NULL));
}
- SkPdfArray* Range() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Range() const;
};
#endif // __DEFINED__SkPdfLabColorSpaceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.cpp
new file mode 100644
index 0000000..b643d15
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfLaunchActionDictionary_autogen.h"
+
+std::string SkPdfLaunchActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfFileSpec SkPdfLaunchActionDictionary::F() const {
+ SkPdfFileSpec ret;
+ if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFileSpec();
+}
+
+SkPdfDictionary* SkPdfLaunchActionDictionary::Win() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Win", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfObject* SkPdfLaunchActionDictionary::Mac() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfObject* SkPdfLaunchActionDictionary::Unix() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+bool SkPdfLaunchActionDictionary::NewWindow() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.h
index 5fbb763..f3bc768 100644
--- a/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required if none of the entries Win, Mac, or Unix is present) The application to
* be launched or the document to be opened or printed. If this entry is absent
* and the viewer application does not understand any of the alternative entries,
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- SkPdfFileSpec F() const {
- SkPdfFileSpec ret;
- if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFileSpec();
- }
-
+ SkPdfFileSpec F() const;
/** (Optional) A dictionary containing Windows-specific launch parameters (see
* the Table 8.38; see also implementation note 73 in Appendix H).
**/
@@ -562,39 +550,21 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Win", "", NULL));
}
- SkPdfDictionary* Win() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Win", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Win() const;
/** (Optional) Mac OS'specific launch parameters; not yet defined.
**/
bool has_Mac() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", NULL));
}
- SkPdfObject* Mac() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* Mac() const;
/** (Optional) UNIX-specific launch parameters; not yet defined.
**/
bool has_Unix() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", NULL));
}
- SkPdfObject* Unix() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* Unix() const;
/** (Optional; PDF 1.2) A flag specifying whether to open the destination docu-
* ment in a new window. If this flag is false, the destination document will
* replace the current document in the same window. If this entry is absent, the
@@ -606,13 +576,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", NULL));
}
- bool NewWindow() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool NewWindow() const;
};
#endif // __DEFINED__SkPdfLaunchActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..d5c040a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfLineAnnotationDictionary_autogen.h"
+
+std::string SkPdfLineAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfLineAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfLineAnnotationDictionary::L() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfLineAnnotationDictionary::BS() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfLineAnnotationDictionary::LE() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LE", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfLineAnnotationDictionary::IC() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.h
index 29f5758..0a0716b 100644
--- a/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) The text to be displayed in the pop-up window when the annotation
* is opened. Carriage returns may be used to separate the text into paragraphs.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Required) An array of four numbers, [x1 y1 x2 y2 ], specifying the starting and
* ending coordinates of the line in default user space.
**/
@@ -560,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", NULL));
}
- SkPdfArray* L() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* L() const;
/** (Optional) A border style dictionary (see Table 8.12 on page 495) specifying the
* width and dash pattern to be used in drawing the line.
* Note: The annotation dictionary's AP entry, if present, takes precedence over the L
@@ -576,13 +558,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", NULL));
}
- SkPdfDictionary* BS() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* BS() const;
/** (Optional; PDF 1.4) An array of two names specifying the line ending styles to be
* used in drawing the line. The first and second elements of the array specify the
* line ending styles for the endpoints defined, respectively, by the first and second
@@ -593,13 +569,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LE", "", NULL));
}
- SkPdfArray* LE() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LE", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* LE() const;
/** (Optional; PDF 1.4) An array of three numbers in the range 0.0 to 1.0 specifying
* the components, in the DeviceRGB color space, of the interior color with which to
* fill the annotation's line endings (see Table 8.19). If this entry is absent, the inte-
@@ -609,13 +579,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", NULL));
}
- SkPdfArray* IC() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* IC() const;
};
#endif // __DEFINED__SkPdfLineAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.cpp
new file mode 100644
index 0000000..8d6b29e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfListAttributeDictionary_autogen.h"
+
+std::string SkPdfListAttributeDictionary::ListNumbering() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ListNumbering", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.h
index 8b8bbe3..7463e3b 100644
--- a/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.h
@@ -548,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ListNumbering", "", NULL));
}
- std::string ListNumbering() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ListNumbering", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string ListNumbering() const;
};
#endif // __DEFINED__SkPdfListAttributeDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.cpp
new file mode 100644
index 0000000..8b3541d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.h"
+
+long SkPdfLzwdecodeAndFlatedecodeFiltersDictionary::Predictor() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Predictor", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfLzwdecodeAndFlatedecodeFiltersDictionary::Colors() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colors", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfLzwdecodeAndFlatedecodeFiltersDictionary::BitsPerComponent() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfLzwdecodeAndFlatedecodeFiltersDictionary::Columns() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfLzwdecodeAndFlatedecodeFiltersDictionary::EarlyChange() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EarlyChange", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.h
index eb43ba2..08f8e00 100644
--- a/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.h
@@ -536,13 +536,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Predictor", "", NULL));
}
- long Predictor() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Predictor", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Predictor() const;
/** (Used only if Predictor is greater than 1) The number of interleaved color com-
* ponents per sample. Valid values are 1 to 4 in PDF 1.2 or earlier, and 1 or
* greater in PDF 1.3 or later. Default value: 1.
@@ -551,13 +545,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colors", "", NULL));
}
- long Colors() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colors", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Colors() const;
/** (Used only if Predictor is greater than 1) The number of bits used to represent
* each color component in a sample. Valid values are 1, 2, 4, and 8. Default
* value: 8.
@@ -566,13 +554,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", NULL));
}
- long BitsPerComponent() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long BitsPerComponent() const;
/** (Used only if Predictor is greater than 1) The number of samples in each row.
* Default value: 1.
**/
@@ -580,13 +562,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", NULL));
}
- long Columns() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Columns() const;
/** (LZWDecode only) An indication of when to increase the code length. If the
* value of this entry is 0, code length increases are postponed as long as pos-
* sible. If it is 1, they occur one code early. This parameter is included because
@@ -597,13 +573,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EarlyChange", "", NULL));
}
- long EarlyChange() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EarlyChange", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long EarlyChange() const;
};
#endif // __DEFINED__SkPdfLzwdecodeAndFlatedecodeFiltersDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.cpp
new file mode 100644
index 0000000..d43e0e7
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfMacOsFileInformationDictionary_autogen.h"
+
+std::string SkPdfMacOsFileInformationDictionary::Subtype() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfMacOsFileInformationDictionary::Creator() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfMacOsFileInformationDictionary::ResFork() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ResFork", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.h
index 5e070c8..f6b2eaa 100644
--- a/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.h
@@ -531,39 +531,21 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Optional) The embedded file's creator signature.
**/
bool has_Creator() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", NULL));
}
- std::string Creator() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Creator() const;
/** (Optional) The binary contents of the embedded file's resource fork.
**/
bool has_ResFork() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ResFork", "", NULL));
}
- SkPdfStream* ResFork() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ResFork", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* ResFork() const;
};
#endif // __DEFINED__SkPdfMacOsFileInformationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.cpp
new file mode 100644
index 0000000..2a5c8ec
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfMarkInformationDictionary_autogen.h"
+
+bool SkPdfMarkInformationDictionary::Marked() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Marked", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.h
index c88d491..3a3a2b9 100644
--- a/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Marked", "", NULL));
}
- bool Marked() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Marked", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool Marked() const;
};
#endif // __DEFINED__SkPdfMarkInformationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.cpp
new file mode 100644
index 0000000..0b8cf8a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfMarkedContentReferenceDictionary_autogen.h"
+
+std::string SkPdfMarkedContentReferenceDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfMarkedContentReferenceDictionary::Pg() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfMarkedContentReferenceDictionary::Stm() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Stm", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfObject* SkPdfMarkedContentReferenceDictionary::StmOwn() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StmOwn", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfMarkedContentReferenceDictionary::MCID() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MCID", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.h
index bf0f64f..1e3522b 100644
--- a/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Optional; must be an indirect reference) The page object representing the page on
* which the graphics objects in the marked-content sequence are rendered. This
* entry overrides any Pg entry in the structure element containing the marked-
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", NULL));
}
- SkPdfDictionary* Pg() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Pg() const;
/** (Optional; must be an indirect reference) The content stream containing the
* marked-content sequence. This entry is needed only if the marked-content
* sequence resides in some other content stream associated with the page-for
@@ -566,13 +554,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Stm", "", NULL));
}
- SkPdfStream* Stm() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Stm", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Stm() const;
/** (Optional; must be an indirect reference) The PDF object owning the stream
* identified by Stm-for example, the annotation to which an appearance stream
* belongs.
@@ -581,13 +563,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StmOwn", "", NULL));
}
- SkPdfObject* StmOwn() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StmOwn", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* StmOwn() const;
/** (Required) The marked-content identifier of the marked-content sequence with-
* in its content stream.
**/
@@ -595,13 +571,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MCID", "", NULL));
}
- long MCID() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MCID", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long MCID() const;
};
#endif // __DEFINED__SkPdfMarkedContentReferenceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.cpp
new file mode 100644
index 0000000..440c92a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfMarkupAnnotationsDictionary_autogen.h"
+
+std::string SkPdfMarkupAnnotationsDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfMarkupAnnotationsDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfMarkupAnnotationsDictionary::QuadPoints() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "QuadPoints", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.h
index dc754b2..747ac24 100644
--- a/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) The text to be displayed in the pop-up window when the annota-
* tion is opened. Carriage returns may be used to separate the text into para-
* graphs.
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Required) An array of 8 x n numbers specifying the coordinates of n quadri-
* laterals in default user space. Each quadrilateral encompasses a word or
* group of contiguous words in the text underlying the annotation. The coor-
@@ -579,13 +567,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "QuadPoints", "", NULL));
}
- SkPdfArray* QuadPoints() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "QuadPoints", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* QuadPoints() const;
};
#endif // __DEFINED__SkPdfMarkupAnnotationsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.cpp
new file mode 100644
index 0000000..6ce1677
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfMetadataStreamDictionary_autogen.h"
+
+std::string SkPdfMetadataStreamDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfMetadataStreamDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.h
index 0c8798f..2724d10 100644
--- a/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The type of metadata stream that this dictionary describes; must be
* XML.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
};
#endif // __DEFINED__SkPdfMetadataStreamDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.cpp
new file mode 100644
index 0000000..9211e45
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfMovieActionDictionary_autogen.h"
+
+std::string SkPdfMovieActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfMovieActionDictionary::Annot() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annot", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfMovieActionDictionary::T() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfMovieActionDictionary::Operation() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Operation", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.h
index 2b2e193..41348bc 100644
--- a/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Optional) An indirect reference to a movie annotation identifying the movie
* to be played.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annot", "", NULL));
}
- SkPdfDictionary* Annot() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annot", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Annot() const;
/** (Optional) The title of a movie annotation identifying the movie to be
* played.
* Note: The dictionary must include either an Annot or a T entry, but not both.
@@ -561,13 +549,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
}
- std::string T() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string T() const;
/** (Optional) The operation to be performed on the movie:
* Play Start playing the movie, using the play mode specified by the
* dictionary's Mode entry (see Table 8.79 on page 571). If the
@@ -583,13 +565,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Operation", "", NULL));
}
- std::string Operation() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Operation", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Operation() const;
};
#endif // __DEFINED__SkPdfMovieActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.cpp
new file mode 100644
index 0000000..1d327a5
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.cpp
@@ -0,0 +1,65 @@
+#include "SkPdfMovieActivationDictionary_autogen.h"
+
+SkPdfObject* SkPdfMovieActivationDictionary::Start() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Start", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfObject* SkPdfMovieActivationDictionary::Duration() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Duration", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+double SkPdfMovieActivationDictionary::Rate() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfMovieActivationDictionary::Volume() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+bool SkPdfMovieActivationDictionary::ShowControls() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShowControls", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+std::string SkPdfMovieActivationDictionary::Mode() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+bool SkPdfMovieActivationDictionary::Synchronous() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+SkPdfArray* SkPdfMovieActivationDictionary::FWScale() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWScale", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfMovieActivationDictionary::FWPosition() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWPosition", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.h
index 88fe52b..b3702db 100644
--- a/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.h
@@ -544,13 +544,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Start", "", NULL));
}
- SkPdfObject* Start() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Start", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* Start() const;
/** (Optional) The duration of the movie segment to be played, specified in the
* same form as Start. Negative values specify that the movie is to be played
* backward. If this entry is omitted, the movie is played to the end.
@@ -559,13 +553,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Duration", "", NULL));
}
- SkPdfObject* Duration() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Duration", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* Duration() const;
/** (Optional) The initial speed at which to play the movie. If the value of this
* entry is negative, the movie is played backward with respect to Start and
* Duration. Default value: 1.0.
@@ -574,13 +562,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rate", "", NULL));
}
- double Rate() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double Rate() const;
/** (Optional) The initial sound volume at which to play the movie, in the range
* -1.0 to 1.0. Higher values denote greater volume; negative values mute the
* sound. Default value: 1.0.
@@ -589,13 +571,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", NULL));
}
- double Volume() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double Volume() const;
/** (Optional) A flag specifying whether to display a movie controller bar while
* playing the movie. Default value: false.
**/
@@ -603,13 +579,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShowControls", "", NULL));
}
- bool ShowControls() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShowControls", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool ShowControls() const;
/** (Optional) The play mode for playing the movie:
* Once Play once and stop.
* Open Play and leave the movie controller bar open.
@@ -621,13 +591,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mode", "", NULL));
}
- std::string Mode() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Mode() const;
/** (Optional) A flag specifying whether to play the movie synchronously or
* asynchronously. If this value is true, the movie player will retain control until
* the movie is completed or dismissed by the user; if false, it will return control
@@ -638,13 +602,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", NULL));
}
- bool Synchronous() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool Synchronous() const;
/** (Optional) The magnification (zoom) factor at which to play the movie. The
* presence of this entry implies that the movie is to be played in a floating win-
* dow; if the entry is absent, it will be played in the annotation rectangle.
@@ -658,13 +616,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWScale", "", NULL));
}
- SkPdfArray* FWScale() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWScale", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* FWScale() const;
/** (Optional) For floating play windows, the relative position of the window on
* the screen. The value is an array of two numbers
* [horiz vert]
@@ -677,13 +629,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWPosition", "", NULL));
}
- SkPdfArray* FWPosition() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWPosition", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* FWPosition() const;
};
#endif // __DEFINED__SkPdfMovieActivationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..d2e375e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfMovieAnnotationDictionary_autogen.h"
+
+std::string SkPdfMovieAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfMovieAnnotationDictionary::Movie() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Movie", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfMovieAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+bool SkPdfMovieAnnotationDictionary::getAAsBoolean() const {
+ bool ret = false;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+SkPdfDictionary* SkPdfMovieAnnotationDictionary::getAAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.h
index db13412..5f0218e 100644
--- a/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) A movie dictionary describing the movie's static characteristics (see
* Section 8.8, "Movies").
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Movie", "", NULL));
}
- SkPdfDictionary* Movie() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Movie", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Movie() const;
/** (Optional; PDF 1.4) An alternate representation of the annotation's contents in
* human-readable form, useful when extracting the document's contents in sup-
* port of accessibility to disabled users or for other purposes (see Section 9.8.2,
@@ -562,13 +550,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Optional) A flag or dictionary specifying whether and how to play the movie
* when the annotation is activated. If this value is a dictionary, it is a movie activa-
* tion dictionary (see Section 8.8, "Movies") specifying how to play the movie; if it
@@ -586,26 +568,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Bool;
}
- bool getAAsBoolean() const {
- bool ret = false;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool getAAsBoolean() const;
bool isAADictionary() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getAAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getAAsDictionary() const;
};
#endif // __DEFINED__SkPdfMovieAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.cpp
new file mode 100644
index 0000000..8f3ba01
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfMovieDictionary_autogen.h"
+
+SkPdfFileSpec SkPdfMovieDictionary::F() const {
+ SkPdfFileSpec ret;
+ if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFileSpec();
+}
+
+SkPdfArray* SkPdfMovieDictionary::Aspect() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Aspect", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfMovieDictionary::Rotate() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+bool SkPdfMovieDictionary::getPosterAsBoolean() const {
+ bool ret = false;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+SkPdfStream* SkPdfMovieDictionary::getPosterAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.h
index 9173414..2fe0d5b 100644
--- a/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- SkPdfFileSpec F() const {
- SkPdfFileSpec ret;
- if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFileSpec();
- }
-
+ SkPdfFileSpec F() const;
/** (Optional) The width and height of the movie's bounding box, in pixels,
* specified as [width height]. This entry should be omitted for a movie consist-
* ing entirely of sound with no visible images.
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Aspect", "", NULL));
}
- SkPdfArray* Aspect() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Aspect", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Aspect() const;
/** (Optional) The number of degrees by which the movie is rotated clockwise
* relative to the page. The value must be a multiple of 90. Default value: 0.
**/
@@ -562,13 +550,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", NULL));
}
- long Rotate() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Rotate() const;
/** (Optional) A flag or stream specifying whether and how to display a poster
* image representing the movie. If this value is a stream, it contains an image
* XObject (see Section 4.8, "Images") to be displayed as the poster; if it is the
@@ -585,26 +567,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Bool;
}
- bool getPosterAsBoolean() const {
- bool ret = false;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool getPosterAsBoolean() const;
bool isPosterAStream() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return false;
return ret->podofo()->HasStream();
}
- SkPdfStream* getPosterAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getPosterAsStream() const;
};
#endif // __DEFINED__SkPdfMovieDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.cpp
new file mode 100644
index 0000000..7cc1b8f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfMultiMasterFontDictionary_autogen.h"
+
+std::string SkPdfMultiMasterFontDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.h
index 766cf06..6009cb3 100644
--- a/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.h
@@ -36,13 +36,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
};
#endif // __DEFINED__SkPdfMultiMasterFontDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.cpp
new file mode 100644
index 0000000..8cbdd45
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.cpp
@@ -0,0 +1,114 @@
+#include "SkPdfNameDictionary_autogen.h"
+
+std::string SkPdfNameDictionary::getDestsAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getDestsAsTree() const {
+ SkPdfTree* ret = NULL;
+ if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfNameDictionary::getAPAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getAPAsTree() const {
+ SkPdfTree* ret = NULL;
+ if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfNameDictionary::getJavaScriptAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getJavaScriptAsTree() const {
+ SkPdfTree* ret = NULL;
+ if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfNameDictionary::getPagesAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getPagesAsTree() const {
+ SkPdfTree* ret = NULL;
+ if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfNameDictionary::getTemplatesAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getTemplatesAsTree() const {
+ SkPdfTree* ret = NULL;
+ if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfNameDictionary::getIDSAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getIDSAsTree() const {
+ SkPdfTree* ret = NULL;
+ if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfNameDictionary::getURLSAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getURLSAsTree() const {
+ SkPdfTree* ret = NULL;
+ if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfNameDictionary::getEmbeddedFilesAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getEmbeddedFilesAsTree() const {
+ SkPdfTree* ret = NULL;
+ if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.h
index 2e1e824..45afd1f 100644
--- a/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.h
@@ -538,26 +538,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getDestsAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getDestsAsName() const;
bool isDestsATree() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfTree* getDestsAsTree() const {
- SkPdfTree* ret = NULL;
- if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfTree* getDestsAsTree() const;
/** (Optional; PDF 1.3) A name tree mapping name strings to annotation
* appearance streams (see Section 8.4.4, "Appearance Streams").
**/
@@ -571,26 +559,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getAPAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getAPAsName() const;
bool isAPATree() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfTree* getAPAsTree() const {
- SkPdfTree* ret = NULL;
- if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfTree* getAPAsTree() const;
/** (Optional; PDF 1.3) A name tree mapping name strings to document-level
* JavaScript(R) actions (see "JavaScript Actions" on page 556).
**/
@@ -604,26 +580,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getJavaScriptAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getJavaScriptAsName() const;
bool isJavaScriptATree() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfTree* getJavaScriptAsTree() const {
- SkPdfTree* ret = NULL;
- if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfTree* getJavaScriptAsTree() const;
/** (Optional; PDF 1.3) A name tree mapping name strings to visible pages for
* use in interactive forms (see Section 8.6.5, "Named Pages").
**/
@@ -637,26 +601,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getPagesAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getPagesAsName() const;
bool isPagesATree() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfTree* getPagesAsTree() const {
- SkPdfTree* ret = NULL;
- if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfTree* getPagesAsTree() const;
/** (Optional; PDF 1.3) A name tree mapping name strings to invisible (tem-
* plate) pages for use in interactive forms (see Section 8.6.5, "Named Pages").
**/
@@ -670,26 +622,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getTemplatesAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getTemplatesAsName() const;
bool isTemplatesATree() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfTree* getTemplatesAsTree() const {
- SkPdfTree* ret = NULL;
- if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfTree* getTemplatesAsTree() const;
/** (Optional; PDF 1.3) A name tree mapping digital identifiers to Web Capture
* content sets (see Section 9.9.3, "Content Sets").
**/
@@ -703,26 +643,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getIDSAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getIDSAsName() const;
bool isIDSATree() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfTree* getIDSAsTree() const {
- SkPdfTree* ret = NULL;
- if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfTree* getIDSAsTree() const;
/** (Optional; PDF 1.3) A name tree mapping uniform resource locators (URLs)
* to Web Capture content sets (see Section 9.9.3, "Content Sets").
**/
@@ -736,26 +664,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getURLSAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getURLSAsName() const;
bool isURLSATree() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfTree* getURLSAsTree() const {
- SkPdfTree* ret = NULL;
- if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfTree* getURLSAsTree() const;
/** (Optional; PDF 1.4) A name tree mapping name strings to embedded file
* streams (see Section 3.10.3, "Embedded File Streams").
**/
@@ -769,26 +685,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getEmbeddedFilesAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getEmbeddedFilesAsName() const;
bool isEmbeddedFilesATree() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfTree* getEmbeddedFilesAsTree() const {
- SkPdfTree* ret = NULL;
- if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfTree* getEmbeddedFilesAsTree() const;
};
#endif // __DEFINED__SkPdfNameDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.cpp
new file mode 100644
index 0000000..e677440
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfNameTreeNodeDictionary_autogen.h"
+
+SkPdfArray* SkPdfNameTreeNodeDictionary::Kids() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfNameTreeNodeDictionary::Names() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfNameTreeNodeDictionary::Limits() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.h
index 6a9afd4..e92e293 100644
--- a/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", NULL));
}
- SkPdfArray* Kids() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Kids() const;
/** (Root and leaf nodes only; required in leaf nodes; present in the root node if and only if Kids
* is not present) An array of the form
* [key1 value1 key2 value2 ... keyn valuen ]
@@ -550,13 +544,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", NULL));
}
- SkPdfArray* Names() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Names() const;
/** (Intermediate and leaf nodes only; required) An array of two strings, specifying the (lexi-
* cally) least and greatest keys included in the Names array of a leaf node or in the Names
* arrays of any leaf nodes that are descendants of an intermediate node.
@@ -565,13 +553,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", NULL));
}
- SkPdfArray* Limits() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Limits() const;
};
#endif // __DEFINED__SkPdfNameTreeNodeDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfName_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfName_autogen.cpp
new file mode 100644
index 0000000..d986d32
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfName_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfName_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.cpp
new file mode 100644
index 0000000..b2b83f0
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfNamedActionsDictionary_autogen.h"
+
+std::string SkPdfNamedActionsDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfNamedActionsDictionary::N() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.h
index 8545683..2f18b39 100644
--- a/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.h
@@ -532,26 +532,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) The name of the action to be performed (see Table 8.45).
**/
bool has_N() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", NULL));
}
- std::string N() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string N() const;
};
#endif // __DEFINED__SkPdfNamedActionsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfNull_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfNull_autogen.cpp
new file mode 100644
index 0000000..1e65ded
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfNull_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfNull_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.cpp
new file mode 100644
index 0000000..002b2bf
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfNumberTreeNodeDictionary_autogen.h"
+
+SkPdfArray* SkPdfNumberTreeNodeDictionary::Kids() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfNumberTreeNodeDictionary::Nums() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Nums", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfNumberTreeNodeDictionary::Limits() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.h
index 3cce6af..596744a 100644
--- a/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", NULL));
}
- SkPdfArray* Kids() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Kids() const;
/** (Root and leaf nodes only; required in leaf nodes; present in the root node if and only if Kids
* is not present) An array of the form
* [key1 value1 key2 value2 ... keyn valuen ]
@@ -551,13 +545,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Nums", "", NULL));
}
- SkPdfArray* Nums() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Nums", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Nums() const;
/** (Intermediate and leaf nodes only; required) An array of two integers, specifying the
* (numerically) least and greatest keys included in the Nums array of a leaf node or in the
* Nums arrays of any leaf nodes that are descendants of an intermediate node.
@@ -566,13 +554,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", NULL));
}
- SkPdfArray* Limits() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Limits() const;
};
#endif // __DEFINED__SkPdfNumberTreeNodeDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfNumber_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfNumber_autogen.cpp
new file mode 100644
index 0000000..f342fff
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfNumber_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfNumber_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.cpp
new file mode 100644
index 0000000..684aeba
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfObjectReferenceDictionary_autogen.h"
+
+std::string SkPdfObjectReferenceDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfObjectReferenceDictionary::Pg() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfObject* SkPdfObjectReferenceDictionary::Obj() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Obj", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.h
index f6cff49..ea4bc36 100644
--- a/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Optional; must be an indirect reference) The page object representing the page on
* which the object is rendered. This entry overrides any Pg entry in the structure ele-
* ment containing the object reference; it is required if the structure element has no such
@@ -548,26 +542,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", NULL));
}
- SkPdfDictionary* Pg() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Pg() const;
/** (Required; must be an indirect reference) The referenced object.
**/
bool has_Obj() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Obj", "", NULL));
}
- SkPdfObject* Obj() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Obj", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* Obj() const;
};
#endif // __DEFINED__SkPdfObjectReferenceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfObject_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfObject_autogen.cpp
new file mode 100644
index 0000000..f1eb09b
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfObject_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfObject_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.cpp
new file mode 100644
index 0000000..d02be22
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfOpiVersionDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfOpiVersionDictionary::version_number() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "version_number", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.h
index 7da516a..9318fab 100644
--- a/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "version_number", "", NULL));
}
- SkPdfDictionary* version_number() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "version_number", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* version_number() const;
};
#endif // __DEFINED__SkPdfOpiVersionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.cpp
new file mode 100644
index 0000000..6869d9f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfOutlineDictionary_autogen.h"
+
+std::string SkPdfOutlineDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfOutlineDictionary::First() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineDictionary::Last() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfOutlineDictionary::Count() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.h
index 55a13c0..f7163a1 100644
--- a/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required; must be an indirect reference) An outline item dictionary represent-
* ing the first top-level item in the outline.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", NULL));
}
- SkPdfDictionary* First() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* First() const;
/** (Required; must be an indirect reference) An outline item dictionary represent-
* ing the last top-level item in the outline.
**/
@@ -560,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", NULL));
}
- SkPdfDictionary* Last() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Last() const;
/** (Required if the document has any open outline entries) The total number of
* open items at all levels of the outline. This entry should be omitted if there
* are no open outline items.
@@ -575,13 +557,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", NULL));
}
- long Count() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Count() const;
};
#endif // __DEFINED__SkPdfOutlineDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.cpp
new file mode 100644
index 0000000..05f5ef8
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.cpp
@@ -0,0 +1,100 @@
+#include "SkPdfOutlineItemDictionary_autogen.h"
+
+std::string SkPdfOutlineItemDictionary::Title() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::Parent() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::Prev() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::Next() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::First() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::Last() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfOutlineItemDictionary::Count() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfOutlineItemDictionary::getDestAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfOutlineItemDictionary::getDestAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfOutlineItemDictionary::getDestAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::A() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::SE() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SE", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfOutlineItemDictionary::C() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfOutlineItemDictionary::F() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.h
index eb74f64..7ca070a 100644
--- a/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.h
@@ -531,13 +531,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", NULL));
}
- std::string Title() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Title() const;
/** (Required; must be an indirect reference) The parent of this item in the outline
* hierarchy. The parent of a top-level item is the outline dictionary itself.
**/
@@ -545,13 +539,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", NULL));
}
- SkPdfDictionary* Parent() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Parent() const;
/** (Required for all but the first item at each level; must be an indirect reference)
* The previous item at this outline level.
**/
@@ -559,13 +547,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", NULL));
}
- SkPdfDictionary* Prev() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Prev() const;
/** (Required for all but the last item at each level; must be an indirect reference)
* The next item at this outline level.
**/
@@ -573,13 +555,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", NULL));
}
- SkPdfDictionary* Next() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Next() const;
/** (Required if the item has any descendants; must be an indirect reference) The
* first of this item's immediate children in the outline hierarchy.
**/
@@ -587,13 +563,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", NULL));
}
- SkPdfDictionary* First() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* First() const;
/** (Required if the item has any descendants; must be an indirect reference) The
* last of this item's immediate children in the outline hierarchy.
**/
@@ -601,13 +571,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", NULL));
}
- SkPdfDictionary* Last() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Last() const;
/** (Required if the item has any descendants) If the item is open, the total num-
* ber of its open descendants at all lower levels of the outline hierarchy. If the
* item is closed, a negative integer whose absolute value specifies how many
@@ -617,13 +581,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", NULL));
}
- long Count() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Count() const;
/** (Optional; not permitted if an A entry is present) The destination to be
* displayed when this item is activated (see Section 8.2.1, "Destinations"; see
* also implementation note 56 in Appendix H).
@@ -638,39 +596,21 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getDestAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getDestAsName() const;
bool isDestAString() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getDestAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getDestAsString() const;
bool isDestAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getDestAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getDestAsArray() const;
/** (Optional; PDF 1.1; not permitted if a Dest entry is present) The action to be
* performed when this item is activated (see Section 8.5, "Actions").
**/
@@ -678,13 +618,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", NULL));
}
- SkPdfDictionary* A() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* A() const;
/** (Optional; PDF 1.3; must be an indirect reference) The structure element to
* which the item refers (see Section 9.6.1, "Structure Hierarchy").
* Note: The ability to associate an outline item with a structure element (such as
@@ -697,13 +631,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SE", "", NULL));
}
- SkPdfDictionary* SE() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SE", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* SE() const;
/** (Optional; PDF 1.4) An array of three numbers in the range 0.0 to 1.0, repre-
* senting the components in the DeviceRGB color space of the color to be used
* for the outline entry's text. Default value: [0.0 0.0 0.0].
@@ -712,13 +640,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
}
- SkPdfArray* C() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* C() const;
/** (Optional; PDF 1.4) A set of flags specifying style characteristics for display-
* ing the outline item's text (see Table 8.5). Default value: 0.
**/
@@ -726,13 +648,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- long F() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long F() const;
};
#endif // __DEFINED__SkPdfOutlineItemDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.cpp
new file mode 100644
index 0000000..1d7e095
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfPDF_XOutputIntentDictionary_autogen.h"
+
+std::string SkPdfPDF_XOutputIntentDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfPDF_XOutputIntentDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfPDF_XOutputIntentDictionary::OutputCondition() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputCondition", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfPDF_XOutputIntentDictionary::OutputConditionIdentifier() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputConditionIdentifier", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfPDF_XOutputIntentDictionary::RegistryName() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RegistryName", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfPDF_XOutputIntentDictionary::Info() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfPDF_XOutputIntentDictionary::DestOutputProfile() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DestOutputProfile", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.h
index 8b21fcf..1d90217 100644
--- a/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The output intent subtype; must be GTS_PDFX for a
* PDF/X output intent.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Optional) A text string concisely identifying the intended out-
* put device or production condition in human-readable form.
* This is the preferred method of defining such a string for pre-
@@ -562,13 +550,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputCondition", "", NULL));
}
- std::string OutputCondition() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputCondition", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string OutputCondition() const;
/** (Required) A string identifying the intended output device or
* production condition in human- or machine-readable form. If
* human-readable, this string may be used in lieu of an Output-
@@ -588,13 +570,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputConditionIdentifier", "", NULL));
}
- std::string OutputConditionIdentifier() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputConditionIdentifier", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string OutputConditionIdentifier() const;
/** (Optional) A string (conventionally a uniform resource identifi-
* er, or URI) identifying the registry in which the condition desig-
* nated by OutputConditionIdentifier is defined.
@@ -603,13 +579,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RegistryName", "", NULL));
}
- std::string RegistryName() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RegistryName", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string RegistryName() const;
/** (Required if OutputConditionIdentifier does not specify a standard
* production condition; optional otherwise) A human-readable text
* string containing additional information or comments about
@@ -619,13 +589,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", NULL));
}
- std::string Info() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Info() const;
/** (Required if OutputConditionIdentifier does not specify a standard
* production condition; optional otherwise) An ICC profile stream
* defining the transformation from the PDF document's source
@@ -643,13 +607,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DestOutputProfile", "", NULL));
}
- SkPdfStream* DestOutputProfile() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DestOutputProfile", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* DestOutputProfile() const;
};
#endif // __DEFINED__SkPdfPDF_XOutputIntentDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.cpp
new file mode 100644
index 0000000..85b6802
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfPSXobjectDictionary_autogen.h"
+
+std::string SkPdfPSXobjectDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfPSXobjectDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfPSXobjectDictionary::Level1() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Level1", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.h
index a136f45..d091a0f 100644
--- a/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The type of XObject that this dictionary describes; must be PS for a
* PostScript XObject.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Optional) A stream whose contents are to be used in place of the PostScript
* XObject's stream when the target PostScript interpreter is known to support only
* LanguageLevel 1.
@@ -561,13 +549,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Level1", "", NULL));
}
- SkPdfStream* Level1() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Level1", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Level1() const;
};
#endif // __DEFINED__SkPdfPSXobjectDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.cpp
new file mode 100644
index 0000000..171b2b5
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfPageLabelDictionary_autogen.h"
+
+std::string SkPdfPageLabelDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfPageLabelDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfPageLabelDictionary::P() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfPageLabelDictionary::St() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "St", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.h
index dceaf55..0912661 100644
--- a/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Optional) The numbering style to be used for the numeric portion of each page label:
* D Decimal arabic numerals
* R Uppercase roman numerals
@@ -554,26 +548,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Optional) The label prefix for page labels in this range.
**/
bool has_P() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", NULL));
}
- std::string P() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string P() const;
/** (Optional) The value of the numeric portion for the first page label in the range. Sub-
* sequent pages will be numbered sequentially from this value, which must be greater than
* or equal to 1. Default value: 1.
@@ -582,13 +564,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "St", "", NULL));
}
- long St() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "St", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long St() const;
};
#endif // __DEFINED__SkPdfPageLabelDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.cpp
new file mode 100644
index 0000000..e724a83
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfPageObjectActionsDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfPageObjectActionsDictionary::O() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfPageObjectActionsDictionary::C() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.h
index 9a582ce..84bb4f9 100644
--- a/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.h
@@ -535,13 +535,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", NULL));
}
- SkPdfDictionary* O() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* O() const;
/** (Optional; PDF 1.2) An action to be performed when the page is closed (for example,
* when the user navigates to the next or previous page or follows a link annotation or an
* outline item). This action applies to the page being closed, and is executed before any
@@ -551,13 +545,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
}
- SkPdfDictionary* C() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* C() const;
};
#endif // __DEFINED__SkPdfPageObjectActionsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.cpp
new file mode 100644
index 0000000..573fb41
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.cpp
@@ -0,0 +1,184 @@
+#include "SkPdfPageObjectDictionary_autogen.h"
+
+std::string SkPdfPageObjectDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::Parent() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDate SkPdfPageObjectDictionary::LastModified() const {
+ SkPdfDate ret;
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::Resources() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkRect* SkPdfPageObjectDictionary::MediaBox() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MediaBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkRect* SkPdfPageObjectDictionary::CropBox() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkRect* SkPdfPageObjectDictionary::BleedBox() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkRect* SkPdfPageObjectDictionary::TrimBox() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkRect* SkPdfPageObjectDictionary::ArtBox() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::BoxColorInfo() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BoxColorInfo", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfPageObjectDictionary::getContentsAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfPageObjectDictionary::getContentsAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfPageObjectDictionary::Rotate() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::Group() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfPageObjectDictionary::Thumb() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Thumb", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfPageObjectDictionary::B() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+double SkPdfPageObjectDictionary::Dur() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dur", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::Trans() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trans", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfPageObjectDictionary::Annots() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::AA() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfPageObjectDictionary::Metadata() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::PieceInfo() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfPageObjectDictionary::StructParents() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfPageObjectDictionary::ID() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+double SkPdfPageObjectDictionary::PZ() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PZ", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::SeparationInfo() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationInfo", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.h
index 46d686e..287f8c4 100644
--- a/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required; must be an indirect reference) The page tree node that is the im-
* mediate parent of this page object.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", NULL));
}
- SkPdfDictionary* Parent() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Parent() const;
/** (Required if PieceInfo is present; optional otherwise; PDF 1.3) The date and
* time (see Section 3.8.2, "Dates") when the page's contents were most re-
* cently modified. If a page-piece dictionary (PieceInfo) is present, the
@@ -564,13 +552,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", NULL));
}
- SkPdfDate LastModified() const {
- SkPdfDate ret;
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate LastModified() const;
/** (Required; inheritable) A dictionary containing any resources required by
* the page (see Section 3.7.2, "Resource Dictionaries"). If the page requires
* no resources, the value of this entry should be an empty dictionary; omit-
@@ -581,13 +563,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", NULL));
}
- SkPdfDictionary* Resources() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Resources() const;
/** (Required; inheritable) A rectangle (see Section 3.8.3, "Rectangles"), ex-
* pressed in default user space units, defining the boundaries of the physical
* medium on which the page is intended to be displayed or printed (see
@@ -597,13 +573,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MediaBox", "", NULL));
}
- SkRect* MediaBox() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MediaBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* MediaBox() const;
/** (Optional; inheritable) A rectangle, expressed in default user space units,
* defining the visible region of default user space. When the page is dis-
* played or printed, its contents are to be clipped (cropped) to this rectangle
@@ -615,13 +585,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", NULL));
}
- SkRect* CropBox() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* CropBox() const;
/** (Optional; PDF 1.3) A rectangle, expressed in default user space units, de-
* fining the region to which the contents of the page should be clipped
* when output in a production environment (see Section 9.10.1, "Page
@@ -631,13 +595,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", NULL));
}
- SkRect* BleedBox() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* BleedBox() const;
/** (Optional; PDF 1.3) A rectangle, expressed in default user space units, de-
* fining the intended dimensions of the finished page after trimming (see
* Section 9.10.1, "Page Boundaries"). Default value: the value of CropBox.
@@ -646,13 +604,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", NULL));
}
- SkRect* TrimBox() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* TrimBox() const;
/** (Optional; PDF 1.3) A rectangle, expressed in default user space units, de-
* fining the extent of the page's meaningful content (including potential
* white space) as intended by the page's creator (see Section 9.10.1, "Page
@@ -662,13 +614,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", NULL));
}
- SkRect* ArtBox() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* ArtBox() const;
/** (Optional) A box color information dictionary specifying the colors and
* other visual characteristics to be used in displaying guidelines on the
* screen for the various page boundaries (see "Display of Page Boundaries"
@@ -679,13 +625,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BoxColorInfo", "", NULL));
}
- SkPdfDictionary* BoxColorInfo() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BoxColorInfo", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* BoxColorInfo() const;
/** (Optional) A content stream (see Section 3.7.1, "Content Streams") de-
* scribing the contents of this page. If this entry is absent, the page is empty.
* The value may be either a single stream or an array of streams. If it is an
@@ -709,26 +649,14 @@
return ret->podofo()->HasStream();
}
- SkPdfStream* getContentsAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getContentsAsStream() const;
bool isContentsAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getContentsAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getContentsAsArray() const;
/** (Optional; inheritable) The number of degrees by which the page should
* be rotated clockwise when displayed or printed. The value must be a mul-
* tiple of 90. Default value: 0.
@@ -737,13 +665,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", NULL));
}
- long Rotate() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Rotate() const;
/** (Optional; PDF 1.4) A group attributes dictionary specifying the attributes
* of the page's page group for use in the transparent imaging model (see
* Sections 7.3.6, "Page Group," and 7.5.5, "Transparency Group XObjects").
@@ -752,13 +674,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", NULL));
}
- SkPdfDictionary* Group() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Group() const;
/** (Optional) A stream object defining the page's thumbnail image (see Sec-
* tion 8.2.3, "Thumbnail Images").
**/
@@ -766,13 +682,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Thumb", "", NULL));
}
- SkPdfStream* Thumb() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Thumb", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Thumb() const;
/** (Optional; PDF 1.1; recommended if the page contains article beads) An ar-
* ray of indirect references to article beads appearing on the page (see Sec-
* tion 8.3.2, "Articles"; see also implementation note 23 in Appendix H).
@@ -782,13 +692,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", NULL));
}
- SkPdfArray* B() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* B() const;
/** (Optional; PDF 1.1) The page's display duration (also called its advance
* timing): the maximum length of time, in seconds, that the page will be
* displayed during presentations before the viewer application automati-
@@ -799,13 +703,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dur", "", NULL));
}
- double Dur() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dur", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double Dur() const;
/** (Optional; PDF 1.1) A transition dictionary describing the transition effect
* to be used when displaying the page during presentations (see Section
* 8.3.3, "Presentations").
@@ -814,13 +712,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trans", "", NULL));
}
- SkPdfDictionary* Trans() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trans", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Trans() const;
/** (Optional) An array of annotation dictionaries representing annotations
* associated with the page (see Section 8.4, "Annotations").
**/
@@ -828,13 +720,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", NULL));
}
- SkPdfArray* Annots() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Annots() const;
/** (Optional; PDF 1.2) An additional-actions dictionary defining actions to
* be performed when the page is opened or closed (see Section 8.5.2, "Trig-
* ger Events"; see also implementation note 24 in Appendix H).
@@ -843,13 +729,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", NULL));
}
- SkPdfDictionary* AA() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* AA() const;
/** (Optional; PDF 1.4) A metadata stream containing metadata for the page
* (see Section 9.2.2, "Metadata Streams").
**/
@@ -857,13 +737,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
}
- SkPdfStream* Metadata() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Metadata() const;
/** (Optional; PDF 1.3) A page-piece dictionary associated with the page (see
* Section 9.4, "Page-Piece Dictionaries").
**/
@@ -871,13 +745,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", NULL));
}
- SkPdfDictionary* PieceInfo() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* PieceInfo() const;
/** (Required if the page contains structural content items; PDF 1.3) The inte-
* ger key of the page's entry in the structural parent tree (see "Finding Struc-
* ture Elements from Content Items" on page 600).
@@ -886,13 +754,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", NULL));
}
- long StructParents() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long StructParents() const;
/** (Optional; PDF 1.3; indirect reference preferred) The digital identifier of the
* page's parent Web Capture content set (see Section 9.9.5, "Object At-
* tributes Related to Web Capture").
@@ -901,13 +763,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
}
- std::string ID() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string ID() const;
/** (Optional; PDF 1.3) The page's preferred zoom (magnification) factor: the
* factor by which it should be scaled to achieve the "natural" display magni-
* fication (see Section 9.9.5, "Object Attributes Related to Web Capture").
@@ -916,13 +772,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PZ", "", NULL));
}
- double PZ() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PZ", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double PZ() const;
/** (Optional; PDF 1.3) A separation dictionary containing information need-
* ed to generate color separations for the page (see Section 9.10.3, "Separa-
* tion Dictionaries").
@@ -931,13 +781,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationInfo", "", NULL));
}
- SkPdfDictionary* SeparationInfo() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationInfo", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* SeparationInfo() const;
};
#endif // __DEFINED__SkPdfPageObjectDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.cpp
new file mode 100644
index 0000000..1252e48
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.cpp
@@ -0,0 +1,11 @@
+#include "SkPdfPagePieceDictionary_autogen.h"
+
+/*
+SkPdfDictionary* SkPdfPagePieceDictionary::[any_application_name_or_well_known_data_type]() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_application_name_or_well_known_data_type]", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+*/
diff --git a/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.h
index 9ffd819..2e6b812 100644
--- a/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_application_name_or_well_known_data_type]", "", NULL));
}
- SkPdfDictionary* [any_application_name_or_well_known_data_type]() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_application_name_or_well_known_data_type]", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* [any_application_name_or_well_known_data_type]() const;
*/
};
diff --git a/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.cpp
new file mode 100644
index 0000000..6103597
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfPageTreeNodeDictionary_autogen.h"
+
+std::string SkPdfPageTreeNodeDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfPageTreeNodeDictionary::Parent() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfPageTreeNodeDictionary::Kids() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfPageTreeNodeDictionary::Count() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.h
index b1d6d7c..8d370eb 100644
--- a/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required except in root node; must be an indirect reference) The page tree node that
* is the immediate parent of this one.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", NULL));
}
- SkPdfDictionary* Parent() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Parent() const;
/** (Required) An array of indirect references to the immediate children of this node.
* The children may be page objects or other page tree nodes.
**/
@@ -560,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", NULL));
}
- SkPdfArray* Kids() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Kids() const;
/** (Required) The number of leaf nodes (page objects) that are descendants of this
* node within the page tree.
**/
@@ -574,13 +556,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", NULL));
}
- long Count() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Count() const;
};
#endif // __DEFINED__SkPdfPageTreeNodeDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.cpp
new file mode 100644
index 0000000..5d2df72
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.cpp
@@ -0,0 +1,5402 @@
+#include "SkPdfPodofoMapper_autogen.h"
+bool mapObject(const SkPdfObject& in, SkPdfObject** out) {
+ return mapObject(*in.doc(), *in.podofo(), out);
+}
+
+bool mapObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out) {
+ if (!isObject(podofoDoc, podofoObj)) return false;
+
+ if (mapArray(podofoDoc, podofoObj, (SkPdfArray**)out)) return true;
+ if (mapBoolean(podofoDoc, podofoObj, (SkPdfBoolean**)out)) return true;
+ if (mapDictionary(podofoDoc, podofoObj, (SkPdfDictionary**)out)) return true;
+ if (mapInteger(podofoDoc, podofoObj, (SkPdfInteger**)out)) return true;
+ if (mapName(podofoDoc, podofoObj, (SkPdfName**)out)) return true;
+ if (mapNull(podofoDoc, podofoObj, (SkPdfNull**)out)) return true;
+ if (mapReference(podofoDoc, podofoObj, (SkPdfReference**)out)) return true;
+ if (mapString(podofoDoc, podofoObj, (SkPdfString**)out)) return true;
+ if (mapStream(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;
+
+ *out = new SkPdfObject(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapNull(const SkPdfObject& in, SkPdfNull** out) {
+ return mapNull(*in.doc(), *in.podofo(), out);
+}
+
+bool mapNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNull** out) {
+ if (!isNull(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfNull(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapBoolean(const SkPdfObject& in, SkPdfBoolean** out) {
+ return mapBoolean(*in.doc(), *in.podofo(), out);
+}
+
+bool mapBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoolean** out) {
+ if (!isBoolean(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfBoolean(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapInteger(const SkPdfObject& in, SkPdfInteger** out) {
+ return mapInteger(*in.doc(), *in.podofo(), out);
+}
+
+bool mapInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteger** out) {
+ if (!isInteger(podofoDoc, podofoObj)) return false;
+
+ if (mapNumber(podofoDoc, podofoObj, (SkPdfNumber**)out)) return true;
+
+ *out = new SkPdfInteger(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapNumber(const SkPdfObject& in, SkPdfNumber** out) {
+ return mapNumber(*in.doc(), *in.podofo(), out);
+}
+
+bool mapNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumber** out) {
+ if (!isNumber(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfNumber(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapName(const SkPdfObject& in, SkPdfName** out) {
+ return mapName(*in.doc(), *in.podofo(), out);
+}
+
+bool mapName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfName** out) {
+ if (!isName(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfName(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapReference(const SkPdfObject& in, SkPdfReference** out) {
+ return mapReference(*in.doc(), *in.podofo(), out);
+}
+
+bool mapReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReference** out) {
+ if (!isReference(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfReference(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapArray(const SkPdfObject& in, SkPdfArray** out) {
+ return mapArray(*in.doc(), *in.podofo(), out);
+}
+
+bool mapArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArray** out) {
+ if (!isArray(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfArray(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapString(const SkPdfObject& in, SkPdfString** out) {
+ return mapString(*in.doc(), *in.podofo(), out);
+}
+
+bool mapString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfString** out) {
+ if (!isString(podofoDoc, podofoObj)) return false;
+
+ if (mapHexString(podofoDoc, podofoObj, (SkPdfHexString**)out)) return true;
+
+ *out = new SkPdfString(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapHexString(const SkPdfObject& in, SkPdfHexString** out) {
+ return mapHexString(*in.doc(), *in.podofo(), out);
+}
+
+bool mapHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHexString** out) {
+ if (!isHexString(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfHexString(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapDictionary(const SkPdfObject& in, SkPdfDictionary** out) {
+ return mapDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDictionary** out) {
+ if (!isDictionary(podofoDoc, podofoObj)) return false;
+
+ if (mapALinkAnnotationDictionary(podofoDoc, podofoObj, (SkPdfALinkAnnotationDictionary**)out)) return true;
+ if (mapActionDictionary(podofoDoc, podofoObj, (SkPdfActionDictionary**)out)) return true;
+ if (mapAlternateImageDictionary(podofoDoc, podofoObj, (SkPdfAlternateImageDictionary**)out)) return true;
+ if (mapAnnotationActionsDictionary(podofoDoc, podofoObj, (SkPdfAnnotationActionsDictionary**)out)) return true;
+ if (mapAnnotationDictionary(podofoDoc, podofoObj, (SkPdfAnnotationDictionary**)out)) return true;
+ if (mapAppearanceCharacteristicsDictionary(podofoDoc, podofoObj, (SkPdfAppearanceCharacteristicsDictionary**)out)) return true;
+ if (mapAppearanceDictionary(podofoDoc, podofoObj, (SkPdfAppearanceDictionary**)out)) return true;
+ if (mapApplicationDataDictionary(podofoDoc, podofoObj, (SkPdfApplicationDataDictionary**)out)) return true;
+ if (mapArtifactsDictionary(podofoDoc, podofoObj, (SkPdfArtifactsDictionary**)out)) return true;
+ if (mapAttributeObjectDictionary(podofoDoc, podofoObj, (SkPdfAttributeObjectDictionary**)out)) return true;
+ if (mapBeadDictionary(podofoDoc, podofoObj, (SkPdfBeadDictionary**)out)) return true;
+ if (mapBlockLevelStructureElementsDictionary(podofoDoc, podofoObj, (SkPdfBlockLevelStructureElementsDictionary**)out)) return true;
+ if (mapBorderStyleDictionary(podofoDoc, podofoObj, (SkPdfBorderStyleDictionary**)out)) return true;
+ if (mapBoxColorInformationDictionary(podofoDoc, podofoObj, (SkPdfBoxColorInformationDictionary**)out)) return true;
+ if (mapBoxStyleDictionary(podofoDoc, podofoObj, (SkPdfBoxStyleDictionary**)out)) return true;
+ if (mapCIDFontDescriptorDictionary(podofoDoc, podofoObj, (SkPdfCIDFontDescriptorDictionary**)out)) return true;
+ if (mapCIDSystemInfoDictionary(podofoDoc, podofoObj, (SkPdfCIDSystemInfoDictionary**)out)) return true;
+ if (mapCMapDictionary(podofoDoc, podofoObj, (SkPdfCMapDictionary**)out)) return true;
+ if (mapCalgrayColorSpaceDictionary(podofoDoc, podofoObj, (SkPdfCalgrayColorSpaceDictionary**)out)) return true;
+ if (mapCalrgbColorSpaceDictionary(podofoDoc, podofoObj, (SkPdfCalrgbColorSpaceDictionary**)out)) return true;
+ if (mapCatalogDictionary(podofoDoc, podofoObj, (SkPdfCatalogDictionary**)out)) return true;
+ if (mapCcittfaxdecodeFilterDictionary(podofoDoc, podofoObj, (SkPdfCcittfaxdecodeFilterDictionary**)out)) return true;
+ if (mapCheckboxFieldDictionary(podofoDoc, podofoObj, (SkPdfCheckboxFieldDictionary**)out)) return true;
+ if (mapChoiceFieldDictionary(podofoDoc, podofoObj, (SkPdfChoiceFieldDictionary**)out)) return true;
+ if (mapComponentsWithMetadataDictionary(podofoDoc, podofoObj, (SkPdfComponentsWithMetadataDictionary**)out)) return true;
+ if (mapDctdecodeFilterDictionary(podofoDoc, podofoObj, (SkPdfDctdecodeFilterDictionary**)out)) return true;
+ if (mapDeviceNColorSpaceDictionary(podofoDoc, podofoObj, (SkPdfDeviceNColorSpaceDictionary**)out)) return true;
+ if (mapDocumentCatalogActionsDictionary(podofoDoc, podofoObj, (SkPdfDocumentCatalogActionsDictionary**)out)) return true;
+ if (mapDocumentInformationDictionary(podofoDoc, podofoObj, (SkPdfDocumentInformationDictionary**)out)) return true;
+ if (mapEmbeddedFileParameterDictionary(podofoDoc, podofoObj, (SkPdfEmbeddedFileParameterDictionary**)out)) return true;
+ if (mapEmbeddedFileStreamDictionary(podofoDoc, podofoObj, (SkPdfEmbeddedFileStreamDictionary**)out)) return true;
+ if (mapEmbeddedFontStreamDictionary(podofoDoc, podofoObj, (SkPdfEmbeddedFontStreamDictionary**)out)) return true;
+ if (mapEncodingDictionary(podofoDoc, podofoObj, (SkPdfEncodingDictionary**)out)) return true;
+ if (mapEncryptedEmbeddedFileStreamDictionary(podofoDoc, podofoObj, (SkPdfEncryptedEmbeddedFileStreamDictionary**)out)) return true;
+ if (mapEncryptionCommonDictionary(podofoDoc, podofoObj, (SkPdfEncryptionCommonDictionary**)out)) return true;
+ if (mapFDFCatalogDictionary(podofoDoc, podofoObj, (SkPdfFDFCatalogDictionary**)out)) return true;
+ if (mapFDFDictionary(podofoDoc, podofoObj, (SkPdfFDFDictionary**)out)) return true;
+ if (mapFDFFieldDictionary(podofoDoc, podofoObj, (SkPdfFDFFieldDictionary**)out)) return true;
+ if (mapFDFFileAnnotationDictionary(podofoDoc, podofoObj, (SkPdfFDFFileAnnotationDictionary**)out)) return true;
+ if (mapFDFNamedPageReferenceDictionary(podofoDoc, podofoObj, (SkPdfFDFNamedPageReferenceDictionary**)out)) return true;
+ if (mapFDFPageDictionary(podofoDoc, podofoObj, (SkPdfFDFPageDictionary**)out)) return true;
+ if (mapFDFTemplateDictionary(podofoDoc, podofoObj, (SkPdfFDFTemplateDictionary**)out)) return true;
+ if (mapFDFTrailerDictionary(podofoDoc, podofoObj, (SkPdfFDFTrailerDictionary**)out)) return true;
+ if (mapFieldDictionary(podofoDoc, podofoObj, (SkPdfFieldDictionary**)out)) return true;
+ if (mapFileAttachmentAnnotationDictionary(podofoDoc, podofoObj, (SkPdfFileAttachmentAnnotationDictionary**)out)) return true;
+ if (mapFileSpecificationDictionary(podofoDoc, podofoObj, (SkPdfFileSpecificationDictionary**)out)) return true;
+ if (mapFileTrailerDictionary(podofoDoc, podofoObj, (SkPdfFileTrailerDictionary**)out)) return true;
+ if (mapFontDescriptorDictionary(podofoDoc, podofoObj, (SkPdfFontDescriptorDictionary**)out)) return true;
+ if (mapFontDictionary(podofoDoc, podofoObj, (SkPdfFontDictionary**)out)) return true;
+ if (mapFormFieldActionsDictionary(podofoDoc, podofoObj, (SkPdfFormFieldActionsDictionary**)out)) return true;
+ if (mapFreeTextAnnotationDictionary(podofoDoc, podofoObj, (SkPdfFreeTextAnnotationDictionary**)out)) return true;
+ if (mapFunctionCommonDictionary(podofoDoc, podofoObj, (SkPdfFunctionCommonDictionary**)out)) return true;
+ if (mapGoToActionDictionary(podofoDoc, podofoObj, (SkPdfGoToActionDictionary**)out)) return true;
+ if (mapGraphicsStateDictionary(podofoDoc, podofoObj, (SkPdfGraphicsStateDictionary**)out)) return true;
+ if (mapGroupAttributesDictionary(podofoDoc, podofoObj, (SkPdfGroupAttributesDictionary**)out)) return true;
+ if (mapHideActionDictionary(podofoDoc, podofoObj, (SkPdfHideActionDictionary**)out)) return true;
+ if (mapIccProfileStreamDictionary(podofoDoc, podofoObj, (SkPdfIccProfileStreamDictionary**)out)) return true;
+ if (mapIconFitDictionary(podofoDoc, podofoObj, (SkPdfIconFitDictionary**)out)) return true;
+ if (mapImportDataActionDictionary(podofoDoc, podofoObj, (SkPdfImportDataActionDictionary**)out)) return true;
+ if (mapInkAnnotationDictionary(podofoDoc, podofoObj, (SkPdfInkAnnotationDictionary**)out)) return true;
+ if (mapInlineLevelStructureElementsDictionary(podofoDoc, podofoObj, (SkPdfInlineLevelStructureElementsDictionary**)out)) return true;
+ if (mapInteractiveFormDictionary(podofoDoc, podofoObj, (SkPdfInteractiveFormDictionary**)out)) return true;
+ if (mapJavascriptActionDictionary(podofoDoc, podofoObj, (SkPdfJavascriptActionDictionary**)out)) return true;
+ if (mapJavascriptDictionary(podofoDoc, podofoObj, (SkPdfJavascriptDictionary**)out)) return true;
+ if (mapJbig2DecodeFilterDictionary(podofoDoc, podofoObj, (SkPdfJbig2DecodeFilterDictionary**)out)) return true;
+ if (mapLabColorSpaceDictionary(podofoDoc, podofoObj, (SkPdfLabColorSpaceDictionary**)out)) return true;
+ if (mapLaunchActionDictionary(podofoDoc, podofoObj, (SkPdfLaunchActionDictionary**)out)) return true;
+ if (mapLineAnnotationDictionary(podofoDoc, podofoObj, (SkPdfLineAnnotationDictionary**)out)) return true;
+ if (mapListAttributeDictionary(podofoDoc, podofoObj, (SkPdfListAttributeDictionary**)out)) return true;
+ if (mapLzwdecodeAndFlatedecodeFiltersDictionary(podofoDoc, podofoObj, (SkPdfLzwdecodeAndFlatedecodeFiltersDictionary**)out)) return true;
+ if (mapMacOsFileInformationDictionary(podofoDoc, podofoObj, (SkPdfMacOsFileInformationDictionary**)out)) return true;
+ if (mapMarkInformationDictionary(podofoDoc, podofoObj, (SkPdfMarkInformationDictionary**)out)) return true;
+ if (mapMarkedContentReferenceDictionary(podofoDoc, podofoObj, (SkPdfMarkedContentReferenceDictionary**)out)) return true;
+ if (mapMarkupAnnotationsDictionary(podofoDoc, podofoObj, (SkPdfMarkupAnnotationsDictionary**)out)) return true;
+ if (mapMetadataStreamDictionary(podofoDoc, podofoObj, (SkPdfMetadataStreamDictionary**)out)) return true;
+ if (mapMovieActionDictionary(podofoDoc, podofoObj, (SkPdfMovieActionDictionary**)out)) return true;
+ if (mapMovieActivationDictionary(podofoDoc, podofoObj, (SkPdfMovieActivationDictionary**)out)) return true;
+ if (mapMovieAnnotationDictionary(podofoDoc, podofoObj, (SkPdfMovieAnnotationDictionary**)out)) return true;
+ if (mapMovieDictionary(podofoDoc, podofoObj, (SkPdfMovieDictionary**)out)) return true;
+ if (mapNameDictionary(podofoDoc, podofoObj, (SkPdfNameDictionary**)out)) return true;
+ if (mapNameTreeNodeDictionary(podofoDoc, podofoObj, (SkPdfNameTreeNodeDictionary**)out)) return true;
+ if (mapNamedActionsDictionary(podofoDoc, podofoObj, (SkPdfNamedActionsDictionary**)out)) return true;
+ if (mapNumberTreeNodeDictionary(podofoDoc, podofoObj, (SkPdfNumberTreeNodeDictionary**)out)) return true;
+ if (mapObjectReferenceDictionary(podofoDoc, podofoObj, (SkPdfObjectReferenceDictionary**)out)) return true;
+ if (mapOpiVersionDictionary(podofoDoc, podofoObj, (SkPdfOpiVersionDictionary**)out)) return true;
+ if (mapOutlineDictionary(podofoDoc, podofoObj, (SkPdfOutlineDictionary**)out)) return true;
+ if (mapOutlineItemDictionary(podofoDoc, podofoObj, (SkPdfOutlineItemDictionary**)out)) return true;
+ if (mapPDF_XOutputIntentDictionary(podofoDoc, podofoObj, (SkPdfPDF_XOutputIntentDictionary**)out)) return true;
+ if (mapPSXobjectDictionary(podofoDoc, podofoObj, (SkPdfPSXobjectDictionary**)out)) return true;
+ if (mapPageLabelDictionary(podofoDoc, podofoObj, (SkPdfPageLabelDictionary**)out)) return true;
+ if (mapPageObjectActionsDictionary(podofoDoc, podofoObj, (SkPdfPageObjectActionsDictionary**)out)) return true;
+ if (mapPageObjectDictionary(podofoDoc, podofoObj, (SkPdfPageObjectDictionary**)out)) return true;
+ if (mapPagePieceDictionary(podofoDoc, podofoObj, (SkPdfPagePieceDictionary**)out)) return true;
+ if (mapPageTreeNodeDictionary(podofoDoc, podofoObj, (SkPdfPageTreeNodeDictionary**)out)) return true;
+ if (mapPopUpAnnotationDictionary(podofoDoc, podofoObj, (SkPdfPopUpAnnotationDictionary**)out)) return true;
+ if (mapPrinterMarkAnnotationDictionary(podofoDoc, podofoObj, (SkPdfPrinterMarkAnnotationDictionary**)out)) return true;
+ if (mapPrinterMarkFormDictionary(podofoDoc, podofoObj, (SkPdfPrinterMarkFormDictionary**)out)) return true;
+ if (mapRadioButtonFieldDictionary(podofoDoc, podofoObj, (SkPdfRadioButtonFieldDictionary**)out)) return true;
+ if (mapReferenceDictionary(podofoDoc, podofoObj, (SkPdfReferenceDictionary**)out)) return true;
+ if (mapRemoteGoToActionDictionary(podofoDoc, podofoObj, (SkPdfRemoteGoToActionDictionary**)out)) return true;
+ if (mapResetFormActionDictionary(podofoDoc, podofoObj, (SkPdfResetFormActionDictionary**)out)) return true;
+ if (mapResourceDictionary(podofoDoc, podofoObj, (SkPdfResourceDictionary**)out)) return true;
+ if (mapRubberStampAnnotationDictionary(podofoDoc, podofoObj, (SkPdfRubberStampAnnotationDictionary**)out)) return true;
+ if (mapSeparationDictionary(podofoDoc, podofoObj, (SkPdfSeparationDictionary**)out)) return true;
+ if (mapShadingDictionary(podofoDoc, podofoObj, (SkPdfShadingDictionary**)out)) return true;
+ if (mapSignatureDictionary(podofoDoc, podofoObj, (SkPdfSignatureDictionary**)out)) return true;
+ if (mapSoftMaskDictionary(podofoDoc, podofoObj, (SkPdfSoftMaskDictionary**)out)) return true;
+ if (mapSoftMaskImageDictionary(podofoDoc, podofoObj, (SkPdfSoftMaskImageDictionary**)out)) return true;
+ if (mapSoundActionDictionary(podofoDoc, podofoObj, (SkPdfSoundActionDictionary**)out)) return true;
+ if (mapSoundAnnotationDictionary(podofoDoc, podofoObj, (SkPdfSoundAnnotationDictionary**)out)) return true;
+ if (mapSoundObjectDictionary(podofoDoc, podofoObj, (SkPdfSoundObjectDictionary**)out)) return true;
+ if (mapSourceInformationDictionary(podofoDoc, podofoObj, (SkPdfSourceInformationDictionary**)out)) return true;
+ if (mapSquareOrCircleAnnotation(podofoDoc, podofoObj, (SkPdfSquareOrCircleAnnotation**)out)) return true;
+ if (mapStandardSecurityHandlerDictionary(podofoDoc, podofoObj, (SkPdfStandardSecurityHandlerDictionary**)out)) return true;
+ if (mapStandardStructureDictionary(podofoDoc, podofoObj, (SkPdfStandardStructureDictionary**)out)) return true;
+ if (mapStreamCommonDictionary(podofoDoc, podofoObj, (SkPdfStreamCommonDictionary**)out)) return true;
+ if (mapStructureElementAccessDictionary(podofoDoc, podofoObj, (SkPdfStructureElementAccessDictionary**)out)) return true;
+ if (mapStructureElementDictionary(podofoDoc, podofoObj, (SkPdfStructureElementDictionary**)out)) return true;
+ if (mapStructureTreeRootDictionary(podofoDoc, podofoObj, (SkPdfStructureTreeRootDictionary**)out)) return true;
+ if (mapSubmitFormActionDictionary(podofoDoc, podofoObj, (SkPdfSubmitFormActionDictionary**)out)) return true;
+ if (mapTableAttributesDictionary(podofoDoc, podofoObj, (SkPdfTableAttributesDictionary**)out)) return true;
+ if (mapTextAnnotationDictionary(podofoDoc, podofoObj, (SkPdfTextAnnotationDictionary**)out)) return true;
+ if (mapTextFieldDictionary(podofoDoc, podofoObj, (SkPdfTextFieldDictionary**)out)) return true;
+ if (mapThreadActionDictionary(podofoDoc, podofoObj, (SkPdfThreadActionDictionary**)out)) return true;
+ if (mapThreadDictionary(podofoDoc, podofoObj, (SkPdfThreadDictionary**)out)) return true;
+ if (mapTransitionDictionary(podofoDoc, podofoObj, (SkPdfTransitionDictionary**)out)) return true;
+ if (mapTransparencyGroupDictionary(podofoDoc, podofoObj, (SkPdfTransparencyGroupDictionary**)out)) return true;
+ if (mapTrapNetworkAnnotationDictionary(podofoDoc, podofoObj, (SkPdfTrapNetworkAnnotationDictionary**)out)) return true;
+ if (mapTrapNetworkAppearanceStreamDictionary(podofoDoc, podofoObj, (SkPdfTrapNetworkAppearanceStreamDictionary**)out)) return true;
+ if (mapType0FunctionDictionary(podofoDoc, podofoObj, (SkPdfType0FunctionDictionary**)out)) return true;
+ if (mapType10HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType10HalftoneDictionary**)out)) return true;
+ if (mapType16HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType16HalftoneDictionary**)out)) return true;
+ if (mapType1HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType1HalftoneDictionary**)out)) return true;
+ if (mapType1PatternDictionary(podofoDoc, podofoObj, (SkPdfType1PatternDictionary**)out)) return true;
+ if (mapType2FunctionDictionary(podofoDoc, podofoObj, (SkPdfType2FunctionDictionary**)out)) return true;
+ if (mapType2PatternDictionary(podofoDoc, podofoObj, (SkPdfType2PatternDictionary**)out)) return true;
+ if (mapType3FunctionDictionary(podofoDoc, podofoObj, (SkPdfType3FunctionDictionary**)out)) return true;
+ if (mapType5HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType5HalftoneDictionary**)out)) return true;
+ if (mapType6HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType6HalftoneDictionary**)out)) return true;
+ if (mapURIActionDictionary(podofoDoc, podofoObj, (SkPdfURIActionDictionary**)out)) return true;
+ if (mapURIDictionary(podofoDoc, podofoObj, (SkPdfURIDictionary**)out)) return true;
+ if (mapURLAliasDictionary(podofoDoc, podofoObj, (SkPdfURLAliasDictionary**)out)) return true;
+ if (mapVariableTextFieldDictionary(podofoDoc, podofoObj, (SkPdfVariableTextFieldDictionary**)out)) return true;
+ if (mapViewerPreferencesDictionary(podofoDoc, podofoObj, (SkPdfViewerPreferencesDictionary**)out)) return true;
+ if (mapWebCaptureCommandDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureCommandDictionary**)out)) return true;
+ if (mapWebCaptureCommandSettingsDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureCommandSettingsDictionary**)out)) return true;
+ if (mapWebCaptureDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureDictionary**)out)) return true;
+ if (mapWebCaptureImageSetDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureImageSetDictionary**)out)) return true;
+ if (mapWebCaptureInformationDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureInformationDictionary**)out)) return true;
+ if (mapWebCapturePageSetDictionary(podofoDoc, podofoObj, (SkPdfWebCapturePageSetDictionary**)out)) return true;
+ if (mapWidgetAnnotationDictionary(podofoDoc, podofoObj, (SkPdfWidgetAnnotationDictionary**)out)) return true;
+ if (mapWindowsLaunchActionDictionary(podofoDoc, podofoObj, (SkPdfWindowsLaunchActionDictionary**)out)) return true;
+ if (mapXObjectDictionary(podofoDoc, podofoObj, (SkPdfXObjectDictionary**)out)) return true;
+
+ *out = new SkPdfDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapStream(const SkPdfObject& in, SkPdfStream** out) {
+ return mapStream(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStream** out) {
+ if (!isStream(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfStream(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapXObjectDictionary(const SkPdfObject& in, SkPdfXObjectDictionary** out) {
+ return mapXObjectDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfXObjectDictionary** out) {
+ if (!isXObjectDictionary(podofoDoc, podofoObj)) return false;
+
+ if (mapImageDictionary(podofoDoc, podofoObj, (SkPdfImageDictionary**)out)) return true;
+ if (mapType1FormDictionary(podofoDoc, podofoObj, (SkPdfType1FormDictionary**)out)) return true;
+
+ *out = new SkPdfXObjectDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFontDictionary(const SkPdfObject& in, SkPdfFontDictionary** out) {
+ return mapFontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDictionary** out) {
+ if (!isFontDictionary(podofoDoc, podofoObj)) return false;
+
+ if (mapCIDFontDictionary(podofoDoc, podofoObj, (SkPdfCIDFontDictionary**)out)) return true;
+ if (mapType0FontDictionary(podofoDoc, podofoObj, (SkPdfType0FontDictionary**)out)) return true;
+ if (mapType1FontDictionary(podofoDoc, podofoObj, (SkPdfType1FontDictionary**)out)) return true;
+
+ *out = new SkPdfFontDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapTrueTypeFontDictionary(const SkPdfObject& in, SkPdfTrueTypeFontDictionary** out) {
+ return mapTrueTypeFontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrueTypeFontDictionary** out) {
+ if (!isTrueTypeFontDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfTrueTypeFontDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapStreamCommonDictionary(const SkPdfObject& in, SkPdfStreamCommonDictionary** out) {
+ return mapStreamCommonDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStreamCommonDictionary** out) {
+ if (!isStreamCommonDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfStreamCommonDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapLzwdecodeAndFlatedecodeFiltersDictionary(const SkPdfObject& in, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out) {
+ return mapLzwdecodeAndFlatedecodeFiltersDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out) {
+ if (!isLzwdecodeAndFlatedecodeFiltersDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfLzwdecodeAndFlatedecodeFiltersDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapCcittfaxdecodeFilterDictionary(const SkPdfObject& in, SkPdfCcittfaxdecodeFilterDictionary** out) {
+ return mapCcittfaxdecodeFilterDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCcittfaxdecodeFilterDictionary** out) {
+ if (!isCcittfaxdecodeFilterDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfCcittfaxdecodeFilterDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapJbig2DecodeFilterDictionary(const SkPdfObject& in, SkPdfJbig2DecodeFilterDictionary** out) {
+ return mapJbig2DecodeFilterDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJbig2DecodeFilterDictionary** out) {
+ if (!isJbig2DecodeFilterDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfJbig2DecodeFilterDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapDctdecodeFilterDictionary(const SkPdfObject& in, SkPdfDctdecodeFilterDictionary** out) {
+ return mapDctdecodeFilterDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDctdecodeFilterDictionary** out) {
+ if (!isDctdecodeFilterDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfDctdecodeFilterDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFileTrailerDictionary(const SkPdfObject& in, SkPdfFileTrailerDictionary** out) {
+ return mapFileTrailerDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileTrailerDictionary** out) {
+ if (!isFileTrailerDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFileTrailerDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapEncryptionCommonDictionary(const SkPdfObject& in, SkPdfEncryptionCommonDictionary** out) {
+ return mapEncryptionCommonDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptionCommonDictionary** out) {
+ if (!isEncryptionCommonDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfEncryptionCommonDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapStandardSecurityHandlerDictionary(const SkPdfObject& in, SkPdfStandardSecurityHandlerDictionary** out) {
+ return mapStandardSecurityHandlerDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardSecurityHandlerDictionary** out) {
+ if (!isStandardSecurityHandlerDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfStandardSecurityHandlerDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapCatalogDictionary(const SkPdfObject& in, SkPdfCatalogDictionary** out) {
+ return mapCatalogDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCatalogDictionary** out) {
+ if (!isCatalogDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfCatalogDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapPageTreeNodeDictionary(const SkPdfObject& in, SkPdfPageTreeNodeDictionary** out) {
+ return mapPageTreeNodeDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageTreeNodeDictionary** out) {
+ if (!isPageTreeNodeDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfPageTreeNodeDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapPageObjectDictionary(const SkPdfObject& in, SkPdfPageObjectDictionary** out) {
+ return mapPageObjectDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectDictionary** out) {
+ if (!isPageObjectDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfPageObjectDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapNameDictionary(const SkPdfObject& in, SkPdfNameDictionary** out) {
+ return mapNameDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameDictionary** out) {
+ if (!isNameDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfNameDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapResourceDictionary(const SkPdfObject& in, SkPdfResourceDictionary** out) {
+ return mapResourceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResourceDictionary** out) {
+ if (!isResourceDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfResourceDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapNameTreeNodeDictionary(const SkPdfObject& in, SkPdfNameTreeNodeDictionary** out) {
+ return mapNameTreeNodeDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameTreeNodeDictionary** out) {
+ if (!isNameTreeNodeDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfNameTreeNodeDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapNumberTreeNodeDictionary(const SkPdfObject& in, SkPdfNumberTreeNodeDictionary** out) {
+ return mapNumberTreeNodeDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumberTreeNodeDictionary** out) {
+ if (!isNumberTreeNodeDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfNumberTreeNodeDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFunctionCommonDictionary(const SkPdfObject& in, SkPdfFunctionCommonDictionary** out) {
+ return mapFunctionCommonDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFunctionCommonDictionary** out) {
+ if (!isFunctionCommonDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFunctionCommonDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType0FunctionDictionary(const SkPdfObject& in, SkPdfType0FunctionDictionary** out) {
+ return mapType0FunctionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FunctionDictionary** out) {
+ if (!isType0FunctionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType0FunctionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType2FunctionDictionary(const SkPdfObject& in, SkPdfType2FunctionDictionary** out) {
+ return mapType2FunctionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2FunctionDictionary** out) {
+ if (!isType2FunctionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType2FunctionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType3FunctionDictionary(const SkPdfObject& in, SkPdfType3FunctionDictionary** out) {
+ return mapType3FunctionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FunctionDictionary** out) {
+ if (!isType3FunctionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType3FunctionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFileSpecificationDictionary(const SkPdfObject& in, SkPdfFileSpecificationDictionary** out) {
+ return mapFileSpecificationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileSpecificationDictionary** out) {
+ if (!isFileSpecificationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFileSpecificationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapEmbeddedFileStreamDictionary(const SkPdfObject& in, SkPdfEmbeddedFileStreamDictionary** out) {
+ return mapEmbeddedFileStreamDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileStreamDictionary** out) {
+ if (!isEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapEmbeddedFileParameterDictionary(const SkPdfObject& in, SkPdfEmbeddedFileParameterDictionary** out) {
+ return mapEmbeddedFileParameterDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileParameterDictionary** out) {
+ if (!isEmbeddedFileParameterDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfEmbeddedFileParameterDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapMacOsFileInformationDictionary(const SkPdfObject& in, SkPdfMacOsFileInformationDictionary** out) {
+ return mapMacOsFileInformationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMacOsFileInformationDictionary** out) {
+ if (!isMacOsFileInformationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfMacOsFileInformationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapGraphicsStateDictionary(const SkPdfObject& in, SkPdfGraphicsStateDictionary** out) {
+ return mapGraphicsStateDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGraphicsStateDictionary** out) {
+ if (!isGraphicsStateDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfGraphicsStateDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapCalgrayColorSpaceDictionary(const SkPdfObject& in, SkPdfCalgrayColorSpaceDictionary** out) {
+ return mapCalgrayColorSpaceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalgrayColorSpaceDictionary** out) {
+ if (!isCalgrayColorSpaceDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfCalgrayColorSpaceDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapCalrgbColorSpaceDictionary(const SkPdfObject& in, SkPdfCalrgbColorSpaceDictionary** out) {
+ return mapCalrgbColorSpaceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalrgbColorSpaceDictionary** out) {
+ if (!isCalrgbColorSpaceDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfCalrgbColorSpaceDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapLabColorSpaceDictionary(const SkPdfObject& in, SkPdfLabColorSpaceDictionary** out) {
+ return mapLabColorSpaceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLabColorSpaceDictionary** out) {
+ if (!isLabColorSpaceDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfLabColorSpaceDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapIccProfileStreamDictionary(const SkPdfObject& in, SkPdfIccProfileStreamDictionary** out) {
+ return mapIccProfileStreamDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIccProfileStreamDictionary** out) {
+ if (!isIccProfileStreamDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfIccProfileStreamDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapDeviceNColorSpaceDictionary(const SkPdfObject& in, SkPdfDeviceNColorSpaceDictionary** out) {
+ return mapDeviceNColorSpaceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDeviceNColorSpaceDictionary** out) {
+ if (!isDeviceNColorSpaceDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfDeviceNColorSpaceDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType1PatternDictionary(const SkPdfObject& in, SkPdfType1PatternDictionary** out) {
+ return mapType1PatternDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1PatternDictionary** out) {
+ if (!isType1PatternDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType1PatternDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType2PatternDictionary(const SkPdfObject& in, SkPdfType2PatternDictionary** out) {
+ return mapType2PatternDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2PatternDictionary** out) {
+ if (!isType2PatternDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType2PatternDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapShadingDictionary(const SkPdfObject& in, SkPdfShadingDictionary** out) {
+ return mapShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfShadingDictionary** out) {
+ if (!isShadingDictionary(podofoDoc, podofoObj)) return false;
+
+ if (mapType1ShadingDictionary(podofoDoc, podofoObj, (SkPdfType1ShadingDictionary**)out)) return true;
+ if (mapType2ShadingDictionary(podofoDoc, podofoObj, (SkPdfType2ShadingDictionary**)out)) return true;
+ if (mapType3ShadingDictionary(podofoDoc, podofoObj, (SkPdfType3ShadingDictionary**)out)) return true;
+ if (mapType4ShadingDictionary(podofoDoc, podofoObj, (SkPdfType4ShadingDictionary**)out)) return true;
+ if (mapType5ShadingDictionary(podofoDoc, podofoObj, (SkPdfType5ShadingDictionary**)out)) return true;
+ if (mapType6ShadingDictionary(podofoDoc, podofoObj, (SkPdfType6ShadingDictionary**)out)) return true;
+
+ *out = new SkPdfShadingDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType1ShadingDictionary(const SkPdfObject& in, SkPdfType1ShadingDictionary** out) {
+ return mapType1ShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1ShadingDictionary** out) {
+ if (!isType1ShadingDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType1ShadingDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType2ShadingDictionary(const SkPdfObject& in, SkPdfType2ShadingDictionary** out) {
+ return mapType2ShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2ShadingDictionary** out) {
+ if (!isType2ShadingDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType2ShadingDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType3ShadingDictionary(const SkPdfObject& in, SkPdfType3ShadingDictionary** out) {
+ return mapType3ShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3ShadingDictionary** out) {
+ if (!isType3ShadingDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType3ShadingDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType4ShadingDictionary(const SkPdfObject& in, SkPdfType4ShadingDictionary** out) {
+ return mapType4ShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType4ShadingDictionary** out) {
+ if (!isType4ShadingDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType4ShadingDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType5ShadingDictionary(const SkPdfObject& in, SkPdfType5ShadingDictionary** out) {
+ return mapType5ShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5ShadingDictionary** out) {
+ if (!isType5ShadingDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType5ShadingDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType6ShadingDictionary(const SkPdfObject& in, SkPdfType6ShadingDictionary** out) {
+ return mapType6ShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6ShadingDictionary** out) {
+ if (!isType6ShadingDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType6ShadingDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapImageDictionary(const SkPdfObject& in, SkPdfImageDictionary** out) {
+ return mapImageDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImageDictionary** out) {
+ if (!isImageDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfImageDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapAlternateImageDictionary(const SkPdfObject& in, SkPdfAlternateImageDictionary** out) {
+ return mapAlternateImageDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAlternateImageDictionary** out) {
+ if (!isAlternateImageDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfAlternateImageDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType1FormDictionary(const SkPdfObject& in, SkPdfType1FormDictionary** out) {
+ return mapType1FormDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FormDictionary** out) {
+ if (!isType1FormDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType1FormDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapGroupAttributesDictionary(const SkPdfObject& in, SkPdfGroupAttributesDictionary** out) {
+ return mapGroupAttributesDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGroupAttributesDictionary** out) {
+ if (!isGroupAttributesDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfGroupAttributesDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapReferenceDictionary(const SkPdfObject& in, SkPdfReferenceDictionary** out) {
+ return mapReferenceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReferenceDictionary** out) {
+ if (!isReferenceDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfReferenceDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapPSXobjectDictionary(const SkPdfObject& in, SkPdfPSXobjectDictionary** out) {
+ return mapPSXobjectDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPSXobjectDictionary** out) {
+ if (!isPSXobjectDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfPSXobjectDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType1FontDictionary(const SkPdfObject& in, SkPdfType1FontDictionary** out) {
+ return mapType1FontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FontDictionary** out) {
+ if (!isType1FontDictionary(podofoDoc, podofoObj)) return false;
+
+ if (mapMultiMasterFontDictionary(podofoDoc, podofoObj, (SkPdfMultiMasterFontDictionary**)out)) return true;
+ if (mapTrueTypeFontDictionary(podofoDoc, podofoObj, (SkPdfTrueTypeFontDictionary**)out)) return true;
+ if (mapType3FontDictionary(podofoDoc, podofoObj, (SkPdfType3FontDictionary**)out)) return true;
+
+ *out = new SkPdfType1FontDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType3FontDictionary(const SkPdfObject& in, SkPdfType3FontDictionary** out) {
+ return mapType3FontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FontDictionary** out) {
+ if (!isType3FontDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType3FontDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapEncodingDictionary(const SkPdfObject& in, SkPdfEncodingDictionary** out) {
+ return mapEncodingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncodingDictionary** out) {
+ if (!isEncodingDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfEncodingDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapCIDSystemInfoDictionary(const SkPdfObject& in, SkPdfCIDSystemInfoDictionary** out) {
+ return mapCIDSystemInfoDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDSystemInfoDictionary** out) {
+ if (!isCIDSystemInfoDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfCIDSystemInfoDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapCIDFontDictionary(const SkPdfObject& in, SkPdfCIDFontDictionary** out) {
+ return mapCIDFontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDictionary** out) {
+ if (!isCIDFontDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfCIDFontDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapCMapDictionary(const SkPdfObject& in, SkPdfCMapDictionary** out) {
+ return mapCMapDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCMapDictionary** out) {
+ if (!isCMapDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfCMapDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType0FontDictionary(const SkPdfObject& in, SkPdfType0FontDictionary** out) {
+ return mapType0FontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FontDictionary** out) {
+ if (!isType0FontDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType0FontDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFontDescriptorDictionary(const SkPdfObject& in, SkPdfFontDescriptorDictionary** out) {
+ return mapFontDescriptorDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDescriptorDictionary** out) {
+ if (!isFontDescriptorDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFontDescriptorDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapCIDFontDescriptorDictionary(const SkPdfObject& in, SkPdfCIDFontDescriptorDictionary** out) {
+ return mapCIDFontDescriptorDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDescriptorDictionary** out) {
+ if (!isCIDFontDescriptorDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfCIDFontDescriptorDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapEmbeddedFontStreamDictionary(const SkPdfObject& in, SkPdfEmbeddedFontStreamDictionary** out) {
+ return mapEmbeddedFontStreamDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFontStreamDictionary** out) {
+ if (!isEmbeddedFontStreamDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfEmbeddedFontStreamDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType1HalftoneDictionary(const SkPdfObject& in, SkPdfType1HalftoneDictionary** out) {
+ return mapType1HalftoneDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1HalftoneDictionary** out) {
+ if (!isType1HalftoneDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType1HalftoneDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType6HalftoneDictionary(const SkPdfObject& in, SkPdfType6HalftoneDictionary** out) {
+ return mapType6HalftoneDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6HalftoneDictionary** out) {
+ if (!isType6HalftoneDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType6HalftoneDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType10HalftoneDictionary(const SkPdfObject& in, SkPdfType10HalftoneDictionary** out) {
+ return mapType10HalftoneDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType10HalftoneDictionary** out) {
+ if (!isType10HalftoneDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType10HalftoneDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType16HalftoneDictionary(const SkPdfObject& in, SkPdfType16HalftoneDictionary** out) {
+ return mapType16HalftoneDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType16HalftoneDictionary** out) {
+ if (!isType16HalftoneDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType16HalftoneDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapType5HalftoneDictionary(const SkPdfObject& in, SkPdfType5HalftoneDictionary** out) {
+ return mapType5HalftoneDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5HalftoneDictionary** out) {
+ if (!isType5HalftoneDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfType5HalftoneDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapSoftMaskDictionary(const SkPdfObject& in, SkPdfSoftMaskDictionary** out) {
+ return mapSoftMaskDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskDictionary** out) {
+ if (!isSoftMaskDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfSoftMaskDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapSoftMaskImageDictionary(const SkPdfObject& in, SkPdfSoftMaskImageDictionary** out) {
+ return mapSoftMaskImageDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskImageDictionary** out) {
+ if (!isSoftMaskImageDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfSoftMaskImageDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapTransparencyGroupDictionary(const SkPdfObject& in, SkPdfTransparencyGroupDictionary** out) {
+ return mapTransparencyGroupDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransparencyGroupDictionary** out) {
+ if (!isTransparencyGroupDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfTransparencyGroupDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapViewerPreferencesDictionary(const SkPdfObject& in, SkPdfViewerPreferencesDictionary** out) {
+ return mapViewerPreferencesDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfViewerPreferencesDictionary** out) {
+ if (!isViewerPreferencesDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfViewerPreferencesDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapOutlineDictionary(const SkPdfObject& in, SkPdfOutlineDictionary** out) {
+ return mapOutlineDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineDictionary** out) {
+ if (!isOutlineDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfOutlineDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapOutlineItemDictionary(const SkPdfObject& in, SkPdfOutlineItemDictionary** out) {
+ return mapOutlineItemDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineItemDictionary** out) {
+ if (!isOutlineItemDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfOutlineItemDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapPageLabelDictionary(const SkPdfObject& in, SkPdfPageLabelDictionary** out) {
+ return mapPageLabelDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageLabelDictionary** out) {
+ if (!isPageLabelDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfPageLabelDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapThreadDictionary(const SkPdfObject& in, SkPdfThreadDictionary** out) {
+ return mapThreadDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadDictionary** out) {
+ if (!isThreadDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfThreadDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapBeadDictionary(const SkPdfObject& in, SkPdfBeadDictionary** out) {
+ return mapBeadDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBeadDictionary** out) {
+ if (!isBeadDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfBeadDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapTransitionDictionary(const SkPdfObject& in, SkPdfTransitionDictionary** out) {
+ return mapTransitionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransitionDictionary** out) {
+ if (!isTransitionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfTransitionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapAnnotationDictionary(const SkPdfObject& in, SkPdfAnnotationDictionary** out) {
+ return mapAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationDictionary** out) {
+ if (!isAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapBorderStyleDictionary(const SkPdfObject& in, SkPdfBorderStyleDictionary** out) {
+ return mapBorderStyleDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBorderStyleDictionary** out) {
+ if (!isBorderStyleDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfBorderStyleDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapAppearanceDictionary(const SkPdfObject& in, SkPdfAppearanceDictionary** out) {
+ return mapAppearanceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceDictionary** out) {
+ if (!isAppearanceDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfAppearanceDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapTextAnnotationDictionary(const SkPdfObject& in, SkPdfTextAnnotationDictionary** out) {
+ return mapTextAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextAnnotationDictionary** out) {
+ if (!isTextAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfTextAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapALinkAnnotationDictionary(const SkPdfObject& in, SkPdfALinkAnnotationDictionary** out) {
+ return mapALinkAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfALinkAnnotationDictionary** out) {
+ if (!isALinkAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfALinkAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFreeTextAnnotationDictionary(const SkPdfObject& in, SkPdfFreeTextAnnotationDictionary** out) {
+ return mapFreeTextAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFreeTextAnnotationDictionary** out) {
+ if (!isFreeTextAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFreeTextAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapLineAnnotationDictionary(const SkPdfObject& in, SkPdfLineAnnotationDictionary** out) {
+ return mapLineAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLineAnnotationDictionary** out) {
+ if (!isLineAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfLineAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapSquareOrCircleAnnotation(const SkPdfObject& in, SkPdfSquareOrCircleAnnotation** out) {
+ return mapSquareOrCircleAnnotation(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSquareOrCircleAnnotation** out) {
+ if (!isSquareOrCircleAnnotation(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfSquareOrCircleAnnotation(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapMarkupAnnotationsDictionary(const SkPdfObject& in, SkPdfMarkupAnnotationsDictionary** out) {
+ return mapMarkupAnnotationsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkupAnnotationsDictionary** out) {
+ if (!isMarkupAnnotationsDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfMarkupAnnotationsDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapRubberStampAnnotationDictionary(const SkPdfObject& in, SkPdfRubberStampAnnotationDictionary** out) {
+ return mapRubberStampAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRubberStampAnnotationDictionary** out) {
+ if (!isRubberStampAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfRubberStampAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapInkAnnotationDictionary(const SkPdfObject& in, SkPdfInkAnnotationDictionary** out) {
+ return mapInkAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInkAnnotationDictionary** out) {
+ if (!isInkAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfInkAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapPopUpAnnotationDictionary(const SkPdfObject& in, SkPdfPopUpAnnotationDictionary** out) {
+ return mapPopUpAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPopUpAnnotationDictionary** out) {
+ if (!isPopUpAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfPopUpAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFileAttachmentAnnotationDictionary(const SkPdfObject& in, SkPdfFileAttachmentAnnotationDictionary** out) {
+ return mapFileAttachmentAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileAttachmentAnnotationDictionary** out) {
+ if (!isFileAttachmentAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFileAttachmentAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapSoundAnnotationDictionary(const SkPdfObject& in, SkPdfSoundAnnotationDictionary** out) {
+ return mapSoundAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundAnnotationDictionary** out) {
+ if (!isSoundAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfSoundAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapMovieAnnotationDictionary(const SkPdfObject& in, SkPdfMovieAnnotationDictionary** out) {
+ return mapMovieAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieAnnotationDictionary** out) {
+ if (!isMovieAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfMovieAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapWidgetAnnotationDictionary(const SkPdfObject& in, SkPdfWidgetAnnotationDictionary** out) {
+ return mapWidgetAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWidgetAnnotationDictionary** out) {
+ if (!isWidgetAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfWidgetAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapActionDictionary(const SkPdfObject& in, SkPdfActionDictionary** out) {
+ return mapActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfActionDictionary** out) {
+ if (!isActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapAnnotationActionsDictionary(const SkPdfObject& in, SkPdfAnnotationActionsDictionary** out) {
+ return mapAnnotationActionsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationActionsDictionary** out) {
+ if (!isAnnotationActionsDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfAnnotationActionsDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapPageObjectActionsDictionary(const SkPdfObject& in, SkPdfPageObjectActionsDictionary** out) {
+ return mapPageObjectActionsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectActionsDictionary** out) {
+ if (!isPageObjectActionsDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfPageObjectActionsDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFormFieldActionsDictionary(const SkPdfObject& in, SkPdfFormFieldActionsDictionary** out) {
+ return mapFormFieldActionsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFormFieldActionsDictionary** out) {
+ if (!isFormFieldActionsDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFormFieldActionsDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapDocumentCatalogActionsDictionary(const SkPdfObject& in, SkPdfDocumentCatalogActionsDictionary** out) {
+ return mapDocumentCatalogActionsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentCatalogActionsDictionary** out) {
+ if (!isDocumentCatalogActionsDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfDocumentCatalogActionsDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapGoToActionDictionary(const SkPdfObject& in, SkPdfGoToActionDictionary** out) {
+ return mapGoToActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGoToActionDictionary** out) {
+ if (!isGoToActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfGoToActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapRemoteGoToActionDictionary(const SkPdfObject& in, SkPdfRemoteGoToActionDictionary** out) {
+ return mapRemoteGoToActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRemoteGoToActionDictionary** out) {
+ if (!isRemoteGoToActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfRemoteGoToActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapLaunchActionDictionary(const SkPdfObject& in, SkPdfLaunchActionDictionary** out) {
+ return mapLaunchActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLaunchActionDictionary** out) {
+ if (!isLaunchActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfLaunchActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapWindowsLaunchActionDictionary(const SkPdfObject& in, SkPdfWindowsLaunchActionDictionary** out) {
+ return mapWindowsLaunchActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWindowsLaunchActionDictionary** out) {
+ if (!isWindowsLaunchActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfWindowsLaunchActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapThreadActionDictionary(const SkPdfObject& in, SkPdfThreadActionDictionary** out) {
+ return mapThreadActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadActionDictionary** out) {
+ if (!isThreadActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfThreadActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapURIActionDictionary(const SkPdfObject& in, SkPdfURIActionDictionary** out) {
+ return mapURIActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIActionDictionary** out) {
+ if (!isURIActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfURIActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapURIDictionary(const SkPdfObject& in, SkPdfURIDictionary** out) {
+ return mapURIDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIDictionary** out) {
+ if (!isURIDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfURIDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapSoundActionDictionary(const SkPdfObject& in, SkPdfSoundActionDictionary** out) {
+ return mapSoundActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundActionDictionary** out) {
+ if (!isSoundActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfSoundActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapMovieActionDictionary(const SkPdfObject& in, SkPdfMovieActionDictionary** out) {
+ return mapMovieActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActionDictionary** out) {
+ if (!isMovieActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfMovieActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapHideActionDictionary(const SkPdfObject& in, SkPdfHideActionDictionary** out) {
+ return mapHideActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHideActionDictionary** out) {
+ if (!isHideActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfHideActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapNamedActionsDictionary(const SkPdfObject& in, SkPdfNamedActionsDictionary** out) {
+ return mapNamedActionsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNamedActionsDictionary** out) {
+ if (!isNamedActionsDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfNamedActionsDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapInteractiveFormDictionary(const SkPdfObject& in, SkPdfInteractiveFormDictionary** out) {
+ return mapInteractiveFormDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteractiveFormDictionary** out) {
+ if (!isInteractiveFormDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfInteractiveFormDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFieldDictionary(const SkPdfObject& in, SkPdfFieldDictionary** out) {
+ return mapFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFieldDictionary** out) {
+ if (!isFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFieldDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapVariableTextFieldDictionary(const SkPdfObject& in, SkPdfVariableTextFieldDictionary** out) {
+ return mapVariableTextFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfVariableTextFieldDictionary** out) {
+ if (!isVariableTextFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfVariableTextFieldDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapAppearanceCharacteristicsDictionary(const SkPdfObject& in, SkPdfAppearanceCharacteristicsDictionary** out) {
+ return mapAppearanceCharacteristicsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceCharacteristicsDictionary** out) {
+ if (!isAppearanceCharacteristicsDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfAppearanceCharacteristicsDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapCheckboxFieldDictionary(const SkPdfObject& in, SkPdfCheckboxFieldDictionary** out) {
+ return mapCheckboxFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCheckboxFieldDictionary** out) {
+ if (!isCheckboxFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfCheckboxFieldDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapRadioButtonFieldDictionary(const SkPdfObject& in, SkPdfRadioButtonFieldDictionary** out) {
+ return mapRadioButtonFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRadioButtonFieldDictionary** out) {
+ if (!isRadioButtonFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfRadioButtonFieldDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapTextFieldDictionary(const SkPdfObject& in, SkPdfTextFieldDictionary** out) {
+ return mapTextFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextFieldDictionary** out) {
+ if (!isTextFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfTextFieldDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapChoiceFieldDictionary(const SkPdfObject& in, SkPdfChoiceFieldDictionary** out) {
+ return mapChoiceFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfChoiceFieldDictionary** out) {
+ if (!isChoiceFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfChoiceFieldDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapSignatureDictionary(const SkPdfObject& in, SkPdfSignatureDictionary** out) {
+ return mapSignatureDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSignatureDictionary** out) {
+ if (!isSignatureDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfSignatureDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapSubmitFormActionDictionary(const SkPdfObject& in, SkPdfSubmitFormActionDictionary** out) {
+ return mapSubmitFormActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSubmitFormActionDictionary** out) {
+ if (!isSubmitFormActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfSubmitFormActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapResetFormActionDictionary(const SkPdfObject& in, SkPdfResetFormActionDictionary** out) {
+ return mapResetFormActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResetFormActionDictionary** out) {
+ if (!isResetFormActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfResetFormActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapImportDataActionDictionary(const SkPdfObject& in, SkPdfImportDataActionDictionary** out) {
+ return mapImportDataActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImportDataActionDictionary** out) {
+ if (!isImportDataActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfImportDataActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapJavascriptActionDictionary(const SkPdfObject& in, SkPdfJavascriptActionDictionary** out) {
+ return mapJavascriptActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptActionDictionary** out) {
+ if (!isJavascriptActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfJavascriptActionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFDFTrailerDictionary(const SkPdfObject& in, SkPdfFDFTrailerDictionary** out) {
+ return mapFDFTrailerDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTrailerDictionary** out) {
+ if (!isFDFTrailerDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFDFTrailerDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFDFCatalogDictionary(const SkPdfObject& in, SkPdfFDFCatalogDictionary** out) {
+ return mapFDFCatalogDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFCatalogDictionary** out) {
+ if (!isFDFCatalogDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFDFCatalogDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFDFDictionary(const SkPdfObject& in, SkPdfFDFDictionary** out) {
+ return mapFDFDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFDictionary** out) {
+ if (!isFDFDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFDFDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapEncryptedEmbeddedFileStreamDictionary(const SkPdfObject& in, SkPdfEncryptedEmbeddedFileStreamDictionary** out) {
+ return mapEncryptedEmbeddedFileStreamDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptedEmbeddedFileStreamDictionary** out) {
+ if (!isEncryptedEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfEncryptedEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapJavascriptDictionary(const SkPdfObject& in, SkPdfJavascriptDictionary** out) {
+ return mapJavascriptDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptDictionary** out) {
+ if (!isJavascriptDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfJavascriptDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFDFFieldDictionary(const SkPdfObject& in, SkPdfFDFFieldDictionary** out) {
+ return mapFDFFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFieldDictionary** out) {
+ if (!isFDFFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFDFFieldDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapIconFitDictionary(const SkPdfObject& in, SkPdfIconFitDictionary** out) {
+ return mapIconFitDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIconFitDictionary** out) {
+ if (!isIconFitDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfIconFitDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFDFPageDictionary(const SkPdfObject& in, SkPdfFDFPageDictionary** out) {
+ return mapFDFPageDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFPageDictionary** out) {
+ if (!isFDFPageDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFDFPageDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFDFTemplateDictionary(const SkPdfObject& in, SkPdfFDFTemplateDictionary** out) {
+ return mapFDFTemplateDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTemplateDictionary** out) {
+ if (!isFDFTemplateDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFDFTemplateDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFDFNamedPageReferenceDictionary(const SkPdfObject& in, SkPdfFDFNamedPageReferenceDictionary** out) {
+ return mapFDFNamedPageReferenceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFNamedPageReferenceDictionary** out) {
+ if (!isFDFNamedPageReferenceDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFDFNamedPageReferenceDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapFDFFileAnnotationDictionary(const SkPdfObject& in, SkPdfFDFFileAnnotationDictionary** out) {
+ return mapFDFFileAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFileAnnotationDictionary** out) {
+ if (!isFDFFileAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfFDFFileAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapSoundObjectDictionary(const SkPdfObject& in, SkPdfSoundObjectDictionary** out) {
+ return mapSoundObjectDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundObjectDictionary** out) {
+ if (!isSoundObjectDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfSoundObjectDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapMovieDictionary(const SkPdfObject& in, SkPdfMovieDictionary** out) {
+ return mapMovieDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieDictionary** out) {
+ if (!isMovieDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfMovieDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapMovieActivationDictionary(const SkPdfObject& in, SkPdfMovieActivationDictionary** out) {
+ return mapMovieActivationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActivationDictionary** out) {
+ if (!isMovieActivationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfMovieActivationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapDocumentInformationDictionary(const SkPdfObject& in, SkPdfDocumentInformationDictionary** out) {
+ return mapDocumentInformationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentInformationDictionary** out) {
+ if (!isDocumentInformationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfDocumentInformationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapMetadataStreamDictionary(const SkPdfObject& in, SkPdfMetadataStreamDictionary** out) {
+ return mapMetadataStreamDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMetadataStreamDictionary** out) {
+ if (!isMetadataStreamDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfMetadataStreamDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapComponentsWithMetadataDictionary(const SkPdfObject& in, SkPdfComponentsWithMetadataDictionary** out) {
+ return mapComponentsWithMetadataDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfComponentsWithMetadataDictionary** out) {
+ if (!isComponentsWithMetadataDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfComponentsWithMetadataDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapPagePieceDictionary(const SkPdfObject& in, SkPdfPagePieceDictionary** out) {
+ return mapPagePieceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPagePieceDictionary** out) {
+ if (!isPagePieceDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfPagePieceDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapApplicationDataDictionary(const SkPdfObject& in, SkPdfApplicationDataDictionary** out) {
+ return mapApplicationDataDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfApplicationDataDictionary** out) {
+ if (!isApplicationDataDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfApplicationDataDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapStructureTreeRootDictionary(const SkPdfObject& in, SkPdfStructureTreeRootDictionary** out) {
+ return mapStructureTreeRootDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureTreeRootDictionary** out) {
+ if (!isStructureTreeRootDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfStructureTreeRootDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapStructureElementDictionary(const SkPdfObject& in, SkPdfStructureElementDictionary** out) {
+ return mapStructureElementDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementDictionary** out) {
+ if (!isStructureElementDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfStructureElementDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapMarkedContentReferenceDictionary(const SkPdfObject& in, SkPdfMarkedContentReferenceDictionary** out) {
+ return mapMarkedContentReferenceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkedContentReferenceDictionary** out) {
+ if (!isMarkedContentReferenceDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfMarkedContentReferenceDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapObjectReferenceDictionary(const SkPdfObject& in, SkPdfObjectReferenceDictionary** out) {
+ return mapObjectReferenceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObjectReferenceDictionary** out) {
+ if (!isObjectReferenceDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfObjectReferenceDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapStructureElementAccessDictionary(const SkPdfObject& in, SkPdfStructureElementAccessDictionary** out) {
+ return mapStructureElementAccessDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementAccessDictionary** out) {
+ if (!isStructureElementAccessDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfStructureElementAccessDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapAttributeObjectDictionary(const SkPdfObject& in, SkPdfAttributeObjectDictionary** out) {
+ return mapAttributeObjectDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAttributeObjectDictionary** out) {
+ if (!isAttributeObjectDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfAttributeObjectDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapMarkInformationDictionary(const SkPdfObject& in, SkPdfMarkInformationDictionary** out) {
+ return mapMarkInformationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkInformationDictionary** out) {
+ if (!isMarkInformationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfMarkInformationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapArtifactsDictionary(const SkPdfObject& in, SkPdfArtifactsDictionary** out) {
+ return mapArtifactsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArtifactsDictionary** out) {
+ if (!isArtifactsDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfArtifactsDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapStandardStructureDictionary(const SkPdfObject& in, SkPdfStandardStructureDictionary** out) {
+ return mapStandardStructureDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardStructureDictionary** out) {
+ if (!isStandardStructureDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfStandardStructureDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapBlockLevelStructureElementsDictionary(const SkPdfObject& in, SkPdfBlockLevelStructureElementsDictionary** out) {
+ return mapBlockLevelStructureElementsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBlockLevelStructureElementsDictionary** out) {
+ if (!isBlockLevelStructureElementsDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfBlockLevelStructureElementsDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapInlineLevelStructureElementsDictionary(const SkPdfObject& in, SkPdfInlineLevelStructureElementsDictionary** out) {
+ return mapInlineLevelStructureElementsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInlineLevelStructureElementsDictionary** out) {
+ if (!isInlineLevelStructureElementsDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfInlineLevelStructureElementsDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapListAttributeDictionary(const SkPdfObject& in, SkPdfListAttributeDictionary** out) {
+ return mapListAttributeDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfListAttributeDictionary** out) {
+ if (!isListAttributeDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfListAttributeDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapTableAttributesDictionary(const SkPdfObject& in, SkPdfTableAttributesDictionary** out) {
+ return mapTableAttributesDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTableAttributesDictionary** out) {
+ if (!isTableAttributesDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfTableAttributesDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapWebCaptureInformationDictionary(const SkPdfObject& in, SkPdfWebCaptureInformationDictionary** out) {
+ return mapWebCaptureInformationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureInformationDictionary** out) {
+ if (!isWebCaptureInformationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfWebCaptureInformationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapWebCaptureDictionary(const SkPdfObject& in, SkPdfWebCaptureDictionary** out) {
+ return mapWebCaptureDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureDictionary** out) {
+ if (!isWebCaptureDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfWebCaptureDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapWebCapturePageSetDictionary(const SkPdfObject& in, SkPdfWebCapturePageSetDictionary** out) {
+ return mapWebCapturePageSetDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCapturePageSetDictionary** out) {
+ if (!isWebCapturePageSetDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfWebCapturePageSetDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapWebCaptureImageSetDictionary(const SkPdfObject& in, SkPdfWebCaptureImageSetDictionary** out) {
+ return mapWebCaptureImageSetDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureImageSetDictionary** out) {
+ if (!isWebCaptureImageSetDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfWebCaptureImageSetDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapSourceInformationDictionary(const SkPdfObject& in, SkPdfSourceInformationDictionary** out) {
+ return mapSourceInformationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSourceInformationDictionary** out) {
+ if (!isSourceInformationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfSourceInformationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapURLAliasDictionary(const SkPdfObject& in, SkPdfURLAliasDictionary** out) {
+ return mapURLAliasDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURLAliasDictionary** out) {
+ if (!isURLAliasDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfURLAliasDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapWebCaptureCommandDictionary(const SkPdfObject& in, SkPdfWebCaptureCommandDictionary** out) {
+ return mapWebCaptureCommandDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandDictionary** out) {
+ if (!isWebCaptureCommandDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfWebCaptureCommandDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapWebCaptureCommandSettingsDictionary(const SkPdfObject& in, SkPdfWebCaptureCommandSettingsDictionary** out) {
+ return mapWebCaptureCommandSettingsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandSettingsDictionary** out) {
+ if (!isWebCaptureCommandSettingsDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfWebCaptureCommandSettingsDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapBoxColorInformationDictionary(const SkPdfObject& in, SkPdfBoxColorInformationDictionary** out) {
+ return mapBoxColorInformationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxColorInformationDictionary** out) {
+ if (!isBoxColorInformationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfBoxColorInformationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapBoxStyleDictionary(const SkPdfObject& in, SkPdfBoxStyleDictionary** out) {
+ return mapBoxStyleDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxStyleDictionary** out) {
+ if (!isBoxStyleDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfBoxStyleDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapPrinterMarkAnnotationDictionary(const SkPdfObject& in, SkPdfPrinterMarkAnnotationDictionary** out) {
+ return mapPrinterMarkAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkAnnotationDictionary** out) {
+ if (!isPrinterMarkAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfPrinterMarkAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapPrinterMarkFormDictionary(const SkPdfObject& in, SkPdfPrinterMarkFormDictionary** out) {
+ return mapPrinterMarkFormDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkFormDictionary** out) {
+ if (!isPrinterMarkFormDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfPrinterMarkFormDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapSeparationDictionary(const SkPdfObject& in, SkPdfSeparationDictionary** out) {
+ return mapSeparationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSeparationDictionary** out) {
+ if (!isSeparationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfSeparationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapPDF_XOutputIntentDictionary(const SkPdfObject& in, SkPdfPDF_XOutputIntentDictionary** out) {
+ return mapPDF_XOutputIntentDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPDF_XOutputIntentDictionary** out) {
+ if (!isPDF_XOutputIntentDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfPDF_XOutputIntentDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapTrapNetworkAnnotationDictionary(const SkPdfObject& in, SkPdfTrapNetworkAnnotationDictionary** out) {
+ return mapTrapNetworkAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAnnotationDictionary** out) {
+ if (!isTrapNetworkAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfTrapNetworkAnnotationDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapTrapNetworkAppearanceStreamDictionary(const SkPdfObject& in, SkPdfTrapNetworkAppearanceStreamDictionary** out) {
+ return mapTrapNetworkAppearanceStreamDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAppearanceStreamDictionary** out) {
+ if (!isTrapNetworkAppearanceStreamDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfTrapNetworkAppearanceStreamDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapOpiVersionDictionary(const SkPdfObject& in, SkPdfOpiVersionDictionary** out) {
+ return mapOpiVersionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOpiVersionDictionary** out) {
+ if (!isOpiVersionDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfOpiVersionDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool mapMultiMasterFontDictionary(const SkPdfObject& in, SkPdfMultiMasterFontDictionary** out) {
+ return mapMultiMasterFontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMultiMasterFontDictionary** out) {
+ if (!isMultiMasterFontDictionary(podofoDoc, podofoObj)) return false;
+
+
+ *out = new SkPdfMultiMasterFontDictionary(&podofoDoc, &podofoObj);
+ return true;
+}
+
+bool isObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ObjectFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfObject** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapObject(*pdfDoc, *value, (SkPdfObject**)data);
+}
+
+bool ObjectFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfObject** data) {
+ if (ObjectFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ObjectFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return podofoObj.GetDataType() == ePdfDataType_Null;
+}
+
+bool NullFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNull** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapNull(*pdfDoc, *value, (SkPdfNull**)data);
+}
+
+bool NullFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNull** data) {
+ if (NullFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return NullFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return podofoObj.GetDataType() == ePdfDataType_Bool;
+}
+
+bool BooleanFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBoolean** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapBoolean(*pdfDoc, *value, (SkPdfBoolean**)data);
+}
+
+bool BooleanFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBoolean** data) {
+ if (BooleanFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return BooleanFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return podofoObj.GetDataType() == ePdfDataType_Number || podofoObj.GetDataType() == ePdfDataType_Real;
+}
+
+bool IntegerFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInteger** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapInteger(*pdfDoc, *value, (SkPdfInteger**)data);
+}
+
+bool IntegerFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInteger** data) {
+ if (IntegerFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return IntegerFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return podofoObj.GetDataType() == ePdfDataType_Number || podofoObj.GetDataType() == ePdfDataType_Real;
+}
+
+bool NumberFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNumber** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapNumber(*pdfDoc, *value, (SkPdfNumber**)data);
+}
+
+bool NumberFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNumber** data) {
+ if (NumberFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return NumberFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return podofoObj.GetDataType() == ePdfDataType_Name;
+}
+
+bool NameFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfName** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapName(*pdfDoc, *value, (SkPdfName**)data);
+}
+
+bool NameFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfName** data) {
+ if (NameFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return NameFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return podofoObj.GetDataType() == ePdfDataType_Reference;
+}
+
+bool ReferenceFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfReference** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapReference(*pdfDoc, *value, (SkPdfReference**)data);
+}
+
+bool ReferenceFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfReference** data) {
+ if (ReferenceFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ReferenceFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return podofoObj.GetDataType() == ePdfDataType_Array;
+}
+
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfArray** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapArray(*pdfDoc, *value, (SkPdfArray**)data);
+}
+
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfArray** data) {
+ if (ArrayFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ArrayFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return podofoObj.GetDataType() == ePdfDataType_String || podofoObj.GetDataType() == ePdfDataType_HexString;
+}
+
+bool StringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfString** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapString(*pdfDoc, *value, (SkPdfString**)data);
+}
+
+bool StringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfString** data) {
+ if (StringFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return StringFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return podofoObj.GetDataType() == ePdfDataType_HexString;
+}
+
+bool HexStringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfHexString** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapHexString(*pdfDoc, *value, (SkPdfHexString**)data);
+}
+
+bool HexStringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfHexString** data) {
+ if (HexStringFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return HexStringFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return podofoObj.GetDataType() == ePdfDataType_Dictionary;
+}
+
+bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapDictionary(*pdfDoc, *value, (SkPdfDictionary**)data);
+}
+
+bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDictionary** data) {
+ if (DictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return DictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStream** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapStream(*pdfDoc, *value, (SkPdfStream**)data);
+}
+
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStream** data) {
+ if (StreamFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return StreamFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool XObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfXObjectDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapXObjectDictionary(*pdfDoc, *value, (SkPdfXObjectDictionary**)data);
+}
+
+bool XObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfXObjectDictionary** data) {
+ if (XObjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return XObjectDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFontDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFontDictionary(*pdfDoc, *value, (SkPdfFontDictionary**)data);
+}
+
+bool FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFontDictionary** data) {
+ if (FontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ std::string Subtype;
+ if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+ if ((Subtype != "TrueType")) return false;
+
+ return true;
+}
+
+bool TrueTypeFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrueTypeFontDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapTrueTypeFontDictionary(*pdfDoc, *value, (SkPdfTrueTypeFontDictionary**)data);
+}
+
+bool TrueTypeFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrueTypeFontDictionary** data) {
+ if (TrueTypeFontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return TrueTypeFontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool StreamCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStreamCommonDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapStreamCommonDictionary(*pdfDoc, *value, (SkPdfStreamCommonDictionary**)data);
+}
+
+bool StreamCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStreamCommonDictionary** data) {
+ if (StreamCommonDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return StreamCommonDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapLzwdecodeAndFlatedecodeFiltersDictionary(*pdfDoc, *value, (SkPdfLzwdecodeAndFlatedecodeFiltersDictionary**)data);
+}
+
+bool LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** data) {
+ if (LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool CcittfaxdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCcittfaxdecodeFilterDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapCcittfaxdecodeFilterDictionary(*pdfDoc, *value, (SkPdfCcittfaxdecodeFilterDictionary**)data);
+}
+
+bool CcittfaxdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCcittfaxdecodeFilterDictionary** data) {
+ if (CcittfaxdecodeFilterDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return CcittfaxdecodeFilterDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Jbig2DecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfJbig2DecodeFilterDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapJbig2DecodeFilterDictionary(*pdfDoc, *value, (SkPdfJbig2DecodeFilterDictionary**)data);
+}
+
+bool Jbig2DecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfJbig2DecodeFilterDictionary** data) {
+ if (Jbig2DecodeFilterDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Jbig2DecodeFilterDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool DctdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDctdecodeFilterDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapDctdecodeFilterDictionary(*pdfDoc, *value, (SkPdfDctdecodeFilterDictionary**)data);
+}
+
+bool DctdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDctdecodeFilterDictionary** data) {
+ if (DctdecodeFilterDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return DctdecodeFilterDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FileTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFileTrailerDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFileTrailerDictionary(*pdfDoc, *value, (SkPdfFileTrailerDictionary**)data);
+}
+
+bool FileTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileTrailerDictionary** data) {
+ if (FileTrailerDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FileTrailerDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool EncryptionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEncryptionCommonDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapEncryptionCommonDictionary(*pdfDoc, *value, (SkPdfEncryptionCommonDictionary**)data);
+}
+
+bool EncryptionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncryptionCommonDictionary** data) {
+ if (EncryptionCommonDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return EncryptionCommonDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool StandardSecurityHandlerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStandardSecurityHandlerDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapStandardSecurityHandlerDictionary(*pdfDoc, *value, (SkPdfStandardSecurityHandlerDictionary**)data);
+}
+
+bool StandardSecurityHandlerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStandardSecurityHandlerDictionary** data) {
+ if (StandardSecurityHandlerDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return StandardSecurityHandlerDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool CatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCatalogDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapCatalogDictionary(*pdfDoc, *value, (SkPdfCatalogDictionary**)data);
+}
+
+bool CatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCatalogDictionary** data) {
+ if (CatalogDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return CatalogDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool PageTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageTreeNodeDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapPageTreeNodeDictionary(*pdfDoc, *value, (SkPdfPageTreeNodeDictionary**)data);
+}
+
+bool PageTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageTreeNodeDictionary** data) {
+ if (PageTreeNodeDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return PageTreeNodeDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool PageObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageObjectDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapPageObjectDictionary(*pdfDoc, *value, (SkPdfPageObjectDictionary**)data);
+}
+
+bool PageObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageObjectDictionary** data) {
+ if (PageObjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return PageObjectDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool NameDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNameDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapNameDictionary(*pdfDoc, *value, (SkPdfNameDictionary**)data);
+}
+
+bool NameDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNameDictionary** data) {
+ if (NameDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return NameDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ResourceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfResourceDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapResourceDictionary(*pdfDoc, *value, (SkPdfResourceDictionary**)data);
+}
+
+bool ResourceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfResourceDictionary** data) {
+ if (ResourceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ResourceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool NameTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNameTreeNodeDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapNameTreeNodeDictionary(*pdfDoc, *value, (SkPdfNameTreeNodeDictionary**)data);
+}
+
+bool NameTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNameTreeNodeDictionary** data) {
+ if (NameTreeNodeDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return NameTreeNodeDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool NumberTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNumberTreeNodeDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapNumberTreeNodeDictionary(*pdfDoc, *value, (SkPdfNumberTreeNodeDictionary**)data);
+}
+
+bool NumberTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNumberTreeNodeDictionary** data) {
+ if (NumberTreeNodeDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return NumberTreeNodeDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FunctionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFunctionCommonDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFunctionCommonDictionary(*pdfDoc, *value, (SkPdfFunctionCommonDictionary**)data);
+}
+
+bool FunctionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFunctionCommonDictionary** data) {
+ if (FunctionCommonDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FunctionCommonDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type0FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType0FunctionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType0FunctionDictionary(*pdfDoc, *value, (SkPdfType0FunctionDictionary**)data);
+}
+
+bool Type0FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType0FunctionDictionary** data) {
+ if (Type0FunctionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type0FunctionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type2FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType2FunctionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType2FunctionDictionary(*pdfDoc, *value, (SkPdfType2FunctionDictionary**)data);
+}
+
+bool Type2FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType2FunctionDictionary** data) {
+ if (Type2FunctionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type2FunctionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type3FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType3FunctionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType3FunctionDictionary(*pdfDoc, *value, (SkPdfType3FunctionDictionary**)data);
+}
+
+bool Type3FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType3FunctionDictionary** data) {
+ if (Type3FunctionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type3FunctionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FileSpecificationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFileSpecificationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFileSpecificationDictionary(*pdfDoc, *value, (SkPdfFileSpecificationDictionary**)data);
+}
+
+bool FileSpecificationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileSpecificationDictionary** data) {
+ if (FileSpecificationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FileSpecificationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool EmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFileStreamDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapEmbeddedFileStreamDictionary(*pdfDoc, *value, (SkPdfEmbeddedFileStreamDictionary**)data);
+}
+
+bool EmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFileStreamDictionary** data) {
+ if (EmbeddedFileStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return EmbeddedFileStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool EmbeddedFileParameterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFileParameterDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapEmbeddedFileParameterDictionary(*pdfDoc, *value, (SkPdfEmbeddedFileParameterDictionary**)data);
+}
+
+bool EmbeddedFileParameterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFileParameterDictionary** data) {
+ if (EmbeddedFileParameterDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return EmbeddedFileParameterDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool MacOsFileInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMacOsFileInformationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapMacOsFileInformationDictionary(*pdfDoc, *value, (SkPdfMacOsFileInformationDictionary**)data);
+}
+
+bool MacOsFileInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMacOsFileInformationDictionary** data) {
+ if (MacOsFileInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return MacOsFileInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool GraphicsStateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGraphicsStateDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapGraphicsStateDictionary(*pdfDoc, *value, (SkPdfGraphicsStateDictionary**)data);
+}
+
+bool GraphicsStateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGraphicsStateDictionary** data) {
+ if (GraphicsStateDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return GraphicsStateDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool CalgrayColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCalgrayColorSpaceDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapCalgrayColorSpaceDictionary(*pdfDoc, *value, (SkPdfCalgrayColorSpaceDictionary**)data);
+}
+
+bool CalgrayColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCalgrayColorSpaceDictionary** data) {
+ if (CalgrayColorSpaceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return CalgrayColorSpaceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool CalrgbColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCalrgbColorSpaceDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapCalrgbColorSpaceDictionary(*pdfDoc, *value, (SkPdfCalrgbColorSpaceDictionary**)data);
+}
+
+bool CalrgbColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCalrgbColorSpaceDictionary** data) {
+ if (CalrgbColorSpaceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return CalrgbColorSpaceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool LabColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLabColorSpaceDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapLabColorSpaceDictionary(*pdfDoc, *value, (SkPdfLabColorSpaceDictionary**)data);
+}
+
+bool LabColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLabColorSpaceDictionary** data) {
+ if (LabColorSpaceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return LabColorSpaceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool IccProfileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfIccProfileStreamDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapIccProfileStreamDictionary(*pdfDoc, *value, (SkPdfIccProfileStreamDictionary**)data);
+}
+
+bool IccProfileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfIccProfileStreamDictionary** data) {
+ if (IccProfileStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return IccProfileStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool DeviceNColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDeviceNColorSpaceDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapDeviceNColorSpaceDictionary(*pdfDoc, *value, (SkPdfDeviceNColorSpaceDictionary**)data);
+}
+
+bool DeviceNColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDeviceNColorSpaceDictionary** data) {
+ if (DeviceNColorSpaceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return DeviceNColorSpaceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type1PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1PatternDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType1PatternDictionary(*pdfDoc, *value, (SkPdfType1PatternDictionary**)data);
+}
+
+bool Type1PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1PatternDictionary** data) {
+ if (Type1PatternDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type1PatternDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type2PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType2PatternDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType2PatternDictionary(*pdfDoc, *value, (SkPdfType2PatternDictionary**)data);
+}
+
+bool Type2PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType2PatternDictionary** data) {
+ if (Type2PatternDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type2PatternDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfShadingDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapShadingDictionary(*pdfDoc, *value, (SkPdfShadingDictionary**)data);
+}
+
+bool ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfShadingDictionary** data) {
+ if (ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type1ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1ShadingDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType1ShadingDictionary(*pdfDoc, *value, (SkPdfType1ShadingDictionary**)data);
+}
+
+bool Type1ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1ShadingDictionary** data) {
+ if (Type1ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type1ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type2ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType2ShadingDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType2ShadingDictionary(*pdfDoc, *value, (SkPdfType2ShadingDictionary**)data);
+}
+
+bool Type2ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType2ShadingDictionary** data) {
+ if (Type2ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type2ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type3ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType3ShadingDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType3ShadingDictionary(*pdfDoc, *value, (SkPdfType3ShadingDictionary**)data);
+}
+
+bool Type3ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType3ShadingDictionary** data) {
+ if (Type3ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type3ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type4ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType4ShadingDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType4ShadingDictionary(*pdfDoc, *value, (SkPdfType4ShadingDictionary**)data);
+}
+
+bool Type4ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType4ShadingDictionary** data) {
+ if (Type4ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type4ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type5ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType5ShadingDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType5ShadingDictionary(*pdfDoc, *value, (SkPdfType5ShadingDictionary**)data);
+}
+
+bool Type5ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType5ShadingDictionary** data) {
+ if (Type5ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type5ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type6ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType6ShadingDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType6ShadingDictionary(*pdfDoc, *value, (SkPdfType6ShadingDictionary**)data);
+}
+
+bool Type6ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType6ShadingDictionary** data) {
+ if (Type6ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type6ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ std::string Subtype;
+ if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+ if ((Subtype != "Image")) return false;
+
+ return true;
+}
+
+bool ImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfImageDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapImageDictionary(*pdfDoc, *value, (SkPdfImageDictionary**)data);
+}
+
+bool ImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfImageDictionary** data) {
+ if (ImageDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ImageDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool AlternateImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAlternateImageDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapAlternateImageDictionary(*pdfDoc, *value, (SkPdfAlternateImageDictionary**)data);
+}
+
+bool AlternateImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAlternateImageDictionary** data) {
+ if (AlternateImageDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return AlternateImageDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ std::string Subtype;
+ if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+ if ((Subtype != "Form")) return false;
+
+ return true;
+}
+
+bool Type1FormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1FormDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType1FormDictionary(*pdfDoc, *value, (SkPdfType1FormDictionary**)data);
+}
+
+bool Type1FormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1FormDictionary** data) {
+ if (Type1FormDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type1FormDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool GroupAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGroupAttributesDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapGroupAttributesDictionary(*pdfDoc, *value, (SkPdfGroupAttributesDictionary**)data);
+}
+
+bool GroupAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGroupAttributesDictionary** data) {
+ if (GroupAttributesDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return GroupAttributesDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfReferenceDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapReferenceDictionary(*pdfDoc, *value, (SkPdfReferenceDictionary**)data);
+}
+
+bool ReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfReferenceDictionary** data) {
+ if (ReferenceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ReferenceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool PSXobjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPSXobjectDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapPSXobjectDictionary(*pdfDoc, *value, (SkPdfPSXobjectDictionary**)data);
+}
+
+bool PSXobjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPSXobjectDictionary** data) {
+ if (PSXobjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return PSXobjectDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ std::string Subtype;
+ if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+ if ((Subtype != "MMType1") && (Subtype != "TrueType") && (Subtype != "Type3") && (Subtype != "Type1")) return false;
+
+ return true;
+}
+
+bool Type1FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1FontDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType1FontDictionary(*pdfDoc, *value, (SkPdfType1FontDictionary**)data);
+}
+
+bool Type1FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1FontDictionary** data) {
+ if (Type1FontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type1FontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ std::string Subtype;
+ if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+ if ((Subtype != "Type3")) return false;
+
+ return true;
+}
+
+bool Type3FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType3FontDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType3FontDictionary(*pdfDoc, *value, (SkPdfType3FontDictionary**)data);
+}
+
+bool Type3FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType3FontDictionary** data) {
+ if (Type3FontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type3FontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool EncodingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEncodingDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapEncodingDictionary(*pdfDoc, *value, (SkPdfEncodingDictionary**)data);
+}
+
+bool EncodingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncodingDictionary** data) {
+ if (EncodingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return EncodingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool CIDSystemInfoDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCIDSystemInfoDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapCIDSystemInfoDictionary(*pdfDoc, *value, (SkPdfCIDSystemInfoDictionary**)data);
+}
+
+bool CIDSystemInfoDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDSystemInfoDictionary** data) {
+ if (CIDSystemInfoDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return CIDSystemInfoDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ std::string Subtype;
+ if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+ if ((Subtype != "CIDFontType0") && (Subtype != "CIDFontType2")) return false;
+
+ return true;
+}
+
+bool CIDFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCIDFontDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapCIDFontDictionary(*pdfDoc, *value, (SkPdfCIDFontDictionary**)data);
+}
+
+bool CIDFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDFontDictionary** data) {
+ if (CIDFontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return CIDFontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool CMapDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCMapDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapCMapDictionary(*pdfDoc, *value, (SkPdfCMapDictionary**)data);
+}
+
+bool CMapDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCMapDictionary** data) {
+ if (CMapDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return CMapDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ std::string Subtype;
+ if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+ if ((Subtype != "Type0")) return false;
+
+ return true;
+}
+
+bool Type0FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType0FontDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType0FontDictionary(*pdfDoc, *value, (SkPdfType0FontDictionary**)data);
+}
+
+bool Type0FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType0FontDictionary** data) {
+ if (Type0FontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type0FontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFontDescriptorDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFontDescriptorDictionary(*pdfDoc, *value, (SkPdfFontDescriptorDictionary**)data);
+}
+
+bool FontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFontDescriptorDictionary** data) {
+ if (FontDescriptorDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FontDescriptorDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool CIDFontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCIDFontDescriptorDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapCIDFontDescriptorDictionary(*pdfDoc, *value, (SkPdfCIDFontDescriptorDictionary**)data);
+}
+
+bool CIDFontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDFontDescriptorDictionary** data) {
+ if (CIDFontDescriptorDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return CIDFontDescriptorDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool EmbeddedFontStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFontStreamDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapEmbeddedFontStreamDictionary(*pdfDoc, *value, (SkPdfEmbeddedFontStreamDictionary**)data);
+}
+
+bool EmbeddedFontStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFontStreamDictionary** data) {
+ if (EmbeddedFontStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return EmbeddedFontStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type1HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1HalftoneDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType1HalftoneDictionary(*pdfDoc, *value, (SkPdfType1HalftoneDictionary**)data);
+}
+
+bool Type1HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1HalftoneDictionary** data) {
+ if (Type1HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type1HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type6HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType6HalftoneDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType6HalftoneDictionary(*pdfDoc, *value, (SkPdfType6HalftoneDictionary**)data);
+}
+
+bool Type6HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType6HalftoneDictionary** data) {
+ if (Type6HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type6HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type10HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType10HalftoneDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType10HalftoneDictionary(*pdfDoc, *value, (SkPdfType10HalftoneDictionary**)data);
+}
+
+bool Type10HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType10HalftoneDictionary** data) {
+ if (Type10HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type10HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type16HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType16HalftoneDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType16HalftoneDictionary(*pdfDoc, *value, (SkPdfType16HalftoneDictionary**)data);
+}
+
+bool Type16HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType16HalftoneDictionary** data) {
+ if (Type16HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type16HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool Type5HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType5HalftoneDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapType5HalftoneDictionary(*pdfDoc, *value, (SkPdfType5HalftoneDictionary**)data);
+}
+
+bool Type5HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType5HalftoneDictionary** data) {
+ if (Type5HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return Type5HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool SoftMaskDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoftMaskDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapSoftMaskDictionary(*pdfDoc, *value, (SkPdfSoftMaskDictionary**)data);
+}
+
+bool SoftMaskDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoftMaskDictionary** data) {
+ if (SoftMaskDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return SoftMaskDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool SoftMaskImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoftMaskImageDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapSoftMaskImageDictionary(*pdfDoc, *value, (SkPdfSoftMaskImageDictionary**)data);
+}
+
+bool SoftMaskImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoftMaskImageDictionary** data) {
+ if (SoftMaskImageDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return SoftMaskImageDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool TransparencyGroupDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTransparencyGroupDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapTransparencyGroupDictionary(*pdfDoc, *value, (SkPdfTransparencyGroupDictionary**)data);
+}
+
+bool TransparencyGroupDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTransparencyGroupDictionary** data) {
+ if (TransparencyGroupDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return TransparencyGroupDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ViewerPreferencesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfViewerPreferencesDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapViewerPreferencesDictionary(*pdfDoc, *value, (SkPdfViewerPreferencesDictionary**)data);
+}
+
+bool ViewerPreferencesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfViewerPreferencesDictionary** data) {
+ if (ViewerPreferencesDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ViewerPreferencesDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool OutlineDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfOutlineDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapOutlineDictionary(*pdfDoc, *value, (SkPdfOutlineDictionary**)data);
+}
+
+bool OutlineDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfOutlineDictionary** data) {
+ if (OutlineDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return OutlineDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool OutlineItemDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfOutlineItemDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapOutlineItemDictionary(*pdfDoc, *value, (SkPdfOutlineItemDictionary**)data);
+}
+
+bool OutlineItemDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfOutlineItemDictionary** data) {
+ if (OutlineItemDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return OutlineItemDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool PageLabelDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageLabelDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapPageLabelDictionary(*pdfDoc, *value, (SkPdfPageLabelDictionary**)data);
+}
+
+bool PageLabelDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageLabelDictionary** data) {
+ if (PageLabelDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return PageLabelDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ThreadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfThreadDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapThreadDictionary(*pdfDoc, *value, (SkPdfThreadDictionary**)data);
+}
+
+bool ThreadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfThreadDictionary** data) {
+ if (ThreadDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ThreadDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool BeadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBeadDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapBeadDictionary(*pdfDoc, *value, (SkPdfBeadDictionary**)data);
+}
+
+bool BeadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBeadDictionary** data) {
+ if (BeadDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return BeadDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool TransitionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTransitionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapTransitionDictionary(*pdfDoc, *value, (SkPdfTransitionDictionary**)data);
+}
+
+bool TransitionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTransitionDictionary** data) {
+ if (TransitionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return TransitionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool AnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapAnnotationDictionary(*pdfDoc, *value, (SkPdfAnnotationDictionary**)data);
+}
+
+bool AnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAnnotationDictionary** data) {
+ if (AnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return AnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool BorderStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBorderStyleDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapBorderStyleDictionary(*pdfDoc, *value, (SkPdfBorderStyleDictionary**)data);
+}
+
+bool BorderStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBorderStyleDictionary** data) {
+ if (BorderStyleDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return BorderStyleDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool AppearanceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAppearanceDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapAppearanceDictionary(*pdfDoc, *value, (SkPdfAppearanceDictionary**)data);
+}
+
+bool AppearanceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAppearanceDictionary** data) {
+ if (AppearanceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return AppearanceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool TextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTextAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapTextAnnotationDictionary(*pdfDoc, *value, (SkPdfTextAnnotationDictionary**)data);
+}
+
+bool TextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTextAnnotationDictionary** data) {
+ if (TextAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return TextAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ALinkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfALinkAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapALinkAnnotationDictionary(*pdfDoc, *value, (SkPdfALinkAnnotationDictionary**)data);
+}
+
+bool ALinkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfALinkAnnotationDictionary** data) {
+ if (ALinkAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ALinkAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FreeTextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFreeTextAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFreeTextAnnotationDictionary(*pdfDoc, *value, (SkPdfFreeTextAnnotationDictionary**)data);
+}
+
+bool FreeTextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFreeTextAnnotationDictionary** data) {
+ if (FreeTextAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FreeTextAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool LineAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLineAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapLineAnnotationDictionary(*pdfDoc, *value, (SkPdfLineAnnotationDictionary**)data);
+}
+
+bool LineAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLineAnnotationDictionary** data) {
+ if (LineAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return LineAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool SquareOrCircleAnnotationFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSquareOrCircleAnnotation** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapSquareOrCircleAnnotation(*pdfDoc, *value, (SkPdfSquareOrCircleAnnotation**)data);
+}
+
+bool SquareOrCircleAnnotationFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSquareOrCircleAnnotation** data) {
+ if (SquareOrCircleAnnotationFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return SquareOrCircleAnnotationFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool MarkupAnnotationsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkupAnnotationsDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapMarkupAnnotationsDictionary(*pdfDoc, *value, (SkPdfMarkupAnnotationsDictionary**)data);
+}
+
+bool MarkupAnnotationsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkupAnnotationsDictionary** data) {
+ if (MarkupAnnotationsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return MarkupAnnotationsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool RubberStampAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRubberStampAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapRubberStampAnnotationDictionary(*pdfDoc, *value, (SkPdfRubberStampAnnotationDictionary**)data);
+}
+
+bool RubberStampAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRubberStampAnnotationDictionary** data) {
+ if (RubberStampAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return RubberStampAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool InkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInkAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapInkAnnotationDictionary(*pdfDoc, *value, (SkPdfInkAnnotationDictionary**)data);
+}
+
+bool InkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInkAnnotationDictionary** data) {
+ if (InkAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return InkAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool PopUpAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPopUpAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapPopUpAnnotationDictionary(*pdfDoc, *value, (SkPdfPopUpAnnotationDictionary**)data);
+}
+
+bool PopUpAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPopUpAnnotationDictionary** data) {
+ if (PopUpAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return PopUpAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FileAttachmentAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFileAttachmentAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFileAttachmentAnnotationDictionary(*pdfDoc, *value, (SkPdfFileAttachmentAnnotationDictionary**)data);
+}
+
+bool FileAttachmentAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileAttachmentAnnotationDictionary** data) {
+ if (FileAttachmentAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FileAttachmentAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool SoundAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapSoundAnnotationDictionary(*pdfDoc, *value, (SkPdfSoundAnnotationDictionary**)data);
+}
+
+bool SoundAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundAnnotationDictionary** data) {
+ if (SoundAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return SoundAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool MovieAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapMovieAnnotationDictionary(*pdfDoc, *value, (SkPdfMovieAnnotationDictionary**)data);
+}
+
+bool MovieAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieAnnotationDictionary** data) {
+ if (MovieAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return MovieAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool WidgetAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWidgetAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapWidgetAnnotationDictionary(*pdfDoc, *value, (SkPdfWidgetAnnotationDictionary**)data);
+}
+
+bool WidgetAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWidgetAnnotationDictionary** data) {
+ if (WidgetAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return WidgetAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapActionDictionary(*pdfDoc, *value, (SkPdfActionDictionary**)data);
+}
+
+bool ActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfActionDictionary** data) {
+ if (ActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool AnnotationActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAnnotationActionsDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapAnnotationActionsDictionary(*pdfDoc, *value, (SkPdfAnnotationActionsDictionary**)data);
+}
+
+bool AnnotationActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAnnotationActionsDictionary** data) {
+ if (AnnotationActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return AnnotationActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool PageObjectActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageObjectActionsDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapPageObjectActionsDictionary(*pdfDoc, *value, (SkPdfPageObjectActionsDictionary**)data);
+}
+
+bool PageObjectActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageObjectActionsDictionary** data) {
+ if (PageObjectActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return PageObjectActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FormFieldActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFormFieldActionsDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFormFieldActionsDictionary(*pdfDoc, *value, (SkPdfFormFieldActionsDictionary**)data);
+}
+
+bool FormFieldActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFormFieldActionsDictionary** data) {
+ if (FormFieldActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FormFieldActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool DocumentCatalogActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDocumentCatalogActionsDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapDocumentCatalogActionsDictionary(*pdfDoc, *value, (SkPdfDocumentCatalogActionsDictionary**)data);
+}
+
+bool DocumentCatalogActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDocumentCatalogActionsDictionary** data) {
+ if (DocumentCatalogActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return DocumentCatalogActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool GoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGoToActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapGoToActionDictionary(*pdfDoc, *value, (SkPdfGoToActionDictionary**)data);
+}
+
+bool GoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGoToActionDictionary** data) {
+ if (GoToActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return GoToActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool RemoteGoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRemoteGoToActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapRemoteGoToActionDictionary(*pdfDoc, *value, (SkPdfRemoteGoToActionDictionary**)data);
+}
+
+bool RemoteGoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRemoteGoToActionDictionary** data) {
+ if (RemoteGoToActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return RemoteGoToActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool LaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLaunchActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapLaunchActionDictionary(*pdfDoc, *value, (SkPdfLaunchActionDictionary**)data);
+}
+
+bool LaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLaunchActionDictionary** data) {
+ if (LaunchActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return LaunchActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool WindowsLaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWindowsLaunchActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapWindowsLaunchActionDictionary(*pdfDoc, *value, (SkPdfWindowsLaunchActionDictionary**)data);
+}
+
+bool WindowsLaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWindowsLaunchActionDictionary** data) {
+ if (WindowsLaunchActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return WindowsLaunchActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ThreadActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfThreadActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapThreadActionDictionary(*pdfDoc, *value, (SkPdfThreadActionDictionary**)data);
+}
+
+bool ThreadActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfThreadActionDictionary** data) {
+ if (ThreadActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ThreadActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool URIActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfURIActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapURIActionDictionary(*pdfDoc, *value, (SkPdfURIActionDictionary**)data);
+}
+
+bool URIActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfURIActionDictionary** data) {
+ if (URIActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return URIActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool URIDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfURIDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapURIDictionary(*pdfDoc, *value, (SkPdfURIDictionary**)data);
+}
+
+bool URIDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfURIDictionary** data) {
+ if (URIDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return URIDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool SoundActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapSoundActionDictionary(*pdfDoc, *value, (SkPdfSoundActionDictionary**)data);
+}
+
+bool SoundActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundActionDictionary** data) {
+ if (SoundActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return SoundActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool MovieActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapMovieActionDictionary(*pdfDoc, *value, (SkPdfMovieActionDictionary**)data);
+}
+
+bool MovieActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieActionDictionary** data) {
+ if (MovieActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return MovieActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool HideActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfHideActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapHideActionDictionary(*pdfDoc, *value, (SkPdfHideActionDictionary**)data);
+}
+
+bool HideActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfHideActionDictionary** data) {
+ if (HideActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return HideActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool NamedActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNamedActionsDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapNamedActionsDictionary(*pdfDoc, *value, (SkPdfNamedActionsDictionary**)data);
+}
+
+bool NamedActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNamedActionsDictionary** data) {
+ if (NamedActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return NamedActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool InteractiveFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInteractiveFormDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapInteractiveFormDictionary(*pdfDoc, *value, (SkPdfInteractiveFormDictionary**)data);
+}
+
+bool InteractiveFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInteractiveFormDictionary** data) {
+ if (InteractiveFormDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return InteractiveFormDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFieldDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFieldDictionary(*pdfDoc, *value, (SkPdfFieldDictionary**)data);
+}
+
+bool FieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFieldDictionary** data) {
+ if (FieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool VariableTextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfVariableTextFieldDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapVariableTextFieldDictionary(*pdfDoc, *value, (SkPdfVariableTextFieldDictionary**)data);
+}
+
+bool VariableTextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfVariableTextFieldDictionary** data) {
+ if (VariableTextFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return VariableTextFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool AppearanceCharacteristicsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAppearanceCharacteristicsDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapAppearanceCharacteristicsDictionary(*pdfDoc, *value, (SkPdfAppearanceCharacteristicsDictionary**)data);
+}
+
+bool AppearanceCharacteristicsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAppearanceCharacteristicsDictionary** data) {
+ if (AppearanceCharacteristicsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return AppearanceCharacteristicsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool CheckboxFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCheckboxFieldDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapCheckboxFieldDictionary(*pdfDoc, *value, (SkPdfCheckboxFieldDictionary**)data);
+}
+
+bool CheckboxFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCheckboxFieldDictionary** data) {
+ if (CheckboxFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return CheckboxFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool RadioButtonFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRadioButtonFieldDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapRadioButtonFieldDictionary(*pdfDoc, *value, (SkPdfRadioButtonFieldDictionary**)data);
+}
+
+bool RadioButtonFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRadioButtonFieldDictionary** data) {
+ if (RadioButtonFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return RadioButtonFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool TextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTextFieldDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapTextFieldDictionary(*pdfDoc, *value, (SkPdfTextFieldDictionary**)data);
+}
+
+bool TextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTextFieldDictionary** data) {
+ if (TextFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return TextFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ChoiceFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfChoiceFieldDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapChoiceFieldDictionary(*pdfDoc, *value, (SkPdfChoiceFieldDictionary**)data);
+}
+
+bool ChoiceFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfChoiceFieldDictionary** data) {
+ if (ChoiceFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ChoiceFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool SignatureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSignatureDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapSignatureDictionary(*pdfDoc, *value, (SkPdfSignatureDictionary**)data);
+}
+
+bool SignatureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSignatureDictionary** data) {
+ if (SignatureDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return SignatureDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool SubmitFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSubmitFormActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapSubmitFormActionDictionary(*pdfDoc, *value, (SkPdfSubmitFormActionDictionary**)data);
+}
+
+bool SubmitFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSubmitFormActionDictionary** data) {
+ if (SubmitFormActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return SubmitFormActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ResetFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfResetFormActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapResetFormActionDictionary(*pdfDoc, *value, (SkPdfResetFormActionDictionary**)data);
+}
+
+bool ResetFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfResetFormActionDictionary** data) {
+ if (ResetFormActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ResetFormActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ImportDataActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfImportDataActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapImportDataActionDictionary(*pdfDoc, *value, (SkPdfImportDataActionDictionary**)data);
+}
+
+bool ImportDataActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfImportDataActionDictionary** data) {
+ if (ImportDataActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ImportDataActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool JavascriptActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfJavascriptActionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapJavascriptActionDictionary(*pdfDoc, *value, (SkPdfJavascriptActionDictionary**)data);
+}
+
+bool JavascriptActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfJavascriptActionDictionary** data) {
+ if (JavascriptActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return JavascriptActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FDFTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFTrailerDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFDFTrailerDictionary(*pdfDoc, *value, (SkPdfFDFTrailerDictionary**)data);
+}
+
+bool FDFTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFTrailerDictionary** data) {
+ if (FDFTrailerDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FDFTrailerDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FDFCatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFCatalogDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFDFCatalogDictionary(*pdfDoc, *value, (SkPdfFDFCatalogDictionary**)data);
+}
+
+bool FDFCatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFCatalogDictionary** data) {
+ if (FDFCatalogDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FDFCatalogDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FDFDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFDFDictionary(*pdfDoc, *value, (SkPdfFDFDictionary**)data);
+}
+
+bool FDFDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFDictionary** data) {
+ if (FDFDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FDFDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool EncryptedEmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEncryptedEmbeddedFileStreamDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapEncryptedEmbeddedFileStreamDictionary(*pdfDoc, *value, (SkPdfEncryptedEmbeddedFileStreamDictionary**)data);
+}
+
+bool EncryptedEmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncryptedEmbeddedFileStreamDictionary** data) {
+ if (EncryptedEmbeddedFileStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return EncryptedEmbeddedFileStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool JavascriptDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfJavascriptDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapJavascriptDictionary(*pdfDoc, *value, (SkPdfJavascriptDictionary**)data);
+}
+
+bool JavascriptDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfJavascriptDictionary** data) {
+ if (JavascriptDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return JavascriptDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FDFFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFFieldDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFDFFieldDictionary(*pdfDoc, *value, (SkPdfFDFFieldDictionary**)data);
+}
+
+bool FDFFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFFieldDictionary** data) {
+ if (FDFFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FDFFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool IconFitDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfIconFitDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapIconFitDictionary(*pdfDoc, *value, (SkPdfIconFitDictionary**)data);
+}
+
+bool IconFitDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfIconFitDictionary** data) {
+ if (IconFitDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return IconFitDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FDFPageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFPageDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFDFPageDictionary(*pdfDoc, *value, (SkPdfFDFPageDictionary**)data);
+}
+
+bool FDFPageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFPageDictionary** data) {
+ if (FDFPageDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FDFPageDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FDFTemplateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFTemplateDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFDFTemplateDictionary(*pdfDoc, *value, (SkPdfFDFTemplateDictionary**)data);
+}
+
+bool FDFTemplateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFTemplateDictionary** data) {
+ if (FDFTemplateDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FDFTemplateDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FDFNamedPageReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFNamedPageReferenceDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFDFNamedPageReferenceDictionary(*pdfDoc, *value, (SkPdfFDFNamedPageReferenceDictionary**)data);
+}
+
+bool FDFNamedPageReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFNamedPageReferenceDictionary** data) {
+ if (FDFNamedPageReferenceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FDFNamedPageReferenceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool FDFFileAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFFileAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapFDFFileAnnotationDictionary(*pdfDoc, *value, (SkPdfFDFFileAnnotationDictionary**)data);
+}
+
+bool FDFFileAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFFileAnnotationDictionary** data) {
+ if (FDFFileAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return FDFFileAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool SoundObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundObjectDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapSoundObjectDictionary(*pdfDoc, *value, (SkPdfSoundObjectDictionary**)data);
+}
+
+bool SoundObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundObjectDictionary** data) {
+ if (SoundObjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return SoundObjectDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool MovieDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapMovieDictionary(*pdfDoc, *value, (SkPdfMovieDictionary**)data);
+}
+
+bool MovieDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieDictionary** data) {
+ if (MovieDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return MovieDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool MovieActivationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieActivationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapMovieActivationDictionary(*pdfDoc, *value, (SkPdfMovieActivationDictionary**)data);
+}
+
+bool MovieActivationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieActivationDictionary** data) {
+ if (MovieActivationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return MovieActivationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool DocumentInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDocumentInformationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapDocumentInformationDictionary(*pdfDoc, *value, (SkPdfDocumentInformationDictionary**)data);
+}
+
+bool DocumentInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDocumentInformationDictionary** data) {
+ if (DocumentInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return DocumentInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool MetadataStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMetadataStreamDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapMetadataStreamDictionary(*pdfDoc, *value, (SkPdfMetadataStreamDictionary**)data);
+}
+
+bool MetadataStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMetadataStreamDictionary** data) {
+ if (MetadataStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return MetadataStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ComponentsWithMetadataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfComponentsWithMetadataDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapComponentsWithMetadataDictionary(*pdfDoc, *value, (SkPdfComponentsWithMetadataDictionary**)data);
+}
+
+bool ComponentsWithMetadataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfComponentsWithMetadataDictionary** data) {
+ if (ComponentsWithMetadataDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ComponentsWithMetadataDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool PagePieceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPagePieceDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapPagePieceDictionary(*pdfDoc, *value, (SkPdfPagePieceDictionary**)data);
+}
+
+bool PagePieceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPagePieceDictionary** data) {
+ if (PagePieceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return PagePieceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ApplicationDataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfApplicationDataDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapApplicationDataDictionary(*pdfDoc, *value, (SkPdfApplicationDataDictionary**)data);
+}
+
+bool ApplicationDataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfApplicationDataDictionary** data) {
+ if (ApplicationDataDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ApplicationDataDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool StructureTreeRootDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStructureTreeRootDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapStructureTreeRootDictionary(*pdfDoc, *value, (SkPdfStructureTreeRootDictionary**)data);
+}
+
+bool StructureTreeRootDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureTreeRootDictionary** data) {
+ if (StructureTreeRootDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return StructureTreeRootDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool StructureElementDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStructureElementDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapStructureElementDictionary(*pdfDoc, *value, (SkPdfStructureElementDictionary**)data);
+}
+
+bool StructureElementDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureElementDictionary** data) {
+ if (StructureElementDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return StructureElementDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool MarkedContentReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkedContentReferenceDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapMarkedContentReferenceDictionary(*pdfDoc, *value, (SkPdfMarkedContentReferenceDictionary**)data);
+}
+
+bool MarkedContentReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkedContentReferenceDictionary** data) {
+ if (MarkedContentReferenceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return MarkedContentReferenceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ObjectReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfObjectReferenceDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapObjectReferenceDictionary(*pdfDoc, *value, (SkPdfObjectReferenceDictionary**)data);
+}
+
+bool ObjectReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfObjectReferenceDictionary** data) {
+ if (ObjectReferenceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ObjectReferenceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool StructureElementAccessDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStructureElementAccessDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapStructureElementAccessDictionary(*pdfDoc, *value, (SkPdfStructureElementAccessDictionary**)data);
+}
+
+bool StructureElementAccessDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureElementAccessDictionary** data) {
+ if (StructureElementAccessDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return StructureElementAccessDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool AttributeObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAttributeObjectDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapAttributeObjectDictionary(*pdfDoc, *value, (SkPdfAttributeObjectDictionary**)data);
+}
+
+bool AttributeObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAttributeObjectDictionary** data) {
+ if (AttributeObjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return AttributeObjectDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool MarkInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkInformationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapMarkInformationDictionary(*pdfDoc, *value, (SkPdfMarkInformationDictionary**)data);
+}
+
+bool MarkInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkInformationDictionary** data) {
+ if (MarkInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return MarkInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ArtifactsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfArtifactsDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapArtifactsDictionary(*pdfDoc, *value, (SkPdfArtifactsDictionary**)data);
+}
+
+bool ArtifactsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfArtifactsDictionary** data) {
+ if (ArtifactsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ArtifactsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool StandardStructureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStandardStructureDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapStandardStructureDictionary(*pdfDoc, *value, (SkPdfStandardStructureDictionary**)data);
+}
+
+bool StandardStructureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStandardStructureDictionary** data) {
+ if (StandardStructureDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return StandardStructureDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool BlockLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBlockLevelStructureElementsDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapBlockLevelStructureElementsDictionary(*pdfDoc, *value, (SkPdfBlockLevelStructureElementsDictionary**)data);
+}
+
+bool BlockLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBlockLevelStructureElementsDictionary** data) {
+ if (BlockLevelStructureElementsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return BlockLevelStructureElementsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool InlineLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInlineLevelStructureElementsDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapInlineLevelStructureElementsDictionary(*pdfDoc, *value, (SkPdfInlineLevelStructureElementsDictionary**)data);
+}
+
+bool InlineLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInlineLevelStructureElementsDictionary** data) {
+ if (InlineLevelStructureElementsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return InlineLevelStructureElementsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool ListAttributeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfListAttributeDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapListAttributeDictionary(*pdfDoc, *value, (SkPdfListAttributeDictionary**)data);
+}
+
+bool ListAttributeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfListAttributeDictionary** data) {
+ if (ListAttributeDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return ListAttributeDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool TableAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTableAttributesDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapTableAttributesDictionary(*pdfDoc, *value, (SkPdfTableAttributesDictionary**)data);
+}
+
+bool TableAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTableAttributesDictionary** data) {
+ if (TableAttributesDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return TableAttributesDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool WebCaptureInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureInformationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapWebCaptureInformationDictionary(*pdfDoc, *value, (SkPdfWebCaptureInformationDictionary**)data);
+}
+
+bool WebCaptureInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureInformationDictionary** data) {
+ if (WebCaptureInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return WebCaptureInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool WebCaptureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapWebCaptureDictionary(*pdfDoc, *value, (SkPdfWebCaptureDictionary**)data);
+}
+
+bool WebCaptureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureDictionary** data) {
+ if (WebCaptureDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return WebCaptureDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool WebCapturePageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCapturePageSetDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapWebCapturePageSetDictionary(*pdfDoc, *value, (SkPdfWebCapturePageSetDictionary**)data);
+}
+
+bool WebCapturePageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCapturePageSetDictionary** data) {
+ if (WebCapturePageSetDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return WebCapturePageSetDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool WebCaptureImageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureImageSetDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapWebCaptureImageSetDictionary(*pdfDoc, *value, (SkPdfWebCaptureImageSetDictionary**)data);
+}
+
+bool WebCaptureImageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureImageSetDictionary** data) {
+ if (WebCaptureImageSetDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return WebCaptureImageSetDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool SourceInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSourceInformationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapSourceInformationDictionary(*pdfDoc, *value, (SkPdfSourceInformationDictionary**)data);
+}
+
+bool SourceInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSourceInformationDictionary** data) {
+ if (SourceInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return SourceInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool URLAliasDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfURLAliasDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapURLAliasDictionary(*pdfDoc, *value, (SkPdfURLAliasDictionary**)data);
+}
+
+bool URLAliasDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfURLAliasDictionary** data) {
+ if (URLAliasDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return URLAliasDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool WebCaptureCommandDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureCommandDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapWebCaptureCommandDictionary(*pdfDoc, *value, (SkPdfWebCaptureCommandDictionary**)data);
+}
+
+bool WebCaptureCommandDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureCommandDictionary** data) {
+ if (WebCaptureCommandDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return WebCaptureCommandDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool WebCaptureCommandSettingsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureCommandSettingsDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapWebCaptureCommandSettingsDictionary(*pdfDoc, *value, (SkPdfWebCaptureCommandSettingsDictionary**)data);
+}
+
+bool WebCaptureCommandSettingsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureCommandSettingsDictionary** data) {
+ if (WebCaptureCommandSettingsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return WebCaptureCommandSettingsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool BoxColorInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBoxColorInformationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapBoxColorInformationDictionary(*pdfDoc, *value, (SkPdfBoxColorInformationDictionary**)data);
+}
+
+bool BoxColorInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBoxColorInformationDictionary** data) {
+ if (BoxColorInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return BoxColorInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool BoxStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBoxStyleDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapBoxStyleDictionary(*pdfDoc, *value, (SkPdfBoxStyleDictionary**)data);
+}
+
+bool BoxStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBoxStyleDictionary** data) {
+ if (BoxStyleDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return BoxStyleDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool PrinterMarkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPrinterMarkAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapPrinterMarkAnnotationDictionary(*pdfDoc, *value, (SkPdfPrinterMarkAnnotationDictionary**)data);
+}
+
+bool PrinterMarkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPrinterMarkAnnotationDictionary** data) {
+ if (PrinterMarkAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return PrinterMarkAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool PrinterMarkFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPrinterMarkFormDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapPrinterMarkFormDictionary(*pdfDoc, *value, (SkPdfPrinterMarkFormDictionary**)data);
+}
+
+bool PrinterMarkFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPrinterMarkFormDictionary** data) {
+ if (PrinterMarkFormDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return PrinterMarkFormDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool SeparationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSeparationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapSeparationDictionary(*pdfDoc, *value, (SkPdfSeparationDictionary**)data);
+}
+
+bool SeparationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSeparationDictionary** data) {
+ if (SeparationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return SeparationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool PDF_XOutputIntentDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPDF_XOutputIntentDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapPDF_XOutputIntentDictionary(*pdfDoc, *value, (SkPdfPDF_XOutputIntentDictionary**)data);
+}
+
+bool PDF_XOutputIntentDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPDF_XOutputIntentDictionary** data) {
+ if (PDF_XOutputIntentDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return PDF_XOutputIntentDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool TrapNetworkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrapNetworkAnnotationDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapTrapNetworkAnnotationDictionary(*pdfDoc, *value, (SkPdfTrapNetworkAnnotationDictionary**)data);
+}
+
+bool TrapNetworkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrapNetworkAnnotationDictionary** data) {
+ if (TrapNetworkAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return TrapNetworkAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool TrapNetworkAppearanceStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrapNetworkAppearanceStreamDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapTrapNetworkAppearanceStreamDictionary(*pdfDoc, *value, (SkPdfTrapNetworkAppearanceStreamDictionary**)data);
+}
+
+bool TrapNetworkAppearanceStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrapNetworkAppearanceStreamDictionary** data) {
+ if (TrapNetworkAppearanceStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return TrapNetworkAppearanceStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ return true;
+}
+
+bool OpiVersionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfOpiVersionDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapOpiVersionDictionary(*pdfDoc, *value, (SkPdfOpiVersionDictionary**)data);
+}
+
+bool OpiVersionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfOpiVersionDictionary** data) {
+ if (OpiVersionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return OpiVersionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+ std::string Subtype;
+ if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+ if ((Subtype != "MMType1")) return false;
+
+ return true;
+}
+
+bool MultiMasterFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMultiMasterFontDictionary** data) {
+ const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+ if (value == NULL) { return false; }
+ if (data == NULL) { return true; }
+ return mapMultiMasterFontDictionary(*pdfDoc, *value, (SkPdfMultiMasterFontDictionary**)data);
+}
+
+bool MultiMasterFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMultiMasterFontDictionary** data) {
+ if (MultiMasterFontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+ if (abr == NULL || *abr == '\0') return false;
+ return MultiMasterFontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.h b/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.h
index f4c52b4..c611eb8 100644
--- a/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.h
@@ -2,3082 +2,900 @@
#define __DEFINED__SkPdfPodofoMapper
#include "SkPdfHeaders_autogen.h"
-class PodofoMapper {
-public:
- static bool map(const SkPdfObject& in, SkPdfObject** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out) {
- if (!isObject(podofoDoc, podofoObj)) return false;
-
- if (map(podofoDoc, podofoObj, (SkPdfArray**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfBoolean**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfInteger**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfName**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfNull**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfReference**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfString**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;
-
- *out = new SkPdfObject(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfNull** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNull** out) {
- if (!isNull(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfNull(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfBoolean** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoolean** out) {
- if (!isBoolean(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfBoolean(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfInteger** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteger** out) {
- if (!isInteger(podofoDoc, podofoObj)) return false;
-
- if (map(podofoDoc, podofoObj, (SkPdfNumber**)out)) return true;
-
- *out = new SkPdfInteger(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfNumber** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumber** out) {
- if (!isNumber(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfNumber(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfName** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfName** out) {
- if (!isName(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfName(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfReference** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReference** out) {
- if (!isReference(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfReference(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfArray** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArray** out) {
- if (!isArray(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfArray(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfString** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfString** out) {
- if (!isString(podofoDoc, podofoObj)) return false;
-
- if (map(podofoDoc, podofoObj, (SkPdfHexString**)out)) return true;
-
- *out = new SkPdfString(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfHexString** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHexString** out) {
- if (!isHexString(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfHexString(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDictionary** out) {
- if (!isDictionary(podofoDoc, podofoObj)) return false;
-
- if (map(podofoDoc, podofoObj, (SkPdfALinkAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfAlternateImageDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfAnnotationActionsDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfAppearanceCharacteristicsDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfAppearanceDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfApplicationDataDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfArtifactsDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfAttributeObjectDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfBeadDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfBlockLevelStructureElementsDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfBorderStyleDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfBoxColorInformationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfBoxStyleDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfCIDFontDescriptorDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfCIDSystemInfoDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfCMapDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfCalgrayColorSpaceDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfCalrgbColorSpaceDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfCatalogDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfCcittfaxdecodeFilterDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfCheckboxFieldDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfChoiceFieldDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfComponentsWithMetadataDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfDctdecodeFilterDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfDeviceNColorSpaceDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfDocumentCatalogActionsDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfDocumentInformationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfEmbeddedFileParameterDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfEmbeddedFileStreamDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfEmbeddedFontStreamDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfEncodingDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfEncryptedEmbeddedFileStreamDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfEncryptionCommonDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFDFCatalogDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFDFDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFDFFieldDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFDFFileAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFDFNamedPageReferenceDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFDFPageDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFDFTemplateDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFDFTrailerDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFieldDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFileAttachmentAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFileSpecificationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFileTrailerDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFontDescriptorDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFontDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFormFieldActionsDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFreeTextAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfFunctionCommonDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfGoToActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfGraphicsStateDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfGroupAttributesDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfHideActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfIccProfileStreamDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfIconFitDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfImportDataActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfInkAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfInlineLevelStructureElementsDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfInteractiveFormDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfJavascriptActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfJavascriptDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfJbig2DecodeFilterDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfLabColorSpaceDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfLaunchActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfLineAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfListAttributeDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfLzwdecodeAndFlatedecodeFiltersDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfMacOsFileInformationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfMarkInformationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfMarkedContentReferenceDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfMarkupAnnotationsDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfMetadataStreamDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfMovieActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfMovieActivationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfMovieAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfMovieDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfNameDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfNameTreeNodeDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfNamedActionsDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfNumberTreeNodeDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfObjectReferenceDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfOpiVersionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfOutlineDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfOutlineItemDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfPDF_XOutputIntentDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfPSXobjectDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfPageLabelDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfPageObjectActionsDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfPageObjectDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfPagePieceDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfPageTreeNodeDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfPopUpAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfPrinterMarkAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfPrinterMarkFormDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfRadioButtonFieldDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfReferenceDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfRemoteGoToActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfResetFormActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfResourceDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfRubberStampAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfSeparationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfShadingDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfSignatureDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfSoftMaskDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfSoftMaskImageDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfSoundActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfSoundAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfSoundObjectDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfSourceInformationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfSquareOrCircleAnnotation**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfStandardSecurityHandlerDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfStandardStructureDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfStreamCommonDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfStructureElementAccessDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfStructureElementDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfStructureTreeRootDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfSubmitFormActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfTableAttributesDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfTextAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfTextFieldDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfThreadActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfThreadDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfTransitionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfTransparencyGroupDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfTrapNetworkAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfTrapNetworkAppearanceStreamDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType0FunctionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType10HalftoneDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType16HalftoneDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType1HalftoneDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType1PatternDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType2FunctionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType2PatternDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType3FunctionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType5HalftoneDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType6HalftoneDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfURIActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfURIDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfURLAliasDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfVariableTextFieldDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfViewerPreferencesDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfWebCaptureCommandDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfWebCaptureCommandSettingsDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfWebCaptureDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfWebCaptureImageSetDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfWebCaptureInformationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfWebCapturePageSetDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfWidgetAnnotationDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfWindowsLaunchActionDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfXObjectDictionary**)out)) return true;
-
- *out = new SkPdfDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfStream** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStream** out) {
- if (!isStream(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfStream(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfXObjectDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfXObjectDictionary** out) {
- if (!isXObjectDictionary(podofoDoc, podofoObj)) return false;
-
- if (map(podofoDoc, podofoObj, (SkPdfImageDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType1FormDictionary**)out)) return true;
-
- *out = new SkPdfXObjectDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFontDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDictionary** out) {
- if (!isFontDictionary(podofoDoc, podofoObj)) return false;
-
- if (map(podofoDoc, podofoObj, (SkPdfCIDFontDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType0FontDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType1FontDictionary**)out)) return true;
-
- *out = new SkPdfFontDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfTrueTypeFontDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrueTypeFontDictionary** out) {
- if (!isTrueTypeFontDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfTrueTypeFontDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfStreamCommonDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStreamCommonDictionary** out) {
- if (!isStreamCommonDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfStreamCommonDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out) {
- if (!isLzwdecodeAndFlatedecodeFiltersDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfLzwdecodeAndFlatedecodeFiltersDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfCcittfaxdecodeFilterDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCcittfaxdecodeFilterDictionary** out) {
- if (!isCcittfaxdecodeFilterDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfCcittfaxdecodeFilterDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfJbig2DecodeFilterDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJbig2DecodeFilterDictionary** out) {
- if (!isJbig2DecodeFilterDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfJbig2DecodeFilterDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfDctdecodeFilterDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDctdecodeFilterDictionary** out) {
- if (!isDctdecodeFilterDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfDctdecodeFilterDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFileTrailerDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileTrailerDictionary** out) {
- if (!isFileTrailerDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFileTrailerDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfEncryptionCommonDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptionCommonDictionary** out) {
- if (!isEncryptionCommonDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfEncryptionCommonDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfStandardSecurityHandlerDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardSecurityHandlerDictionary** out) {
- if (!isStandardSecurityHandlerDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfStandardSecurityHandlerDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfCatalogDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCatalogDictionary** out) {
- if (!isCatalogDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfCatalogDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfPageTreeNodeDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageTreeNodeDictionary** out) {
- if (!isPageTreeNodeDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfPageTreeNodeDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfPageObjectDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectDictionary** out) {
- if (!isPageObjectDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfPageObjectDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfNameDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameDictionary** out) {
- if (!isNameDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfNameDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfResourceDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResourceDictionary** out) {
- if (!isResourceDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfResourceDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfNameTreeNodeDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameTreeNodeDictionary** out) {
- if (!isNameTreeNodeDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfNameTreeNodeDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfNumberTreeNodeDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumberTreeNodeDictionary** out) {
- if (!isNumberTreeNodeDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfNumberTreeNodeDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFunctionCommonDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFunctionCommonDictionary** out) {
- if (!isFunctionCommonDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFunctionCommonDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType0FunctionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FunctionDictionary** out) {
- if (!isType0FunctionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType0FunctionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType2FunctionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2FunctionDictionary** out) {
- if (!isType2FunctionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType2FunctionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType3FunctionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FunctionDictionary** out) {
- if (!isType3FunctionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType3FunctionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFileSpecificationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileSpecificationDictionary** out) {
- if (!isFileSpecificationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFileSpecificationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfEmbeddedFileStreamDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileStreamDictionary** out) {
- if (!isEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfEmbeddedFileParameterDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileParameterDictionary** out) {
- if (!isEmbeddedFileParameterDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfEmbeddedFileParameterDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfMacOsFileInformationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMacOsFileInformationDictionary** out) {
- if (!isMacOsFileInformationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfMacOsFileInformationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfGraphicsStateDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGraphicsStateDictionary** out) {
- if (!isGraphicsStateDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfGraphicsStateDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfCalgrayColorSpaceDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalgrayColorSpaceDictionary** out) {
- if (!isCalgrayColorSpaceDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfCalgrayColorSpaceDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfCalrgbColorSpaceDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalrgbColorSpaceDictionary** out) {
- if (!isCalrgbColorSpaceDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfCalrgbColorSpaceDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfLabColorSpaceDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLabColorSpaceDictionary** out) {
- if (!isLabColorSpaceDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfLabColorSpaceDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfIccProfileStreamDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIccProfileStreamDictionary** out) {
- if (!isIccProfileStreamDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfIccProfileStreamDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfDeviceNColorSpaceDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDeviceNColorSpaceDictionary** out) {
- if (!isDeviceNColorSpaceDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfDeviceNColorSpaceDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType1PatternDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1PatternDictionary** out) {
- if (!isType1PatternDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType1PatternDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType2PatternDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2PatternDictionary** out) {
- if (!isType2PatternDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType2PatternDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfShadingDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfShadingDictionary** out) {
- if (!isShadingDictionary(podofoDoc, podofoObj)) return false;
-
- if (map(podofoDoc, podofoObj, (SkPdfType1ShadingDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType2ShadingDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType3ShadingDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType4ShadingDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType5ShadingDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType6ShadingDictionary**)out)) return true;
-
- *out = new SkPdfShadingDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType1ShadingDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1ShadingDictionary** out) {
- if (!isType1ShadingDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType1ShadingDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType2ShadingDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2ShadingDictionary** out) {
- if (!isType2ShadingDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType2ShadingDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType3ShadingDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3ShadingDictionary** out) {
- if (!isType3ShadingDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType3ShadingDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType4ShadingDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType4ShadingDictionary** out) {
- if (!isType4ShadingDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType4ShadingDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType5ShadingDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5ShadingDictionary** out) {
- if (!isType5ShadingDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType5ShadingDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType6ShadingDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6ShadingDictionary** out) {
- if (!isType6ShadingDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType6ShadingDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfImageDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImageDictionary** out) {
- if (!isImageDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfImageDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfAlternateImageDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAlternateImageDictionary** out) {
- if (!isAlternateImageDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfAlternateImageDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType1FormDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FormDictionary** out) {
- if (!isType1FormDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType1FormDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfGroupAttributesDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGroupAttributesDictionary** out) {
- if (!isGroupAttributesDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfGroupAttributesDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfReferenceDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReferenceDictionary** out) {
- if (!isReferenceDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfReferenceDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfPSXobjectDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPSXobjectDictionary** out) {
- if (!isPSXobjectDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfPSXobjectDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType1FontDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FontDictionary** out) {
- if (!isType1FontDictionary(podofoDoc, podofoObj)) return false;
-
- if (map(podofoDoc, podofoObj, (SkPdfMultiMasterFontDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfTrueTypeFontDictionary**)out)) return true;
- if (map(podofoDoc, podofoObj, (SkPdfType3FontDictionary**)out)) return true;
-
- *out = new SkPdfType1FontDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType3FontDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FontDictionary** out) {
- if (!isType3FontDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType3FontDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfEncodingDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncodingDictionary** out) {
- if (!isEncodingDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfEncodingDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfCIDSystemInfoDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDSystemInfoDictionary** out) {
- if (!isCIDSystemInfoDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfCIDSystemInfoDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfCIDFontDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDictionary** out) {
- if (!isCIDFontDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfCIDFontDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfCMapDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCMapDictionary** out) {
- if (!isCMapDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfCMapDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType0FontDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FontDictionary** out) {
- if (!isType0FontDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType0FontDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFontDescriptorDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDescriptorDictionary** out) {
- if (!isFontDescriptorDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFontDescriptorDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfCIDFontDescriptorDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDescriptorDictionary** out) {
- if (!isCIDFontDescriptorDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfCIDFontDescriptorDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfEmbeddedFontStreamDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFontStreamDictionary** out) {
- if (!isEmbeddedFontStreamDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfEmbeddedFontStreamDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType1HalftoneDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1HalftoneDictionary** out) {
- if (!isType1HalftoneDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType1HalftoneDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType6HalftoneDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6HalftoneDictionary** out) {
- if (!isType6HalftoneDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType6HalftoneDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType10HalftoneDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType10HalftoneDictionary** out) {
- if (!isType10HalftoneDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType10HalftoneDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType16HalftoneDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType16HalftoneDictionary** out) {
- if (!isType16HalftoneDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType16HalftoneDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfType5HalftoneDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5HalftoneDictionary** out) {
- if (!isType5HalftoneDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfType5HalftoneDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfSoftMaskDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskDictionary** out) {
- if (!isSoftMaskDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfSoftMaskDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfSoftMaskImageDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskImageDictionary** out) {
- if (!isSoftMaskImageDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfSoftMaskImageDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfTransparencyGroupDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransparencyGroupDictionary** out) {
- if (!isTransparencyGroupDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfTransparencyGroupDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfViewerPreferencesDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfViewerPreferencesDictionary** out) {
- if (!isViewerPreferencesDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfViewerPreferencesDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfOutlineDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineDictionary** out) {
- if (!isOutlineDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfOutlineDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfOutlineItemDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineItemDictionary** out) {
- if (!isOutlineItemDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfOutlineItemDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfPageLabelDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageLabelDictionary** out) {
- if (!isPageLabelDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfPageLabelDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfThreadDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadDictionary** out) {
- if (!isThreadDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfThreadDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfBeadDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBeadDictionary** out) {
- if (!isBeadDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfBeadDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfTransitionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransitionDictionary** out) {
- if (!isTransitionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfTransitionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationDictionary** out) {
- if (!isAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfBorderStyleDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBorderStyleDictionary** out) {
- if (!isBorderStyleDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfBorderStyleDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfAppearanceDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceDictionary** out) {
- if (!isAppearanceDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfAppearanceDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfTextAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextAnnotationDictionary** out) {
- if (!isTextAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfTextAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfALinkAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfALinkAnnotationDictionary** out) {
- if (!isALinkAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfALinkAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFreeTextAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFreeTextAnnotationDictionary** out) {
- if (!isFreeTextAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFreeTextAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfLineAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLineAnnotationDictionary** out) {
- if (!isLineAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfLineAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfSquareOrCircleAnnotation** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSquareOrCircleAnnotation** out) {
- if (!isSquareOrCircleAnnotation(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfSquareOrCircleAnnotation(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfMarkupAnnotationsDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkupAnnotationsDictionary** out) {
- if (!isMarkupAnnotationsDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfMarkupAnnotationsDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfRubberStampAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRubberStampAnnotationDictionary** out) {
- if (!isRubberStampAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfRubberStampAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfInkAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInkAnnotationDictionary** out) {
- if (!isInkAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfInkAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfPopUpAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPopUpAnnotationDictionary** out) {
- if (!isPopUpAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfPopUpAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFileAttachmentAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileAttachmentAnnotationDictionary** out) {
- if (!isFileAttachmentAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFileAttachmentAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfSoundAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundAnnotationDictionary** out) {
- if (!isSoundAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfSoundAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfMovieAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieAnnotationDictionary** out) {
- if (!isMovieAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfMovieAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfWidgetAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWidgetAnnotationDictionary** out) {
- if (!isWidgetAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfWidgetAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfActionDictionary** out) {
- if (!isActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfAnnotationActionsDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationActionsDictionary** out) {
- if (!isAnnotationActionsDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfAnnotationActionsDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfPageObjectActionsDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectActionsDictionary** out) {
- if (!isPageObjectActionsDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfPageObjectActionsDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFormFieldActionsDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFormFieldActionsDictionary** out) {
- if (!isFormFieldActionsDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFormFieldActionsDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfDocumentCatalogActionsDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentCatalogActionsDictionary** out) {
- if (!isDocumentCatalogActionsDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfDocumentCatalogActionsDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfGoToActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGoToActionDictionary** out) {
- if (!isGoToActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfGoToActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfRemoteGoToActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRemoteGoToActionDictionary** out) {
- if (!isRemoteGoToActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfRemoteGoToActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfLaunchActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLaunchActionDictionary** out) {
- if (!isLaunchActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfLaunchActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfWindowsLaunchActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWindowsLaunchActionDictionary** out) {
- if (!isWindowsLaunchActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfWindowsLaunchActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfThreadActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadActionDictionary** out) {
- if (!isThreadActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfThreadActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfURIActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIActionDictionary** out) {
- if (!isURIActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfURIActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfURIDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIDictionary** out) {
- if (!isURIDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfURIDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfSoundActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundActionDictionary** out) {
- if (!isSoundActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfSoundActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfMovieActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActionDictionary** out) {
- if (!isMovieActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfMovieActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfHideActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHideActionDictionary** out) {
- if (!isHideActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfHideActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfNamedActionsDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNamedActionsDictionary** out) {
- if (!isNamedActionsDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfNamedActionsDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfInteractiveFormDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteractiveFormDictionary** out) {
- if (!isInteractiveFormDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfInteractiveFormDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFieldDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFieldDictionary** out) {
- if (!isFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFieldDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfVariableTextFieldDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfVariableTextFieldDictionary** out) {
- if (!isVariableTextFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfVariableTextFieldDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfAppearanceCharacteristicsDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceCharacteristicsDictionary** out) {
- if (!isAppearanceCharacteristicsDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfAppearanceCharacteristicsDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfCheckboxFieldDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCheckboxFieldDictionary** out) {
- if (!isCheckboxFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfCheckboxFieldDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfRadioButtonFieldDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRadioButtonFieldDictionary** out) {
- if (!isRadioButtonFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfRadioButtonFieldDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfTextFieldDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextFieldDictionary** out) {
- if (!isTextFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfTextFieldDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfChoiceFieldDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfChoiceFieldDictionary** out) {
- if (!isChoiceFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfChoiceFieldDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfSignatureDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSignatureDictionary** out) {
- if (!isSignatureDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfSignatureDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfSubmitFormActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSubmitFormActionDictionary** out) {
- if (!isSubmitFormActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfSubmitFormActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfResetFormActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResetFormActionDictionary** out) {
- if (!isResetFormActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfResetFormActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfImportDataActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImportDataActionDictionary** out) {
- if (!isImportDataActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfImportDataActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfJavascriptActionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptActionDictionary** out) {
- if (!isJavascriptActionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfJavascriptActionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFDFTrailerDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTrailerDictionary** out) {
- if (!isFDFTrailerDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFDFTrailerDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFDFCatalogDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFCatalogDictionary** out) {
- if (!isFDFCatalogDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFDFCatalogDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFDFDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFDictionary** out) {
- if (!isFDFDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFDFDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfEncryptedEmbeddedFileStreamDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptedEmbeddedFileStreamDictionary** out) {
- if (!isEncryptedEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfEncryptedEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfJavascriptDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptDictionary** out) {
- if (!isJavascriptDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfJavascriptDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFDFFieldDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFieldDictionary** out) {
- if (!isFDFFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFDFFieldDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfIconFitDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIconFitDictionary** out) {
- if (!isIconFitDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfIconFitDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFDFPageDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFPageDictionary** out) {
- if (!isFDFPageDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFDFPageDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFDFTemplateDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTemplateDictionary** out) {
- if (!isFDFTemplateDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFDFTemplateDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFDFNamedPageReferenceDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFNamedPageReferenceDictionary** out) {
- if (!isFDFNamedPageReferenceDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFDFNamedPageReferenceDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfFDFFileAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFileAnnotationDictionary** out) {
- if (!isFDFFileAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfFDFFileAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfSoundObjectDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundObjectDictionary** out) {
- if (!isSoundObjectDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfSoundObjectDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfMovieDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieDictionary** out) {
- if (!isMovieDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfMovieDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfMovieActivationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActivationDictionary** out) {
- if (!isMovieActivationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfMovieActivationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfDocumentInformationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentInformationDictionary** out) {
- if (!isDocumentInformationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfDocumentInformationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfMetadataStreamDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMetadataStreamDictionary** out) {
- if (!isMetadataStreamDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfMetadataStreamDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfComponentsWithMetadataDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfComponentsWithMetadataDictionary** out) {
- if (!isComponentsWithMetadataDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfComponentsWithMetadataDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfPagePieceDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPagePieceDictionary** out) {
- if (!isPagePieceDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfPagePieceDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfApplicationDataDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfApplicationDataDictionary** out) {
- if (!isApplicationDataDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfApplicationDataDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfStructureTreeRootDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureTreeRootDictionary** out) {
- if (!isStructureTreeRootDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfStructureTreeRootDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfStructureElementDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementDictionary** out) {
- if (!isStructureElementDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfStructureElementDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfMarkedContentReferenceDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkedContentReferenceDictionary** out) {
- if (!isMarkedContentReferenceDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfMarkedContentReferenceDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfObjectReferenceDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObjectReferenceDictionary** out) {
- if (!isObjectReferenceDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfObjectReferenceDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfStructureElementAccessDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementAccessDictionary** out) {
- if (!isStructureElementAccessDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfStructureElementAccessDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfAttributeObjectDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAttributeObjectDictionary** out) {
- if (!isAttributeObjectDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfAttributeObjectDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfMarkInformationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkInformationDictionary** out) {
- if (!isMarkInformationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfMarkInformationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfArtifactsDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArtifactsDictionary** out) {
- if (!isArtifactsDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfArtifactsDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfStandardStructureDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardStructureDictionary** out) {
- if (!isStandardStructureDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfStandardStructureDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfBlockLevelStructureElementsDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBlockLevelStructureElementsDictionary** out) {
- if (!isBlockLevelStructureElementsDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfBlockLevelStructureElementsDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfInlineLevelStructureElementsDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInlineLevelStructureElementsDictionary** out) {
- if (!isInlineLevelStructureElementsDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfInlineLevelStructureElementsDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfListAttributeDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfListAttributeDictionary** out) {
- if (!isListAttributeDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfListAttributeDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfTableAttributesDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTableAttributesDictionary** out) {
- if (!isTableAttributesDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfTableAttributesDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfWebCaptureInformationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureInformationDictionary** out) {
- if (!isWebCaptureInformationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfWebCaptureInformationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfWebCaptureDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureDictionary** out) {
- if (!isWebCaptureDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfWebCaptureDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfWebCapturePageSetDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCapturePageSetDictionary** out) {
- if (!isWebCapturePageSetDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfWebCapturePageSetDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfWebCaptureImageSetDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureImageSetDictionary** out) {
- if (!isWebCaptureImageSetDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfWebCaptureImageSetDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfSourceInformationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSourceInformationDictionary** out) {
- if (!isSourceInformationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfSourceInformationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfURLAliasDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURLAliasDictionary** out) {
- if (!isURLAliasDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfURLAliasDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfWebCaptureCommandDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandDictionary** out) {
- if (!isWebCaptureCommandDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfWebCaptureCommandDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfWebCaptureCommandSettingsDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandSettingsDictionary** out) {
- if (!isWebCaptureCommandSettingsDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfWebCaptureCommandSettingsDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfBoxColorInformationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxColorInformationDictionary** out) {
- if (!isBoxColorInformationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfBoxColorInformationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfBoxStyleDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxStyleDictionary** out) {
- if (!isBoxStyleDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfBoxStyleDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfPrinterMarkAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkAnnotationDictionary** out) {
- if (!isPrinterMarkAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfPrinterMarkAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfPrinterMarkFormDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkFormDictionary** out) {
- if (!isPrinterMarkFormDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfPrinterMarkFormDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfSeparationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSeparationDictionary** out) {
- if (!isSeparationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfSeparationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfPDF_XOutputIntentDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPDF_XOutputIntentDictionary** out) {
- if (!isPDF_XOutputIntentDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfPDF_XOutputIntentDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfTrapNetworkAnnotationDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAnnotationDictionary** out) {
- if (!isTrapNetworkAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfTrapNetworkAnnotationDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfTrapNetworkAppearanceStreamDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAppearanceStreamDictionary** out) {
- if (!isTrapNetworkAppearanceStreamDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfTrapNetworkAppearanceStreamDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfOpiVersionDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOpiVersionDictionary** out) {
- if (!isOpiVersionDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfOpiVersionDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool map(const SkPdfObject& in, SkPdfMultiMasterFontDictionary** out) {
- return map(*in.doc(), *in.podofo(), out);
- }
-
- static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMultiMasterFontDictionary** out) {
- if (!isMultiMasterFontDictionary(podofoDoc, podofoObj)) return false;
-
-
- *out = new SkPdfMultiMasterFontDictionary(&podofoDoc, &podofoObj);
- return true;
- }
-
- static bool isObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return podofoObj.GetDataType() == ePdfDataType_Null;
- }
-
- static bool isBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return podofoObj.GetDataType() == ePdfDataType_Bool;
- }
-
- static bool isInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return podofoObj.GetDataType() == ePdfDataType_Number || podofoObj.GetDataType() == ePdfDataType_Real;
- }
-
- static bool isNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return podofoObj.GetDataType() == ePdfDataType_Number || podofoObj.GetDataType() == ePdfDataType_Real;
- }
-
- static bool isName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return podofoObj.GetDataType() == ePdfDataType_Name;
- }
-
- static bool isReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return podofoObj.GetDataType() == ePdfDataType_Reference;
- }
-
- static bool isArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return podofoObj.GetDataType() == ePdfDataType_Array;
- }
-
- static bool isString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return podofoObj.GetDataType() == ePdfDataType_String || podofoObj.GetDataType() == ePdfDataType_HexString;
- }
-
- static bool isHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return podofoObj.GetDataType() == ePdfDataType_HexString;
- }
-
- static bool isDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return podofoObj.GetDataType() == ePdfDataType_Dictionary;
- }
-
- static bool isStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- std::string Subtype;
- if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
- if ((Subtype != "TrueType")) return false;
-
- return true;
- }
-
- static bool isStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- std::string Subtype;
- if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
- if ((Subtype != "Image")) return false;
-
- return true;
- }
-
- static bool isAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- std::string Subtype;
- if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
- if ((Subtype != "Form")) return false;
-
- return true;
- }
-
- static bool isGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- std::string Subtype;
- if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
- if ((Subtype != "MMType1") && (Subtype != "TrueType") && (Subtype != "Type3") && (Subtype != "Type1")) return false;
-
- return true;
- }
-
- static bool isType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- std::string Subtype;
- if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
- if ((Subtype != "Type3")) return false;
-
- return true;
- }
-
- static bool isEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- std::string Subtype;
- if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
- if ((Subtype != "CIDFontType0") && (Subtype != "CIDFontType2")) return false;
-
- return true;
- }
-
- static bool isCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- std::string Subtype;
- if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
- if ((Subtype != "Type0")) return false;
-
- return true;
- }
-
- static bool isFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- return true;
- }
-
- static bool isMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
- std::string Subtype;
- if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
- if ((Subtype != "MMType1")) return false;
-
- return true;
- }
-
-};
+bool mapObject(const SkPdfObject& in, SkPdfObject** out);
+bool mapObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out);
+bool mapNull(const SkPdfObject& in, SkPdfNull** out);
+bool mapNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNull** out);
+bool mapBoolean(const SkPdfObject& in, SkPdfBoolean** out);
+bool mapBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoolean** out);
+bool mapInteger(const SkPdfObject& in, SkPdfInteger** out);
+bool mapInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteger** out);
+bool mapNumber(const SkPdfObject& in, SkPdfNumber** out);
+bool mapNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumber** out);
+bool mapName(const SkPdfObject& in, SkPdfName** out);
+bool mapName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfName** out);
+bool mapReference(const SkPdfObject& in, SkPdfReference** out);
+bool mapReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReference** out);
+bool mapArray(const SkPdfObject& in, SkPdfArray** out);
+bool mapArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArray** out);
+bool mapString(const SkPdfObject& in, SkPdfString** out);
+bool mapString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfString** out);
+bool mapHexString(const SkPdfObject& in, SkPdfHexString** out);
+bool mapHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHexString** out);
+bool mapDictionary(const SkPdfObject& in, SkPdfDictionary** out);
+bool mapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDictionary** out);
+bool mapStream(const SkPdfObject& in, SkPdfStream** out);
+bool mapStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStream** out);
+bool mapXObjectDictionary(const SkPdfObject& in, SkPdfXObjectDictionary** out);
+bool mapXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfXObjectDictionary** out);
+bool mapFontDictionary(const SkPdfObject& in, SkPdfFontDictionary** out);
+bool mapFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDictionary** out);
+bool mapTrueTypeFontDictionary(const SkPdfObject& in, SkPdfTrueTypeFontDictionary** out);
+bool mapTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrueTypeFontDictionary** out);
+bool mapStreamCommonDictionary(const SkPdfObject& in, SkPdfStreamCommonDictionary** out);
+bool mapStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStreamCommonDictionary** out);
+bool mapLzwdecodeAndFlatedecodeFiltersDictionary(const SkPdfObject& in, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out);
+bool mapLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out);
+bool mapCcittfaxdecodeFilterDictionary(const SkPdfObject& in, SkPdfCcittfaxdecodeFilterDictionary** out);
+bool mapCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCcittfaxdecodeFilterDictionary** out);
+bool mapJbig2DecodeFilterDictionary(const SkPdfObject& in, SkPdfJbig2DecodeFilterDictionary** out);
+bool mapJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJbig2DecodeFilterDictionary** out);
+bool mapDctdecodeFilterDictionary(const SkPdfObject& in, SkPdfDctdecodeFilterDictionary** out);
+bool mapDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDctdecodeFilterDictionary** out);
+bool mapFileTrailerDictionary(const SkPdfObject& in, SkPdfFileTrailerDictionary** out);
+bool mapFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileTrailerDictionary** out);
+bool mapEncryptionCommonDictionary(const SkPdfObject& in, SkPdfEncryptionCommonDictionary** out);
+bool mapEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptionCommonDictionary** out);
+bool mapStandardSecurityHandlerDictionary(const SkPdfObject& in, SkPdfStandardSecurityHandlerDictionary** out);
+bool mapStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardSecurityHandlerDictionary** out);
+bool mapCatalogDictionary(const SkPdfObject& in, SkPdfCatalogDictionary** out);
+bool mapCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCatalogDictionary** out);
+bool mapPageTreeNodeDictionary(const SkPdfObject& in, SkPdfPageTreeNodeDictionary** out);
+bool mapPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageTreeNodeDictionary** out);
+bool mapPageObjectDictionary(const SkPdfObject& in, SkPdfPageObjectDictionary** out);
+bool mapPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectDictionary** out);
+bool mapNameDictionary(const SkPdfObject& in, SkPdfNameDictionary** out);
+bool mapNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameDictionary** out);
+bool mapResourceDictionary(const SkPdfObject& in, SkPdfResourceDictionary** out);
+bool mapResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResourceDictionary** out);
+bool mapNameTreeNodeDictionary(const SkPdfObject& in, SkPdfNameTreeNodeDictionary** out);
+bool mapNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameTreeNodeDictionary** out);
+bool mapNumberTreeNodeDictionary(const SkPdfObject& in, SkPdfNumberTreeNodeDictionary** out);
+bool mapNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumberTreeNodeDictionary** out);
+bool mapFunctionCommonDictionary(const SkPdfObject& in, SkPdfFunctionCommonDictionary** out);
+bool mapFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFunctionCommonDictionary** out);
+bool mapType0FunctionDictionary(const SkPdfObject& in, SkPdfType0FunctionDictionary** out);
+bool mapType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FunctionDictionary** out);
+bool mapType2FunctionDictionary(const SkPdfObject& in, SkPdfType2FunctionDictionary** out);
+bool mapType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2FunctionDictionary** out);
+bool mapType3FunctionDictionary(const SkPdfObject& in, SkPdfType3FunctionDictionary** out);
+bool mapType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FunctionDictionary** out);
+bool mapFileSpecificationDictionary(const SkPdfObject& in, SkPdfFileSpecificationDictionary** out);
+bool mapFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileSpecificationDictionary** out);
+bool mapEmbeddedFileStreamDictionary(const SkPdfObject& in, SkPdfEmbeddedFileStreamDictionary** out);
+bool mapEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileStreamDictionary** out);
+bool mapEmbeddedFileParameterDictionary(const SkPdfObject& in, SkPdfEmbeddedFileParameterDictionary** out);
+bool mapEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileParameterDictionary** out);
+bool mapMacOsFileInformationDictionary(const SkPdfObject& in, SkPdfMacOsFileInformationDictionary** out);
+bool mapMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMacOsFileInformationDictionary** out);
+bool mapGraphicsStateDictionary(const SkPdfObject& in, SkPdfGraphicsStateDictionary** out);
+bool mapGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGraphicsStateDictionary** out);
+bool mapCalgrayColorSpaceDictionary(const SkPdfObject& in, SkPdfCalgrayColorSpaceDictionary** out);
+bool mapCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalgrayColorSpaceDictionary** out);
+bool mapCalrgbColorSpaceDictionary(const SkPdfObject& in, SkPdfCalrgbColorSpaceDictionary** out);
+bool mapCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalrgbColorSpaceDictionary** out);
+bool mapLabColorSpaceDictionary(const SkPdfObject& in, SkPdfLabColorSpaceDictionary** out);
+bool mapLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLabColorSpaceDictionary** out);
+bool mapIccProfileStreamDictionary(const SkPdfObject& in, SkPdfIccProfileStreamDictionary** out);
+bool mapIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIccProfileStreamDictionary** out);
+bool mapDeviceNColorSpaceDictionary(const SkPdfObject& in, SkPdfDeviceNColorSpaceDictionary** out);
+bool mapDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDeviceNColorSpaceDictionary** out);
+bool mapType1PatternDictionary(const SkPdfObject& in, SkPdfType1PatternDictionary** out);
+bool mapType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1PatternDictionary** out);
+bool mapType2PatternDictionary(const SkPdfObject& in, SkPdfType2PatternDictionary** out);
+bool mapType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2PatternDictionary** out);
+bool mapShadingDictionary(const SkPdfObject& in, SkPdfShadingDictionary** out);
+bool mapShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfShadingDictionary** out);
+bool mapType1ShadingDictionary(const SkPdfObject& in, SkPdfType1ShadingDictionary** out);
+bool mapType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1ShadingDictionary** out);
+bool mapType2ShadingDictionary(const SkPdfObject& in, SkPdfType2ShadingDictionary** out);
+bool mapType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2ShadingDictionary** out);
+bool mapType3ShadingDictionary(const SkPdfObject& in, SkPdfType3ShadingDictionary** out);
+bool mapType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3ShadingDictionary** out);
+bool mapType4ShadingDictionary(const SkPdfObject& in, SkPdfType4ShadingDictionary** out);
+bool mapType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType4ShadingDictionary** out);
+bool mapType5ShadingDictionary(const SkPdfObject& in, SkPdfType5ShadingDictionary** out);
+bool mapType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5ShadingDictionary** out);
+bool mapType6ShadingDictionary(const SkPdfObject& in, SkPdfType6ShadingDictionary** out);
+bool mapType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6ShadingDictionary** out);
+bool mapImageDictionary(const SkPdfObject& in, SkPdfImageDictionary** out);
+bool mapImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImageDictionary** out);
+bool mapAlternateImageDictionary(const SkPdfObject& in, SkPdfAlternateImageDictionary** out);
+bool mapAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAlternateImageDictionary** out);
+bool mapType1FormDictionary(const SkPdfObject& in, SkPdfType1FormDictionary** out);
+bool mapType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FormDictionary** out);
+bool mapGroupAttributesDictionary(const SkPdfObject& in, SkPdfGroupAttributesDictionary** out);
+bool mapGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGroupAttributesDictionary** out);
+bool mapReferenceDictionary(const SkPdfObject& in, SkPdfReferenceDictionary** out);
+bool mapReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReferenceDictionary** out);
+bool mapPSXobjectDictionary(const SkPdfObject& in, SkPdfPSXobjectDictionary** out);
+bool mapPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPSXobjectDictionary** out);
+bool mapType1FontDictionary(const SkPdfObject& in, SkPdfType1FontDictionary** out);
+bool mapType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FontDictionary** out);
+bool mapType3FontDictionary(const SkPdfObject& in, SkPdfType3FontDictionary** out);
+bool mapType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FontDictionary** out);
+bool mapEncodingDictionary(const SkPdfObject& in, SkPdfEncodingDictionary** out);
+bool mapEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncodingDictionary** out);
+bool mapCIDSystemInfoDictionary(const SkPdfObject& in, SkPdfCIDSystemInfoDictionary** out);
+bool mapCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDSystemInfoDictionary** out);
+bool mapCIDFontDictionary(const SkPdfObject& in, SkPdfCIDFontDictionary** out);
+bool mapCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDictionary** out);
+bool mapCMapDictionary(const SkPdfObject& in, SkPdfCMapDictionary** out);
+bool mapCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCMapDictionary** out);
+bool mapType0FontDictionary(const SkPdfObject& in, SkPdfType0FontDictionary** out);
+bool mapType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FontDictionary** out);
+bool mapFontDescriptorDictionary(const SkPdfObject& in, SkPdfFontDescriptorDictionary** out);
+bool mapFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDescriptorDictionary** out);
+bool mapCIDFontDescriptorDictionary(const SkPdfObject& in, SkPdfCIDFontDescriptorDictionary** out);
+bool mapCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDescriptorDictionary** out);
+bool mapEmbeddedFontStreamDictionary(const SkPdfObject& in, SkPdfEmbeddedFontStreamDictionary** out);
+bool mapEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFontStreamDictionary** out);
+bool mapType1HalftoneDictionary(const SkPdfObject& in, SkPdfType1HalftoneDictionary** out);
+bool mapType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1HalftoneDictionary** out);
+bool mapType6HalftoneDictionary(const SkPdfObject& in, SkPdfType6HalftoneDictionary** out);
+bool mapType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6HalftoneDictionary** out);
+bool mapType10HalftoneDictionary(const SkPdfObject& in, SkPdfType10HalftoneDictionary** out);
+bool mapType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType10HalftoneDictionary** out);
+bool mapType16HalftoneDictionary(const SkPdfObject& in, SkPdfType16HalftoneDictionary** out);
+bool mapType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType16HalftoneDictionary** out);
+bool mapType5HalftoneDictionary(const SkPdfObject& in, SkPdfType5HalftoneDictionary** out);
+bool mapType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5HalftoneDictionary** out);
+bool mapSoftMaskDictionary(const SkPdfObject& in, SkPdfSoftMaskDictionary** out);
+bool mapSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskDictionary** out);
+bool mapSoftMaskImageDictionary(const SkPdfObject& in, SkPdfSoftMaskImageDictionary** out);
+bool mapSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskImageDictionary** out);
+bool mapTransparencyGroupDictionary(const SkPdfObject& in, SkPdfTransparencyGroupDictionary** out);
+bool mapTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransparencyGroupDictionary** out);
+bool mapViewerPreferencesDictionary(const SkPdfObject& in, SkPdfViewerPreferencesDictionary** out);
+bool mapViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfViewerPreferencesDictionary** out);
+bool mapOutlineDictionary(const SkPdfObject& in, SkPdfOutlineDictionary** out);
+bool mapOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineDictionary** out);
+bool mapOutlineItemDictionary(const SkPdfObject& in, SkPdfOutlineItemDictionary** out);
+bool mapOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineItemDictionary** out);
+bool mapPageLabelDictionary(const SkPdfObject& in, SkPdfPageLabelDictionary** out);
+bool mapPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageLabelDictionary** out);
+bool mapThreadDictionary(const SkPdfObject& in, SkPdfThreadDictionary** out);
+bool mapThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadDictionary** out);
+bool mapBeadDictionary(const SkPdfObject& in, SkPdfBeadDictionary** out);
+bool mapBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBeadDictionary** out);
+bool mapTransitionDictionary(const SkPdfObject& in, SkPdfTransitionDictionary** out);
+bool mapTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransitionDictionary** out);
+bool mapAnnotationDictionary(const SkPdfObject& in, SkPdfAnnotationDictionary** out);
+bool mapAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationDictionary** out);
+bool mapBorderStyleDictionary(const SkPdfObject& in, SkPdfBorderStyleDictionary** out);
+bool mapBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBorderStyleDictionary** out);
+bool mapAppearanceDictionary(const SkPdfObject& in, SkPdfAppearanceDictionary** out);
+bool mapAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceDictionary** out);
+bool mapTextAnnotationDictionary(const SkPdfObject& in, SkPdfTextAnnotationDictionary** out);
+bool mapTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextAnnotationDictionary** out);
+bool mapALinkAnnotationDictionary(const SkPdfObject& in, SkPdfALinkAnnotationDictionary** out);
+bool mapALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfALinkAnnotationDictionary** out);
+bool mapFreeTextAnnotationDictionary(const SkPdfObject& in, SkPdfFreeTextAnnotationDictionary** out);
+bool mapFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFreeTextAnnotationDictionary** out);
+bool mapLineAnnotationDictionary(const SkPdfObject& in, SkPdfLineAnnotationDictionary** out);
+bool mapLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLineAnnotationDictionary** out);
+bool mapSquareOrCircleAnnotation(const SkPdfObject& in, SkPdfSquareOrCircleAnnotation** out);
+bool mapSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSquareOrCircleAnnotation** out);
+bool mapMarkupAnnotationsDictionary(const SkPdfObject& in, SkPdfMarkupAnnotationsDictionary** out);
+bool mapMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkupAnnotationsDictionary** out);
+bool mapRubberStampAnnotationDictionary(const SkPdfObject& in, SkPdfRubberStampAnnotationDictionary** out);
+bool mapRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRubberStampAnnotationDictionary** out);
+bool mapInkAnnotationDictionary(const SkPdfObject& in, SkPdfInkAnnotationDictionary** out);
+bool mapInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInkAnnotationDictionary** out);
+bool mapPopUpAnnotationDictionary(const SkPdfObject& in, SkPdfPopUpAnnotationDictionary** out);
+bool mapPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPopUpAnnotationDictionary** out);
+bool mapFileAttachmentAnnotationDictionary(const SkPdfObject& in, SkPdfFileAttachmentAnnotationDictionary** out);
+bool mapFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileAttachmentAnnotationDictionary** out);
+bool mapSoundAnnotationDictionary(const SkPdfObject& in, SkPdfSoundAnnotationDictionary** out);
+bool mapSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundAnnotationDictionary** out);
+bool mapMovieAnnotationDictionary(const SkPdfObject& in, SkPdfMovieAnnotationDictionary** out);
+bool mapMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieAnnotationDictionary** out);
+bool mapWidgetAnnotationDictionary(const SkPdfObject& in, SkPdfWidgetAnnotationDictionary** out);
+bool mapWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWidgetAnnotationDictionary** out);
+bool mapActionDictionary(const SkPdfObject& in, SkPdfActionDictionary** out);
+bool mapActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfActionDictionary** out);
+bool mapAnnotationActionsDictionary(const SkPdfObject& in, SkPdfAnnotationActionsDictionary** out);
+bool mapAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationActionsDictionary** out);
+bool mapPageObjectActionsDictionary(const SkPdfObject& in, SkPdfPageObjectActionsDictionary** out);
+bool mapPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectActionsDictionary** out);
+bool mapFormFieldActionsDictionary(const SkPdfObject& in, SkPdfFormFieldActionsDictionary** out);
+bool mapFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFormFieldActionsDictionary** out);
+bool mapDocumentCatalogActionsDictionary(const SkPdfObject& in, SkPdfDocumentCatalogActionsDictionary** out);
+bool mapDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentCatalogActionsDictionary** out);
+bool mapGoToActionDictionary(const SkPdfObject& in, SkPdfGoToActionDictionary** out);
+bool mapGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGoToActionDictionary** out);
+bool mapRemoteGoToActionDictionary(const SkPdfObject& in, SkPdfRemoteGoToActionDictionary** out);
+bool mapRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRemoteGoToActionDictionary** out);
+bool mapLaunchActionDictionary(const SkPdfObject& in, SkPdfLaunchActionDictionary** out);
+bool mapLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLaunchActionDictionary** out);
+bool mapWindowsLaunchActionDictionary(const SkPdfObject& in, SkPdfWindowsLaunchActionDictionary** out);
+bool mapWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWindowsLaunchActionDictionary** out);
+bool mapThreadActionDictionary(const SkPdfObject& in, SkPdfThreadActionDictionary** out);
+bool mapThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadActionDictionary** out);
+bool mapURIActionDictionary(const SkPdfObject& in, SkPdfURIActionDictionary** out);
+bool mapURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIActionDictionary** out);
+bool mapURIDictionary(const SkPdfObject& in, SkPdfURIDictionary** out);
+bool mapURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIDictionary** out);
+bool mapSoundActionDictionary(const SkPdfObject& in, SkPdfSoundActionDictionary** out);
+bool mapSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundActionDictionary** out);
+bool mapMovieActionDictionary(const SkPdfObject& in, SkPdfMovieActionDictionary** out);
+bool mapMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActionDictionary** out);
+bool mapHideActionDictionary(const SkPdfObject& in, SkPdfHideActionDictionary** out);
+bool mapHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHideActionDictionary** out);
+bool mapNamedActionsDictionary(const SkPdfObject& in, SkPdfNamedActionsDictionary** out);
+bool mapNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNamedActionsDictionary** out);
+bool mapInteractiveFormDictionary(const SkPdfObject& in, SkPdfInteractiveFormDictionary** out);
+bool mapInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteractiveFormDictionary** out);
+bool mapFieldDictionary(const SkPdfObject& in, SkPdfFieldDictionary** out);
+bool mapFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFieldDictionary** out);
+bool mapVariableTextFieldDictionary(const SkPdfObject& in, SkPdfVariableTextFieldDictionary** out);
+bool mapVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfVariableTextFieldDictionary** out);
+bool mapAppearanceCharacteristicsDictionary(const SkPdfObject& in, SkPdfAppearanceCharacteristicsDictionary** out);
+bool mapAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceCharacteristicsDictionary** out);
+bool mapCheckboxFieldDictionary(const SkPdfObject& in, SkPdfCheckboxFieldDictionary** out);
+bool mapCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCheckboxFieldDictionary** out);
+bool mapRadioButtonFieldDictionary(const SkPdfObject& in, SkPdfRadioButtonFieldDictionary** out);
+bool mapRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRadioButtonFieldDictionary** out);
+bool mapTextFieldDictionary(const SkPdfObject& in, SkPdfTextFieldDictionary** out);
+bool mapTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextFieldDictionary** out);
+bool mapChoiceFieldDictionary(const SkPdfObject& in, SkPdfChoiceFieldDictionary** out);
+bool mapChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfChoiceFieldDictionary** out);
+bool mapSignatureDictionary(const SkPdfObject& in, SkPdfSignatureDictionary** out);
+bool mapSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSignatureDictionary** out);
+bool mapSubmitFormActionDictionary(const SkPdfObject& in, SkPdfSubmitFormActionDictionary** out);
+bool mapSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSubmitFormActionDictionary** out);
+bool mapResetFormActionDictionary(const SkPdfObject& in, SkPdfResetFormActionDictionary** out);
+bool mapResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResetFormActionDictionary** out);
+bool mapImportDataActionDictionary(const SkPdfObject& in, SkPdfImportDataActionDictionary** out);
+bool mapImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImportDataActionDictionary** out);
+bool mapJavascriptActionDictionary(const SkPdfObject& in, SkPdfJavascriptActionDictionary** out);
+bool mapJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptActionDictionary** out);
+bool mapFDFTrailerDictionary(const SkPdfObject& in, SkPdfFDFTrailerDictionary** out);
+bool mapFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTrailerDictionary** out);
+bool mapFDFCatalogDictionary(const SkPdfObject& in, SkPdfFDFCatalogDictionary** out);
+bool mapFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFCatalogDictionary** out);
+bool mapFDFDictionary(const SkPdfObject& in, SkPdfFDFDictionary** out);
+bool mapFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFDictionary** out);
+bool mapEncryptedEmbeddedFileStreamDictionary(const SkPdfObject& in, SkPdfEncryptedEmbeddedFileStreamDictionary** out);
+bool mapEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptedEmbeddedFileStreamDictionary** out);
+bool mapJavascriptDictionary(const SkPdfObject& in, SkPdfJavascriptDictionary** out);
+bool mapJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptDictionary** out);
+bool mapFDFFieldDictionary(const SkPdfObject& in, SkPdfFDFFieldDictionary** out);
+bool mapFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFieldDictionary** out);
+bool mapIconFitDictionary(const SkPdfObject& in, SkPdfIconFitDictionary** out);
+bool mapIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIconFitDictionary** out);
+bool mapFDFPageDictionary(const SkPdfObject& in, SkPdfFDFPageDictionary** out);
+bool mapFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFPageDictionary** out);
+bool mapFDFTemplateDictionary(const SkPdfObject& in, SkPdfFDFTemplateDictionary** out);
+bool mapFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTemplateDictionary** out);
+bool mapFDFNamedPageReferenceDictionary(const SkPdfObject& in, SkPdfFDFNamedPageReferenceDictionary** out);
+bool mapFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFNamedPageReferenceDictionary** out);
+bool mapFDFFileAnnotationDictionary(const SkPdfObject& in, SkPdfFDFFileAnnotationDictionary** out);
+bool mapFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFileAnnotationDictionary** out);
+bool mapSoundObjectDictionary(const SkPdfObject& in, SkPdfSoundObjectDictionary** out);
+bool mapSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundObjectDictionary** out);
+bool mapMovieDictionary(const SkPdfObject& in, SkPdfMovieDictionary** out);
+bool mapMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieDictionary** out);
+bool mapMovieActivationDictionary(const SkPdfObject& in, SkPdfMovieActivationDictionary** out);
+bool mapMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActivationDictionary** out);
+bool mapDocumentInformationDictionary(const SkPdfObject& in, SkPdfDocumentInformationDictionary** out);
+bool mapDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentInformationDictionary** out);
+bool mapMetadataStreamDictionary(const SkPdfObject& in, SkPdfMetadataStreamDictionary** out);
+bool mapMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMetadataStreamDictionary** out);
+bool mapComponentsWithMetadataDictionary(const SkPdfObject& in, SkPdfComponentsWithMetadataDictionary** out);
+bool mapComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfComponentsWithMetadataDictionary** out);
+bool mapPagePieceDictionary(const SkPdfObject& in, SkPdfPagePieceDictionary** out);
+bool mapPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPagePieceDictionary** out);
+bool mapApplicationDataDictionary(const SkPdfObject& in, SkPdfApplicationDataDictionary** out);
+bool mapApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfApplicationDataDictionary** out);
+bool mapStructureTreeRootDictionary(const SkPdfObject& in, SkPdfStructureTreeRootDictionary** out);
+bool mapStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureTreeRootDictionary** out);
+bool mapStructureElementDictionary(const SkPdfObject& in, SkPdfStructureElementDictionary** out);
+bool mapStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementDictionary** out);
+bool mapMarkedContentReferenceDictionary(const SkPdfObject& in, SkPdfMarkedContentReferenceDictionary** out);
+bool mapMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkedContentReferenceDictionary** out);
+bool mapObjectReferenceDictionary(const SkPdfObject& in, SkPdfObjectReferenceDictionary** out);
+bool mapObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObjectReferenceDictionary** out);
+bool mapStructureElementAccessDictionary(const SkPdfObject& in, SkPdfStructureElementAccessDictionary** out);
+bool mapStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementAccessDictionary** out);
+bool mapAttributeObjectDictionary(const SkPdfObject& in, SkPdfAttributeObjectDictionary** out);
+bool mapAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAttributeObjectDictionary** out);
+bool mapMarkInformationDictionary(const SkPdfObject& in, SkPdfMarkInformationDictionary** out);
+bool mapMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkInformationDictionary** out);
+bool mapArtifactsDictionary(const SkPdfObject& in, SkPdfArtifactsDictionary** out);
+bool mapArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArtifactsDictionary** out);
+bool mapStandardStructureDictionary(const SkPdfObject& in, SkPdfStandardStructureDictionary** out);
+bool mapStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardStructureDictionary** out);
+bool mapBlockLevelStructureElementsDictionary(const SkPdfObject& in, SkPdfBlockLevelStructureElementsDictionary** out);
+bool mapBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBlockLevelStructureElementsDictionary** out);
+bool mapInlineLevelStructureElementsDictionary(const SkPdfObject& in, SkPdfInlineLevelStructureElementsDictionary** out);
+bool mapInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInlineLevelStructureElementsDictionary** out);
+bool mapListAttributeDictionary(const SkPdfObject& in, SkPdfListAttributeDictionary** out);
+bool mapListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfListAttributeDictionary** out);
+bool mapTableAttributesDictionary(const SkPdfObject& in, SkPdfTableAttributesDictionary** out);
+bool mapTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTableAttributesDictionary** out);
+bool mapWebCaptureInformationDictionary(const SkPdfObject& in, SkPdfWebCaptureInformationDictionary** out);
+bool mapWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureInformationDictionary** out);
+bool mapWebCaptureDictionary(const SkPdfObject& in, SkPdfWebCaptureDictionary** out);
+bool mapWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureDictionary** out);
+bool mapWebCapturePageSetDictionary(const SkPdfObject& in, SkPdfWebCapturePageSetDictionary** out);
+bool mapWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCapturePageSetDictionary** out);
+bool mapWebCaptureImageSetDictionary(const SkPdfObject& in, SkPdfWebCaptureImageSetDictionary** out);
+bool mapWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureImageSetDictionary** out);
+bool mapSourceInformationDictionary(const SkPdfObject& in, SkPdfSourceInformationDictionary** out);
+bool mapSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSourceInformationDictionary** out);
+bool mapURLAliasDictionary(const SkPdfObject& in, SkPdfURLAliasDictionary** out);
+bool mapURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURLAliasDictionary** out);
+bool mapWebCaptureCommandDictionary(const SkPdfObject& in, SkPdfWebCaptureCommandDictionary** out);
+bool mapWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandDictionary** out);
+bool mapWebCaptureCommandSettingsDictionary(const SkPdfObject& in, SkPdfWebCaptureCommandSettingsDictionary** out);
+bool mapWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandSettingsDictionary** out);
+bool mapBoxColorInformationDictionary(const SkPdfObject& in, SkPdfBoxColorInformationDictionary** out);
+bool mapBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxColorInformationDictionary** out);
+bool mapBoxStyleDictionary(const SkPdfObject& in, SkPdfBoxStyleDictionary** out);
+bool mapBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxStyleDictionary** out);
+bool mapPrinterMarkAnnotationDictionary(const SkPdfObject& in, SkPdfPrinterMarkAnnotationDictionary** out);
+bool mapPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkAnnotationDictionary** out);
+bool mapPrinterMarkFormDictionary(const SkPdfObject& in, SkPdfPrinterMarkFormDictionary** out);
+bool mapPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkFormDictionary** out);
+bool mapSeparationDictionary(const SkPdfObject& in, SkPdfSeparationDictionary** out);
+bool mapSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSeparationDictionary** out);
+bool mapPDF_XOutputIntentDictionary(const SkPdfObject& in, SkPdfPDF_XOutputIntentDictionary** out);
+bool mapPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPDF_XOutputIntentDictionary** out);
+bool mapTrapNetworkAnnotationDictionary(const SkPdfObject& in, SkPdfTrapNetworkAnnotationDictionary** out);
+bool mapTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAnnotationDictionary** out);
+bool mapTrapNetworkAppearanceStreamDictionary(const SkPdfObject& in, SkPdfTrapNetworkAppearanceStreamDictionary** out);
+bool mapTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAppearanceStreamDictionary** out);
+bool mapOpiVersionDictionary(const SkPdfObject& in, SkPdfOpiVersionDictionary** out);
+bool mapOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOpiVersionDictionary** out);
+bool mapMultiMasterFontDictionary(const SkPdfObject& in, SkPdfMultiMasterFontDictionary** out);
+bool mapMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMultiMasterFontDictionary** out);
+bool isObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ObjectFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfObject** data);
+bool ObjectFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfObject** data);
+bool isNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NullFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNull** data);
+bool NullFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNull** data);
+bool isBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool BooleanFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBoolean** data);
+bool BooleanFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBoolean** data);
+bool isInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool IntegerFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInteger** data);
+bool IntegerFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInteger** data);
+bool isNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NumberFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNumber** data);
+bool NumberFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNumber** data);
+bool isName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NameFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfName** data);
+bool NameFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfName** data);
+bool isReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ReferenceFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfReference** data);
+bool ReferenceFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfReference** data);
+bool isArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfArray** data);
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfArray** data);
+bool isString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfString** data);
+bool StringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfString** data);
+bool isHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool HexStringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfHexString** data);
+bool HexStringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfHexString** data);
+bool isDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDictionary** data);
+bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDictionary** data);
+bool isStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStream** data);
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStream** data);
+bool isXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool XObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfXObjectDictionary** data);
+bool XObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfXObjectDictionary** data);
+bool isFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFontDictionary** data);
+bool FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFontDictionary** data);
+bool isTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TrueTypeFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrueTypeFontDictionary** data);
+bool TrueTypeFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrueTypeFontDictionary** data);
+bool isStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StreamCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStreamCommonDictionary** data);
+bool StreamCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStreamCommonDictionary** data);
+bool isLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** data);
+bool LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** data);
+bool isCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CcittfaxdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCcittfaxdecodeFilterDictionary** data);
+bool CcittfaxdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCcittfaxdecodeFilterDictionary** data);
+bool isJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Jbig2DecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfJbig2DecodeFilterDictionary** data);
+bool Jbig2DecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfJbig2DecodeFilterDictionary** data);
+bool isDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool DctdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDctdecodeFilterDictionary** data);
+bool DctdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDctdecodeFilterDictionary** data);
+bool isFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FileTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFileTrailerDictionary** data);
+bool FileTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileTrailerDictionary** data);
+bool isEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool EncryptionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEncryptionCommonDictionary** data);
+bool EncryptionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncryptionCommonDictionary** data);
+bool isStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StandardSecurityHandlerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStandardSecurityHandlerDictionary** data);
+bool StandardSecurityHandlerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStandardSecurityHandlerDictionary** data);
+bool isCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCatalogDictionary** data);
+bool CatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCatalogDictionary** data);
+bool isPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PageTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageTreeNodeDictionary** data);
+bool PageTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageTreeNodeDictionary** data);
+bool isPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PageObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageObjectDictionary** data);
+bool PageObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageObjectDictionary** data);
+bool isNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NameDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNameDictionary** data);
+bool NameDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNameDictionary** data);
+bool isResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ResourceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfResourceDictionary** data);
+bool ResourceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfResourceDictionary** data);
+bool isNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NameTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNameTreeNodeDictionary** data);
+bool NameTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNameTreeNodeDictionary** data);
+bool isNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NumberTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNumberTreeNodeDictionary** data);
+bool NumberTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNumberTreeNodeDictionary** data);
+bool isFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FunctionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFunctionCommonDictionary** data);
+bool FunctionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFunctionCommonDictionary** data);
+bool isType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type0FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType0FunctionDictionary** data);
+bool Type0FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType0FunctionDictionary** data);
+bool isType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type2FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType2FunctionDictionary** data);
+bool Type2FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType2FunctionDictionary** data);
+bool isType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type3FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType3FunctionDictionary** data);
+bool Type3FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType3FunctionDictionary** data);
+bool isFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FileSpecificationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFileSpecificationDictionary** data);
+bool FileSpecificationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileSpecificationDictionary** data);
+bool isEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool EmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFileStreamDictionary** data);
+bool EmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFileStreamDictionary** data);
+bool isEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool EmbeddedFileParameterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFileParameterDictionary** data);
+bool EmbeddedFileParameterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFileParameterDictionary** data);
+bool isMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MacOsFileInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMacOsFileInformationDictionary** data);
+bool MacOsFileInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMacOsFileInformationDictionary** data);
+bool isGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool GraphicsStateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGraphicsStateDictionary** data);
+bool GraphicsStateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGraphicsStateDictionary** data);
+bool isCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CalgrayColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCalgrayColorSpaceDictionary** data);
+bool CalgrayColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCalgrayColorSpaceDictionary** data);
+bool isCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CalrgbColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCalrgbColorSpaceDictionary** data);
+bool CalrgbColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCalrgbColorSpaceDictionary** data);
+bool isLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool LabColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLabColorSpaceDictionary** data);
+bool LabColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLabColorSpaceDictionary** data);
+bool isIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool IccProfileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfIccProfileStreamDictionary** data);
+bool IccProfileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfIccProfileStreamDictionary** data);
+bool isDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool DeviceNColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDeviceNColorSpaceDictionary** data);
+bool DeviceNColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDeviceNColorSpaceDictionary** data);
+bool isType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type1PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1PatternDictionary** data);
+bool Type1PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1PatternDictionary** data);
+bool isType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type2PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType2PatternDictionary** data);
+bool Type2PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType2PatternDictionary** data);
+bool isShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfShadingDictionary** data);
+bool ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfShadingDictionary** data);
+bool isType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type1ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1ShadingDictionary** data);
+bool Type1ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1ShadingDictionary** data);
+bool isType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type2ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType2ShadingDictionary** data);
+bool Type2ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType2ShadingDictionary** data);
+bool isType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type3ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType3ShadingDictionary** data);
+bool Type3ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType3ShadingDictionary** data);
+bool isType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type4ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType4ShadingDictionary** data);
+bool Type4ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType4ShadingDictionary** data);
+bool isType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type5ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType5ShadingDictionary** data);
+bool Type5ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType5ShadingDictionary** data);
+bool isType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type6ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType6ShadingDictionary** data);
+bool Type6ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType6ShadingDictionary** data);
+bool isImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfImageDictionary** data);
+bool ImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfImageDictionary** data);
+bool isAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool AlternateImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAlternateImageDictionary** data);
+bool AlternateImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAlternateImageDictionary** data);
+bool isType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type1FormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1FormDictionary** data);
+bool Type1FormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1FormDictionary** data);
+bool isGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool GroupAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGroupAttributesDictionary** data);
+bool GroupAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGroupAttributesDictionary** data);
+bool isReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfReferenceDictionary** data);
+bool ReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfReferenceDictionary** data);
+bool isPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PSXobjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPSXobjectDictionary** data);
+bool PSXobjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPSXobjectDictionary** data);
+bool isType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type1FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1FontDictionary** data);
+bool Type1FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1FontDictionary** data);
+bool isType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type3FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType3FontDictionary** data);
+bool Type3FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType3FontDictionary** data);
+bool isEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool EncodingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEncodingDictionary** data);
+bool EncodingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncodingDictionary** data);
+bool isCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CIDSystemInfoDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCIDSystemInfoDictionary** data);
+bool CIDSystemInfoDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDSystemInfoDictionary** data);
+bool isCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CIDFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCIDFontDictionary** data);
+bool CIDFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDFontDictionary** data);
+bool isCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CMapDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCMapDictionary** data);
+bool CMapDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCMapDictionary** data);
+bool isType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type0FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType0FontDictionary** data);
+bool Type0FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType0FontDictionary** data);
+bool isFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFontDescriptorDictionary** data);
+bool FontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFontDescriptorDictionary** data);
+bool isCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CIDFontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCIDFontDescriptorDictionary** data);
+bool CIDFontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDFontDescriptorDictionary** data);
+bool isEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool EmbeddedFontStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFontStreamDictionary** data);
+bool EmbeddedFontStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFontStreamDictionary** data);
+bool isType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type1HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1HalftoneDictionary** data);
+bool Type1HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1HalftoneDictionary** data);
+bool isType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type6HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType6HalftoneDictionary** data);
+bool Type6HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType6HalftoneDictionary** data);
+bool isType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type10HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType10HalftoneDictionary** data);
+bool Type10HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType10HalftoneDictionary** data);
+bool isType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type16HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType16HalftoneDictionary** data);
+bool Type16HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType16HalftoneDictionary** data);
+bool isType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type5HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType5HalftoneDictionary** data);
+bool Type5HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType5HalftoneDictionary** data);
+bool isSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SoftMaskDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoftMaskDictionary** data);
+bool SoftMaskDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoftMaskDictionary** data);
+bool isSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SoftMaskImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoftMaskImageDictionary** data);
+bool SoftMaskImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoftMaskImageDictionary** data);
+bool isTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TransparencyGroupDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTransparencyGroupDictionary** data);
+bool TransparencyGroupDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTransparencyGroupDictionary** data);
+bool isViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ViewerPreferencesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfViewerPreferencesDictionary** data);
+bool ViewerPreferencesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfViewerPreferencesDictionary** data);
+bool isOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool OutlineDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfOutlineDictionary** data);
+bool OutlineDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfOutlineDictionary** data);
+bool isOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool OutlineItemDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfOutlineItemDictionary** data);
+bool OutlineItemDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfOutlineItemDictionary** data);
+bool isPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PageLabelDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageLabelDictionary** data);
+bool PageLabelDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageLabelDictionary** data);
+bool isThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ThreadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfThreadDictionary** data);
+bool ThreadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfThreadDictionary** data);
+bool isBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool BeadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBeadDictionary** data);
+bool BeadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBeadDictionary** data);
+bool isTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TransitionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTransitionDictionary** data);
+bool TransitionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTransitionDictionary** data);
+bool isAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool AnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAnnotationDictionary** data);
+bool AnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAnnotationDictionary** data);
+bool isBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool BorderStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBorderStyleDictionary** data);
+bool BorderStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBorderStyleDictionary** data);
+bool isAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool AppearanceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAppearanceDictionary** data);
+bool AppearanceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAppearanceDictionary** data);
+bool isTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTextAnnotationDictionary** data);
+bool TextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTextAnnotationDictionary** data);
+bool isALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ALinkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfALinkAnnotationDictionary** data);
+bool ALinkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfALinkAnnotationDictionary** data);
+bool isFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FreeTextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFreeTextAnnotationDictionary** data);
+bool FreeTextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFreeTextAnnotationDictionary** data);
+bool isLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool LineAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLineAnnotationDictionary** data);
+bool LineAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLineAnnotationDictionary** data);
+bool isSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SquareOrCircleAnnotationFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSquareOrCircleAnnotation** data);
+bool SquareOrCircleAnnotationFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSquareOrCircleAnnotation** data);
+bool isMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MarkupAnnotationsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkupAnnotationsDictionary** data);
+bool MarkupAnnotationsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkupAnnotationsDictionary** data);
+bool isRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool RubberStampAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRubberStampAnnotationDictionary** data);
+bool RubberStampAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRubberStampAnnotationDictionary** data);
+bool isInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool InkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInkAnnotationDictionary** data);
+bool InkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInkAnnotationDictionary** data);
+bool isPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PopUpAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPopUpAnnotationDictionary** data);
+bool PopUpAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPopUpAnnotationDictionary** data);
+bool isFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FileAttachmentAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFileAttachmentAnnotationDictionary** data);
+bool FileAttachmentAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileAttachmentAnnotationDictionary** data);
+bool isSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SoundAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundAnnotationDictionary** data);
+bool SoundAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundAnnotationDictionary** data);
+bool isMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MovieAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieAnnotationDictionary** data);
+bool MovieAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieAnnotationDictionary** data);
+bool isWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WidgetAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWidgetAnnotationDictionary** data);
+bool WidgetAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWidgetAnnotationDictionary** data);
+bool isActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfActionDictionary** data);
+bool ActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfActionDictionary** data);
+bool isAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool AnnotationActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAnnotationActionsDictionary** data);
+bool AnnotationActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAnnotationActionsDictionary** data);
+bool isPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PageObjectActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageObjectActionsDictionary** data);
+bool PageObjectActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageObjectActionsDictionary** data);
+bool isFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FormFieldActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFormFieldActionsDictionary** data);
+bool FormFieldActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFormFieldActionsDictionary** data);
+bool isDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool DocumentCatalogActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDocumentCatalogActionsDictionary** data);
+bool DocumentCatalogActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDocumentCatalogActionsDictionary** data);
+bool isGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool GoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGoToActionDictionary** data);
+bool GoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGoToActionDictionary** data);
+bool isRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool RemoteGoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRemoteGoToActionDictionary** data);
+bool RemoteGoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRemoteGoToActionDictionary** data);
+bool isLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool LaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLaunchActionDictionary** data);
+bool LaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLaunchActionDictionary** data);
+bool isWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WindowsLaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWindowsLaunchActionDictionary** data);
+bool WindowsLaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWindowsLaunchActionDictionary** data);
+bool isThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ThreadActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfThreadActionDictionary** data);
+bool ThreadActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfThreadActionDictionary** data);
+bool isURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool URIActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfURIActionDictionary** data);
+bool URIActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfURIActionDictionary** data);
+bool isURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool URIDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfURIDictionary** data);
+bool URIDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfURIDictionary** data);
+bool isSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SoundActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundActionDictionary** data);
+bool SoundActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundActionDictionary** data);
+bool isMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MovieActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieActionDictionary** data);
+bool MovieActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieActionDictionary** data);
+bool isHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool HideActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfHideActionDictionary** data);
+bool HideActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfHideActionDictionary** data);
+bool isNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NamedActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNamedActionsDictionary** data);
+bool NamedActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNamedActionsDictionary** data);
+bool isInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool InteractiveFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInteractiveFormDictionary** data);
+bool InteractiveFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInteractiveFormDictionary** data);
+bool isFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFieldDictionary** data);
+bool FieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFieldDictionary** data);
+bool isVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool VariableTextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfVariableTextFieldDictionary** data);
+bool VariableTextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfVariableTextFieldDictionary** data);
+bool isAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool AppearanceCharacteristicsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAppearanceCharacteristicsDictionary** data);
+bool AppearanceCharacteristicsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAppearanceCharacteristicsDictionary** data);
+bool isCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CheckboxFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCheckboxFieldDictionary** data);
+bool CheckboxFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCheckboxFieldDictionary** data);
+bool isRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool RadioButtonFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRadioButtonFieldDictionary** data);
+bool RadioButtonFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRadioButtonFieldDictionary** data);
+bool isTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTextFieldDictionary** data);
+bool TextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTextFieldDictionary** data);
+bool isChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ChoiceFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfChoiceFieldDictionary** data);
+bool ChoiceFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfChoiceFieldDictionary** data);
+bool isSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SignatureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSignatureDictionary** data);
+bool SignatureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSignatureDictionary** data);
+bool isSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SubmitFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSubmitFormActionDictionary** data);
+bool SubmitFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSubmitFormActionDictionary** data);
+bool isResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ResetFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfResetFormActionDictionary** data);
+bool ResetFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfResetFormActionDictionary** data);
+bool isImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ImportDataActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfImportDataActionDictionary** data);
+bool ImportDataActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfImportDataActionDictionary** data);
+bool isJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool JavascriptActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfJavascriptActionDictionary** data);
+bool JavascriptActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfJavascriptActionDictionary** data);
+bool isFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFTrailerDictionary** data);
+bool FDFTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFTrailerDictionary** data);
+bool isFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFCatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFCatalogDictionary** data);
+bool FDFCatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFCatalogDictionary** data);
+bool isFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFDictionary** data);
+bool FDFDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFDictionary** data);
+bool isEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool EncryptedEmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEncryptedEmbeddedFileStreamDictionary** data);
+bool EncryptedEmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncryptedEmbeddedFileStreamDictionary** data);
+bool isJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool JavascriptDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfJavascriptDictionary** data);
+bool JavascriptDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfJavascriptDictionary** data);
+bool isFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFFieldDictionary** data);
+bool FDFFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFFieldDictionary** data);
+bool isIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool IconFitDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfIconFitDictionary** data);
+bool IconFitDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfIconFitDictionary** data);
+bool isFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFPageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFPageDictionary** data);
+bool FDFPageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFPageDictionary** data);
+bool isFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFTemplateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFTemplateDictionary** data);
+bool FDFTemplateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFTemplateDictionary** data);
+bool isFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFNamedPageReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFNamedPageReferenceDictionary** data);
+bool FDFNamedPageReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFNamedPageReferenceDictionary** data);
+bool isFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFFileAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFFileAnnotationDictionary** data);
+bool FDFFileAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFFileAnnotationDictionary** data);
+bool isSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SoundObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundObjectDictionary** data);
+bool SoundObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundObjectDictionary** data);
+bool isMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MovieDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieDictionary** data);
+bool MovieDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieDictionary** data);
+bool isMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MovieActivationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieActivationDictionary** data);
+bool MovieActivationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieActivationDictionary** data);
+bool isDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool DocumentInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDocumentInformationDictionary** data);
+bool DocumentInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDocumentInformationDictionary** data);
+bool isMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MetadataStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMetadataStreamDictionary** data);
+bool MetadataStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMetadataStreamDictionary** data);
+bool isComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ComponentsWithMetadataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfComponentsWithMetadataDictionary** data);
+bool ComponentsWithMetadataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfComponentsWithMetadataDictionary** data);
+bool isPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PagePieceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPagePieceDictionary** data);
+bool PagePieceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPagePieceDictionary** data);
+bool isApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ApplicationDataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfApplicationDataDictionary** data);
+bool ApplicationDataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfApplicationDataDictionary** data);
+bool isStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StructureTreeRootDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStructureTreeRootDictionary** data);
+bool StructureTreeRootDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureTreeRootDictionary** data);
+bool isStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StructureElementDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStructureElementDictionary** data);
+bool StructureElementDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureElementDictionary** data);
+bool isMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MarkedContentReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkedContentReferenceDictionary** data);
+bool MarkedContentReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkedContentReferenceDictionary** data);
+bool isObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ObjectReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfObjectReferenceDictionary** data);
+bool ObjectReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfObjectReferenceDictionary** data);
+bool isStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StructureElementAccessDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStructureElementAccessDictionary** data);
+bool StructureElementAccessDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureElementAccessDictionary** data);
+bool isAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool AttributeObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAttributeObjectDictionary** data);
+bool AttributeObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAttributeObjectDictionary** data);
+bool isMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MarkInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkInformationDictionary** data);
+bool MarkInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkInformationDictionary** data);
+bool isArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ArtifactsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfArtifactsDictionary** data);
+bool ArtifactsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfArtifactsDictionary** data);
+bool isStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StandardStructureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStandardStructureDictionary** data);
+bool StandardStructureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStandardStructureDictionary** data);
+bool isBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool BlockLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBlockLevelStructureElementsDictionary** data);
+bool BlockLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBlockLevelStructureElementsDictionary** data);
+bool isInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool InlineLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInlineLevelStructureElementsDictionary** data);
+bool InlineLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInlineLevelStructureElementsDictionary** data);
+bool isListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ListAttributeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfListAttributeDictionary** data);
+bool ListAttributeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfListAttributeDictionary** data);
+bool isTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TableAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTableAttributesDictionary** data);
+bool TableAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTableAttributesDictionary** data);
+bool isWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WebCaptureInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureInformationDictionary** data);
+bool WebCaptureInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureInformationDictionary** data);
+bool isWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WebCaptureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureDictionary** data);
+bool WebCaptureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureDictionary** data);
+bool isWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WebCapturePageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCapturePageSetDictionary** data);
+bool WebCapturePageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCapturePageSetDictionary** data);
+bool isWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WebCaptureImageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureImageSetDictionary** data);
+bool WebCaptureImageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureImageSetDictionary** data);
+bool isSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SourceInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSourceInformationDictionary** data);
+bool SourceInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSourceInformationDictionary** data);
+bool isURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool URLAliasDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfURLAliasDictionary** data);
+bool URLAliasDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfURLAliasDictionary** data);
+bool isWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WebCaptureCommandDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureCommandDictionary** data);
+bool WebCaptureCommandDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureCommandDictionary** data);
+bool isWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WebCaptureCommandSettingsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureCommandSettingsDictionary** data);
+bool WebCaptureCommandSettingsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureCommandSettingsDictionary** data);
+bool isBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool BoxColorInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBoxColorInformationDictionary** data);
+bool BoxColorInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBoxColorInformationDictionary** data);
+bool isBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool BoxStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBoxStyleDictionary** data);
+bool BoxStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBoxStyleDictionary** data);
+bool isPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PrinterMarkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPrinterMarkAnnotationDictionary** data);
+bool PrinterMarkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPrinterMarkAnnotationDictionary** data);
+bool isPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PrinterMarkFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPrinterMarkFormDictionary** data);
+bool PrinterMarkFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPrinterMarkFormDictionary** data);
+bool isSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SeparationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSeparationDictionary** data);
+bool SeparationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSeparationDictionary** data);
+bool isPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PDF_XOutputIntentDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPDF_XOutputIntentDictionary** data);
+bool PDF_XOutputIntentDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPDF_XOutputIntentDictionary** data);
+bool isTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TrapNetworkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrapNetworkAnnotationDictionary** data);
+bool TrapNetworkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrapNetworkAnnotationDictionary** data);
+bool isTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TrapNetworkAppearanceStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrapNetworkAppearanceStreamDictionary** data);
+bool TrapNetworkAppearanceStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrapNetworkAppearanceStreamDictionary** data);
+bool isOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool OpiVersionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfOpiVersionDictionary** data);
+bool OpiVersionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfOpiVersionDictionary** data);
+bool isMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MultiMasterFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMultiMasterFontDictionary** data);
+bool MultiMasterFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMultiMasterFontDictionary** data);
#endif // __DEFINED__SkPdfPodofoMapper
diff --git a/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..35f68a0
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfPopUpAnnotationDictionary_autogen.h"
+
+std::string SkPdfPopUpAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfPopUpAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfPopUpAnnotationDictionary::Parent() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+bool SkPdfPopUpAnnotationDictionary::Open() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.h
index 6c1e25f..b3dc293 100644
--- a/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Optional; PDF 1.4) An alternate representation of the annotation's contents
* in human-readable form, useful when extracting the document's contents in
* support of accessibility to disabled users or for other purposes (see Section
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Optional; must be an indirect reference) The parent annotation with which
* this pop-up annotation is associated.
* Note: If this entry is present, the parent annotation's Contents, M, C, and T
@@ -565,13 +553,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", NULL));
}
- SkPdfDictionary* Parent() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Parent() const;
/** (Optional) A flag specifying whether the pop-up annotation should initially
* be displayed open. Default value: false (closed).
**/
@@ -579,13 +561,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", NULL));
}
- bool Open() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool Open() const;
};
#endif // __DEFINED__SkPdfPopUpAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..8607e11
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfPrinterMarkAnnotationDictionary_autogen.h"
+
+std::string SkPdfPrinterMarkAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfPrinterMarkAnnotationDictionary::MN() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MN", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.h
index 07f7ff0..c6f8af3 100644
--- a/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Optional) An arbitrary name identifying the type of printer's mark, such as Color-
* Bar or RegistrationTarget.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MN", "", NULL));
}
- std::string MN() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MN", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string MN() const;
};
#endif // __DEFINED__SkPdfPrinterMarkAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.cpp
new file mode 100644
index 0000000..3d7c3f6
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfPrinterMarkFormDictionary_autogen.h"
+
+std::string SkPdfPrinterMarkFormDictionary::MarkStyle() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkStyle", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfPrinterMarkFormDictionary::Colorants() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.h
index 1463783..3c2124b 100644
--- a/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkStyle", "", NULL));
}
- std::string MarkStyle() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkStyle", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string MarkStyle() const;
/** (Optional; PDF 1.4) A dictionary identifying the individual colorants
* associated with a printer's mark such as a color bar. For each entry in this
* dictionary, the key is a colorant name and the value is an array defining a
@@ -550,13 +544,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", NULL));
}
- SkPdfDictionary* Colorants() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Colorants() const;
};
#endif // __DEFINED__SkPdfPrinterMarkFormDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..ac178fc
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfRadioButtonFieldDictionary_autogen.h"
+
+SkPdfArray* SkPdfRadioButtonFieldDictionary::Opt() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.h
index 35851bd..67fda2e 100644
--- a/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.h
@@ -535,13 +535,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", NULL));
}
- SkPdfArray* Opt() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Opt() const;
};
#endif // __DEFINED__SkPdfRadioButtonFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.cpp
new file mode 100644
index 0000000..e901c3e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfReferenceDictionary_autogen.h"
+
+SkPdfFileSpec SkPdfReferenceDictionary::F() const {
+ SkPdfFileSpec ret;
+ if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFileSpec();
+}
+
+long SkPdfReferenceDictionary::getPageAsInteger() const {
+ long ret = 0;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfReferenceDictionary::getPageAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfReferenceDictionary::ID() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.h
index dc4d679..3a0253c 100644
--- a/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.h
@@ -531,13 +531,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- SkPdfFileSpec F() const {
- SkPdfFileSpec ret;
- if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFileSpec();
- }
-
+ SkPdfFileSpec F() const;
/** (Required) A page index or page label (see Section 8.3.1, "Page Labels")
* identifying the page of the target document containing the content to be
* imported. Note that the reference is a weak one and can be inadvertently in-
@@ -554,26 +548,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Number;
}
- long getPageAsInteger() const {
- long ret = 0;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long getPageAsInteger() const;
bool isPageAString() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getPageAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getPageAsString() const;
/** (Optional) An array of two strings constituting a file identifier (see Section 9.3,
* "File Identifiers") for the file containing the target document. The use of this
* entry improves a viewer application's chances of finding the intended file and
@@ -583,13 +565,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
}
- SkPdfArray* ID() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* ID() const;
};
#endif // __DEFINED__SkPdfReferenceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfReference_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfReference_autogen.cpp
new file mode 100644
index 0000000..f78ef63
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfReference_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfReference_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.cpp
new file mode 100644
index 0000000..b867053
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfRemoteGoToActionDictionary_autogen.h"
+
+std::string SkPdfRemoteGoToActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfFileSpec SkPdfRemoteGoToActionDictionary::F() const {
+ SkPdfFileSpec ret;
+ if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFileSpec();
+}
+
+std::string SkPdfRemoteGoToActionDictionary::getDAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfRemoteGoToActionDictionary::getDAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfRemoteGoToActionDictionary::getDAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+bool SkPdfRemoteGoToActionDictionary::NewWindow() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.h
index eb42612..9ae32ca 100644
--- a/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.h
@@ -532,26 +532,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) The file in which the destination is located.
**/
bool has_F() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- SkPdfFileSpec F() const {
- SkPdfFileSpec ret;
- if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFileSpec();
- }
-
+ SkPdfFileSpec F() const;
/** (Required) The destination to jump to (see Section 8.2.1, "Destinations"). If
* the value is an array defining an explicit destination (as described under
* "Explicit Destinations" on page 474), its first element must be a page number
@@ -568,39 +556,21 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getDAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getDAsName() const;
bool isDAString() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getDAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getDAsString() const;
bool isDAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getDAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getDAsArray() const;
/** (Optional; PDF 1.2) A flag specifying whether to open the destination docu-
* ment in a new window. If this flag is false, the destination document will
* replace the current document in the same window. If this entry is absent,
@@ -611,13 +581,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", NULL));
}
- bool NewWindow() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool NewWindow() const;
};
#endif // __DEFINED__SkPdfRemoteGoToActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.cpp
new file mode 100644
index 0000000..78a0eb4
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfResetFormActionDictionary_autogen.h"
+
+std::string SkPdfResetFormActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfResetFormActionDictionary::Fields() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfResetFormActionDictionary::Flags() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.h
index b4efb99..206fa20 100644
--- a/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Optional) An array identifying which fields to reset or which to exclude
* from resetting, depending on the setting of the Include/Exclude flag in
* the Flags entry (see Table 8.64). Each element of the array is either an in-
@@ -552,13 +546,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", NULL));
}
- SkPdfArray* Fields() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Fields() const;
/** (Optional; inheritable) A set of flags specifying various characteristics of
* the action (see Table 8.64). Default value: 0.
**/
@@ -566,13 +554,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", NULL));
}
- long Flags() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Flags() const;
};
#endif // __DEFINED__SkPdfResetFormActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.cpp
new file mode 100644
index 0000000..5f4e045
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.cpp
@@ -0,0 +1,58 @@
+#include "SkPdfResourceDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfResourceDictionary::ExtGState() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfResourceDictionary::ColorSpace() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfResourceDictionary::Pattern() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pattern", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfResourceDictionary::Shading() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfResourceDictionary::XObject() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XObject", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfResourceDictionary::Font() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfResourceDictionary::ProcSet() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ProcSet", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfResourceDictionary::Properties() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Properties", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.h
index bd7079d..a339701 100644
--- a/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", NULL));
}
- SkPdfDictionary* ExtGState() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* ExtGState() const;
/** (Optional) A dictionary mapping each resource name to either the name of a
* device-dependent color space or an array describing a color space (see Sec-
* tion 4.5, "Color Spaces").
@@ -547,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", NULL));
}
- SkPdfDictionary* ColorSpace() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* ColorSpace() const;
/** (Optional) A dictionary mapping resource names to pattern objects (see Sec-
* tion 4.6, "Patterns").
**/
@@ -561,13 +549,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pattern", "", NULL));
}
- SkPdfDictionary* Pattern() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pattern", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Pattern() const;
/** (Optional; PDF 1.3) A dictionary mapping resource names to shading dic-
* tionaries (see "Shading Dictionaries" on page 233).
**/
@@ -575,13 +557,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", NULL));
}
- SkPdfDictionary* Shading() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Shading() const;
/** (Optional) A dictionary mapping resource names to external objects (see Sec-
* tion 4.7, "External Objects").
**/
@@ -589,13 +565,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XObject", "", NULL));
}
- SkPdfDictionary* XObject() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XObject", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* XObject() const;
/** (Optional) A dictionary mapping resource names to font dictionaries (see
* Chapter 5).
**/
@@ -603,13 +573,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", NULL));
}
- SkPdfDictionary* Font() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Font() const;
/** (Optional) An array of predefined procedure set names (see Section 9.1,
* "Procedure Sets").
**/
@@ -617,13 +581,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ProcSet", "", NULL));
}
- SkPdfArray* ProcSet() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ProcSet", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* ProcSet() const;
/** (Optional; PDF 1.2) A dictionary mapping resource names to property list
* dictionaries for marked content (see Section 9.5.1, "Property Lists").
**/
@@ -631,13 +589,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Properties", "", NULL));
}
- SkPdfDictionary* Properties() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Properties", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Properties() const;
};
#endif // __DEFINED__SkPdfResourceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..6636d98
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfRubberStampAnnotationDictionary_autogen.h"
+
+std::string SkPdfRubberStampAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfRubberStampAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfRubberStampAnnotationDictionary::Name() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.h
index 1d56702..b810ebc 100644
--- a/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) The text to be displayed in the pop-up window when the annotation
* is opened. Carriage returns may be used to separate the text into paragraphs.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Optional) The name of an icon to be used in displaying the annotation. Viewer
* applications should provide predefined icon appearances for at least the follow-
* ing standard names:
@@ -569,13 +557,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
}
- std::string Name() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Name() const;
};
#endif // __DEFINED__SkPdfRubberStampAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.cpp
new file mode 100644
index 0000000..533e5d5
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfSeparationDictionary_autogen.h"
+
+SkPdfArray* SkPdfSeparationDictionary::Pages() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfSeparationDictionary::getDeviceColorantAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfSeparationDictionary::getDeviceColorantAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfSeparationDictionary::ColorSpace() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.h
index 1c48aba..d4a2c3e 100644
--- a/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.h
@@ -535,13 +535,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", NULL));
}
- SkPdfArray* Pages() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Pages() const;
/** (Required) The name of the device colorant to be used in rendering this
* separation, such as Cyan or PANTONE 35 CV.
**/
@@ -555,26 +549,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getDeviceColorantAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getDeviceColorantAsName() const;
bool isDeviceColorantAString() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getDeviceColorantAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getDeviceColorantAsString() const;
/** (Optional) An array defining a Separation or DeviceN color space (see "Separa-
* tion Color Spaces" on page 201 and "DeviceN Color Spaces" on page 205). This
* provides additional information about the color specified by DeviceColorant-
@@ -590,13 +572,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", NULL));
}
- SkPdfArray* ColorSpace() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* ColorSpace() const;
};
#endif // __DEFINED__SkPdfSeparationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..61b986a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfShadingDictionary_autogen.h"
+
+long SkPdfShadingDictionary::ShadingType() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShadingType", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfShadingDictionary::getColorSpaceAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfShadingDictionary::getColorSpaceAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfShadingDictionary::Background() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Background", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkRect* SkPdfShadingDictionary::BBox() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+bool SkPdfShadingDictionary::AntiAlias() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AntiAlias", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.h
index b859b46..2009666 100644
--- a/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.h
@@ -520,13 +520,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShadingType", "", NULL));
}
- long ShadingType() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShadingType", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long ShadingType() const;
/** (Required) The color space in which color values are expressed. This may be
* any device, CIE-based, or special color space except a Pattern space. See
* "Color Space: Special Considerations," below, for further information.
@@ -541,26 +535,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getColorSpaceAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getColorSpaceAsName() const;
bool isColorSpaceAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getColorSpaceAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getColorSpaceAsArray() const;
/** (Optional) An array of color components appropriate to the color space,
* specifying a single background color value. If present, this color is used be-
* fore any painting operation involving the shading, to fill those portions of the
@@ -575,13 +557,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Background", "", NULL));
}
- SkPdfArray* Background() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Background", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Background() const;
/** (Optional) An array of four numbers giving the left, bottom, right, and top
* coordinates, respectively, of the shading's bounding box. The coordinates are
* interpreted in the shading's target coordinate space. If present, this bounding
@@ -593,13 +569,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", NULL));
}
- SkRect* BBox() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* BBox() const;
/** (Optional) A flag indicating whether to filter the shading function to prevent
* aliasing artifacts. The shading operators sample shading functions at a rate
* determined by the resolution of the output device. Aliasing can occur if the
@@ -614,13 +584,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AntiAlias", "", NULL));
}
- bool AntiAlias() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AntiAlias", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool AntiAlias() const;
};
#endif // __DEFINED__SkPdfShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.cpp
new file mode 100644
index 0000000..924cb9a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.cpp
@@ -0,0 +1,65 @@
+#include "SkPdfSignatureDictionary_autogen.h"
+
+std::string SkPdfSignatureDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfSignatureDictionary::Filter() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfSignatureDictionary::SubFilter() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SubFilter", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfSignatureDictionary::ByteRange() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ByteRange", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfSignatureDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfSignatureDictionary::Name() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDate SkPdfSignatureDictionary::M() const {
+ SkPdfDate ret;
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
+std::string SkPdfSignatureDictionary::Location() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Location", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfSignatureDictionary::Reason() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Reason", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.h
index cdb249c..e365ef6 100644
--- a/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required; inheritable) The name of the signature handler to be used for
* authenticating the field's contents, such as Adobe.PPKLite, Entrust.PPKEF,
* CICI.SignIt, or VeriSign.PPKVS.
@@ -547,26 +541,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", NULL));
}
- std::string Filter() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Filter() const;
/** (Optional) The name of a specific submethod of the specified handler.
**/
bool has_SubFilter() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SubFilter", "", NULL));
}
- std::string SubFilter() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SubFilter", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string SubFilter() const;
/** (Required) An array of pairs of integers (starting byte offset, length in bytes)
* describing the exact byte range for the digest calculation. Multiple discontig-
* uous byte ranges may be used to describe a digest that does not include the
@@ -576,39 +558,21 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ByteRange", "", NULL));
}
- SkPdfArray* ByteRange() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ByteRange", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* ByteRange() const;
/** (Required) The encrypted signature token.
**/
bool has_Contents() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Optional) The name of the person or authority signing the document.
**/
bool has_Name() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
}
- std::string Name() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Name() const;
/** (Optional) The time of signing. Depending on the signature handler, this
* may be a normal unverified computer time or a time generated in a verifiable
* way from a secure time server.
@@ -617,39 +581,21 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", NULL));
}
- SkPdfDate M() const {
- SkPdfDate ret;
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate M() const;
/** (Optional) The CPU host name or physical location of the signing.
**/
bool has_Location() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Location", "", NULL));
}
- std::string Location() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Location", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Location() const;
/** (Optional) The reason for the signing, such as (I agree...).
**/
bool has_Reason() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Reason", "", NULL));
}
- std::string Reason() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Reason", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Reason() const;
};
#endif // __DEFINED__SkPdfSignatureDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.cpp
new file mode 100644
index 0000000..b6a7e48
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfSoftMaskDictionary_autogen.h"
+
+std::string SkPdfSoftMaskDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfSoftMaskDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfSoftMaskDictionary::G() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfSoftMaskDictionary::BC() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfFunction SkPdfSoftMaskDictionary::getTRAsFunction() const {
+ SkPdfFunction ret = SkPdfFunction();
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+std::string SkPdfSoftMaskDictionary::getTRAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.h
index 73295e0..735a359 100644
--- a/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) A subtype specifying the method to be used in deriving the mask
* values from the transparency group specified by the G entry:
* Alpha Use the group's computed alpha, disregarding its color (see
@@ -551,13 +545,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) A transparency group XObject (see Section 7.5.5, "Transparency
* Group XObjects") to be used as the source of alpha or color values for deriv-
* ing the mask. If the subtype S is Luminosity, the group attributes dictionary
@@ -568,13 +556,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", NULL));
}
- SkPdfStream* G() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* G() const;
/** (Optional) An array of component values specifying the color to be used as
* the backdrop against which to composite the transparency group XObject G.
* This entry is consulted only if the subtype S is Luminosity. The array consists
@@ -587,13 +569,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", NULL));
}
- SkPdfArray* BC() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* BC() const;
/** (Optional) A function object (see Section 3.9, "Functions") specifying the
* transfer function to be used in deriving the mask values. The function ac-
* cepts one input, the computed group alpha or luminosity (depending on the
@@ -613,26 +589,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfFunction getTRAsFunction() const {
- SkPdfFunction ret = SkPdfFunction();
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction getTRAsFunction() const;
bool isTRAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getTRAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getTRAsName() const;
};
#endif // __DEFINED__SkPdfSoftMaskDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.cpp
new file mode 100644
index 0000000..c2fb208
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfSoftMaskImageDictionary_autogen.h"
+
+SkPdfArray* SkPdfSoftMaskImageDictionary::Matte() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matte", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.h
index 4ca3995..259a46b 100644
--- a/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.h
@@ -536,13 +536,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matte", "", NULL));
}
- SkPdfArray* Matte() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matte", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Matte() const;
};
#endif // __DEFINED__SkPdfSoftMaskImageDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.cpp
new file mode 100644
index 0000000..e98c8a0
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfSoundActionDictionary_autogen.h"
+
+std::string SkPdfSoundActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfSoundActionDictionary::Sound() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+double SkPdfSoundActionDictionary::Volume() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+bool SkPdfSoundActionDictionary::Synchronous() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+bool SkPdfSoundActionDictionary::Repeat() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Repeat", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+bool SkPdfSoundActionDictionary::Mix() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mix", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.h
index be04ec6..f300de4 100644
--- a/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) A sound object defining the sound to be played (see Section 8.7,
* "Sounds"; see also implementation note 76 in Appendix H).
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", NULL));
}
- SkPdfStream* Sound() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Sound() const;
/** (Optional) The volume at which to play the sound, in the range -1.0 to 1.0.
* Higher values denote greater volume; negative values mute the sound.
* Default value: 1.0.
@@ -561,13 +549,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", NULL));
}
- double Volume() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double Volume() const;
/** (Optional) A flag specifying whether to play the sound synchronously or
* asynchronously. If this flag is true, the viewer application will retain control,
* allowing no further user interaction other than canceling the sound, until the
@@ -577,13 +559,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", NULL));
}
- bool Synchronous() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool Synchronous() const;
/** (Optional) A flag specifying whether to repeat the sound indefinitely. If this
* entry is present, the Synchronous entry is ignored. Default value: false.
**/
@@ -591,13 +567,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Repeat", "", NULL));
}
- bool Repeat() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Repeat", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool Repeat() const;
/** (Optional) A flag specifying whether to mix this sound with any other sound
* already playing. If this flag is false, any previously playing sound will be
* stopped before starting this sound; this can be used to stop a repeating sound
@@ -607,13 +577,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mix", "", NULL));
}
- bool Mix() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mix", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool Mix() const;
};
#endif // __DEFINED__SkPdfSoundActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..f9ad2bc
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfSoundAnnotationDictionary_autogen.h"
+
+std::string SkPdfSoundAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfSoundAnnotationDictionary::Sound() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfSoundAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfSoundAnnotationDictionary::Name() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.h
index 523ff1d..6e37c87 100644
--- a/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) A sound object defining the sound to be played when the annotation
* is activated (see Section 8.7, "Sounds").
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", NULL));
}
- SkPdfStream* Sound() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Sound() const;
/** (Optional) Text to be displayed in a pop-up window for the annotation in place
* of the sound, useful when extracting the document's contents in support of
* accessibility to disabled users or for other purposes (see Section 9.8.2, "Alternate
@@ -562,13 +550,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Optional) The name of an icon to be used in displaying the annotation. Viewer
* applications should provide predefined icon appearances for at least the stan-
* dard names Speaker and Microphone; additional names may be supported as
@@ -580,13 +562,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
}
- std::string Name() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Name() const;
};
#endif // __DEFINED__SkPdfSoundAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.cpp
new file mode 100644
index 0000000..f05bf22
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfSoundObjectDictionary_autogen.h"
+
+std::string SkPdfSoundObjectDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+double SkPdfSoundObjectDictionary::R() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfSoundObjectDictionary::C() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfSoundObjectDictionary::B() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfSoundObjectDictionary::E() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfSoundObjectDictionary::CO() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfObject* SkPdfSoundObjectDictionary::CP() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CP", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.h
index 09ff7d0..34a40b3 100644
--- a/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.h
@@ -532,26 +532,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The sampling rate, in samples per second.
**/
bool has_R() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", NULL));
}
- double R() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double R() const;
/** (Optional) The number of sound channels. Default value: 1. (See implementation
* note 101 in Appendix H.)
**/
@@ -559,26 +547,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
}
- long C() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long C() const;
/** (Optional) The number of bits per sample value per channel. Default value: 8.
**/
bool has_B() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", NULL));
}
- long B() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long B() const;
/** (Optional) The encoding format for the sample data:
* Raw Unspecified or unsigned values in the range 0 to 2B - 1
* Signed Twos-complement values
@@ -590,13 +566,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", NULL));
}
- std::string E() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string E() const;
/** (Optional) The sound compression format used on the sample data. (Note that this is
* separate from any stream compression specified by the sound object's Filter entry; see
* Table 3.4 on page 38 and Section 3.3, "Filters.") If this entry is absent, then no sound
@@ -607,13 +577,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", NULL));
}
- std::string CO() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string CO() const;
/** (Optional) Optional parameters specific to the sound compression format used.
* Note: At the time of publication, no standard values have been defined for the CO and CP
* entries.
@@ -622,13 +586,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CP", "", NULL));
}
- SkPdfObject* CP() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CP", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* CP() const;
};
#endif // __DEFINED__SkPdfSoundObjectDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.cpp
new file mode 100644
index 0000000..6bf902e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfSourceInformationDictionary_autogen.h"
+
+std::string SkPdfSourceInformationDictionary::getAUAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfSourceInformationDictionary::getAUAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDate SkPdfSourceInformationDictionary::TS() const {
+ SkPdfDate ret;
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
+SkPdfDate SkPdfSourceInformationDictionary::E() const {
+ SkPdfDate ret;
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
+long SkPdfSourceInformationDictionary::S() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfDictionary* SkPdfSourceInformationDictionary::C() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.h
index 27d01d5..83cfb9a 100644
--- a/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.h
@@ -538,26 +538,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getAUAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getAUAsString() const;
bool isAUADictionary() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getAUAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getAUAsDictionary() const;
/** (Optional) A time stamp giving the most recent date and time at which the content
* set's contents were known to be up to date with the source data.
**/
@@ -565,13 +553,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", NULL));
}
- SkPdfDate TS() const {
- SkPdfDate ret;
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate TS() const;
/** (Optional) An expiration stamp giving the date and time at which the content set's
* contents should be considered out of date with the source data.
**/
@@ -579,13 +561,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", NULL));
}
- SkPdfDate E() const {
- SkPdfDate ret;
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate E() const;
/** (Optional) A code indicating the type of form submission, if any, by which the source
* data was accessed (see "Submit-Form Actions" on page 550):
* 0 Not accessed via a form submission
@@ -598,13 +574,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- long S() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long S() const;
/** (Optional; must be an indirect reference) A command dictionary (see "Command Dic-
* tionaries" on page 672) describing the command that caused the source data to be
* retrieved. This entry should be present only in source information dictionaries associ-
@@ -614,13 +584,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
}
- SkPdfDictionary* C() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* C() const;
};
#endif // __DEFINED__SkPdfSourceInformationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.cpp
new file mode 100644
index 0000000..cdf2f68
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfSquareOrCircleAnnotation_autogen.h"
+
+std::string SkPdfSquareOrCircleAnnotation::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfSquareOrCircleAnnotation::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfSquareOrCircleAnnotation::BS() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfSquareOrCircleAnnotation::IC() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.h b/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.h
index 1c746d6..ce9864f 100644
--- a/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) The text to be displayed in the pop-up window when the annotation
* is opened. Carriage returns may be used to separate the text into paragraphs.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Optional) A border style dictionary (see Table 8.12 on page 495) specifying the
* line width and dash pattern to be used in drawing the rectangle or ellipse.
* Note: The annotation dictionary's AP entry, if present, takes precedence over the
@@ -563,13 +551,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", NULL));
}
- SkPdfDictionary* BS() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* BS() const;
/** (Optional; PDF 1.4) An array of three numbers in the range 0.0 to 1.0 specifying
* the components, in the DeviceRGB color space, of the interior color with which to
* fill the annotation's rectangle or ellipse (see Table 8.19). If this entry is absent,
@@ -579,13 +561,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", NULL));
}
- SkPdfArray* IC() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* IC() const;
};
#endif // __DEFINED__SkPdfSquareOrCircleAnnotation
diff --git a/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.cpp
new file mode 100644
index 0000000..d8adbcf
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfStandardSecurityHandlerDictionary_autogen.h"
+
+double SkPdfStandardSecurityHandlerDictionary::R() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfStandardSecurityHandlerDictionary::O() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfStandardSecurityHandlerDictionary::U() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfStandardSecurityHandlerDictionary::P() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.h
index 55ba347..079580c 100644
--- a/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.h
@@ -536,13 +536,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", NULL));
}
- double R() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double R() const;
/** (Required) A 32-byte string, based on both the owner and user passwords, that is used in
* computing the encryption key and in determining whether a valid owner password was
* entered. For more information, see "Encryption Key Algorithm" on page 78 and "Pass-
@@ -552,13 +546,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", NULL));
}
- std::string O() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string O() const;
/** (Required) A 32-byte string, based on the user password, that is used in determining
* whether to prompt the user for a password and, if so, whether a valid user or owner pass-
* word was entered. For more information, see "Password Algorithms" on page 79.
@@ -567,13 +555,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", NULL));
}
- std::string U() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string U() const;
/** (Required) A set of flags specifying which operations are permitted when the document is
* opened with user access (see Table 3.15).
**/
@@ -581,13 +563,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", NULL));
}
- long P() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long P() const;
};
#endif // __DEFINED__SkPdfStandardSecurityHandlerDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.cpp
new file mode 100644
index 0000000..23829b5
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfStandardStructureDictionary_autogen.h"
+
+std::string SkPdfStandardStructureDictionary::Placement() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Placement", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfStandardStructureDictionary::WritingMode() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WritingMode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.h
index 4f08d5e..281ff19 100644
--- a/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.h
@@ -569,13 +569,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Placement", "", NULL));
}
- std::string Placement() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Placement", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Placement() const;
/** (Optional) The directions of layout progression for packing of ILSEs (inline
* progression) and stacking of BLSEs (block progression):
* LrTb Inline progression from left to right; block progression from
@@ -605,13 +599,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WritingMode", "", NULL));
}
- std::string WritingMode() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WritingMode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string WritingMode() const;
};
#endif // __DEFINED__SkPdfStandardStructureDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.cpp
new file mode 100644
index 0000000..5b4b8fb
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.cpp
@@ -0,0 +1,72 @@
+#include "SkPdfStreamCommonDictionary_autogen.h"
+
+long SkPdfStreamCommonDictionary::Length() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfStreamCommonDictionary::getFilterAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfStreamCommonDictionary::getFilterAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfStreamCommonDictionary::getDecodeParmsAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfStreamCommonDictionary::getDecodeParmsAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfFileSpec SkPdfStreamCommonDictionary::F() const {
+ SkPdfFileSpec ret;
+ if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFileSpec();
+}
+
+std::string SkPdfStreamCommonDictionary::getFFilterAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfStreamCommonDictionary::getFFilterAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfStreamCommonDictionary::getFDecodeParmsAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfStreamCommonDictionary::getFDecodeParmsAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.h
index b1f86c5..fddbb6f 100644
--- a/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.h
@@ -536,13 +536,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", NULL));
}
- long Length() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Length() const;
/** (Optional) The name of a filter to be applied in processing the stream
* data found between the keywords stream and endstream, or an array
* of such names. Multiple filters should be specified in the order in
@@ -558,26 +552,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getFilterAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getFilterAsName() const;
bool isFilterAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getFilterAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getFilterAsArray() const;
/** (Optional) A parameter dictionary, or an array of such dictionaries,
* used by the filters specified by Filter. If there is only one filter and that
* filter has parameters, DecodeParms must be set to the filter's parame-
@@ -601,26 +583,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getDecodeParmsAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getDecodeParmsAsDictionary() const;
bool isDecodeParmsAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getDecodeParmsAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getDecodeParmsAsArray() const;
/** (Optional; PDF 1.2) The file containing the stream data. If this entry
* is present, the bytes between stream and endstream are ignored, the
* filters are specified by FFilter rather than Filter, and the filter parame-
@@ -632,13 +602,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- SkPdfFileSpec F() const {
- SkPdfFileSpec ret;
- if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFileSpec();
- }
-
+ SkPdfFileSpec F() const;
/** (Optional; PDF 1.2) The name of a filter to be applied in processing
* the data found in the stream's external file, or an array of such names.
* The same rules apply as for Filter.
@@ -653,26 +617,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getFFilterAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getFFilterAsName() const;
bool isFFilterAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getFFilterAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getFFilterAsArray() const;
/** (Optional; PDF 1.2) A parameter dictionary, or an array of such dic-
* tionaries, used by the filters specified by FFilter. The same rules apply
* as for DecodeParms.
@@ -687,26 +639,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getFDecodeParmsAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getFDecodeParmsAsDictionary() const;
bool isFDecodeParmsAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getFDecodeParmsAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getFDecodeParmsAsArray() const;
};
#endif // __DEFINED__SkPdfStreamCommonDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfStream_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStream_autogen.cpp
new file mode 100644
index 0000000..b1fdd27
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStream_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfStream_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfString_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfString_autogen.cpp
new file mode 100644
index 0000000..a967633
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfString_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfString_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.cpp
new file mode 100644
index 0000000..7db9df2
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfStructureElementAccessDictionary_autogen.h"
+
+long SkPdfStructureElementAccessDictionary::StructParent() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfStructureElementAccessDictionary::StructParents() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.h
index 1dc8bb0..fb868a5 100644
--- a/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", NULL));
}
- long StructParent() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long StructParent() const;
/** (Required for all content streams containing marked-content sequences that are
* structural content items; PDF 1.3) The integer key of this object's entry in the
* structural parent tree.
@@ -550,13 +544,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", NULL));
}
- long StructParents() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long StructParents() const;
};
#endif // __DEFINED__SkPdfStructureElementAccessDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.cpp
new file mode 100644
index 0000000..0126024
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.cpp
@@ -0,0 +1,100 @@
+#include "SkPdfStructureElementDictionary_autogen.h"
+
+std::string SkPdfStructureElementDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfStructureElementDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfStructureElementDictionary::P() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfStructureElementDictionary::ID() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfStructureElementDictionary::Pg() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfObject* SkPdfStructureElementDictionary::K() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfObject* SkPdfStructureElementDictionary::A() const {
+ SkPdfObject* ret;
+ if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfStructureElementDictionary::getCAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfStructureElementDictionary::getCAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfStructureElementDictionary::R() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfStructureElementDictionary::T() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfStructureElementDictionary::Lang() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfStructureElementDictionary::Alt() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alt", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfStructureElementDictionary::ActualText() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ActualText", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.h
index b7b90da..f666dd4 100644
--- a/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The structure type, a name object identifying the nature of the
* structure element and its role within the document, such as a chapter,
* paragraph, or footnote (see Section 9.6.2, "Structure Types"). Names of
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required; must be an indirect reference) The structure element that is the
* immediate parent of this one in the structure hierarchy.
**/
@@ -562,13 +550,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", NULL));
}
- SkPdfDictionary* P() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* P() const;
/** (Optional) The element identifier, a string designating this structure
* element. The string must be unique among all elements in the docu-
* ment's structure hierarchy. The IDTree entry in the structure tree root
@@ -579,13 +561,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
}
- std::string ID() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string ID() const;
/** (Optional; must be an indirect reference) A page object representing a
* page on which some or all of the content items designated by the K entry
* are rendered.
@@ -594,13 +570,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", NULL));
}
- SkPdfDictionary* Pg() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Pg() const;
/** (Optional) The contents of this structure element, which may consist of
* one or more marked-content sequences, PDF objects, and other struc-
* ture elements. The value of this entry may be any of the following:
@@ -618,13 +588,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", NULL));
}
- SkPdfObject* K() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* K() const;
/** (Optional) The attribute object or objects, if any, associated with this
* structure element. Each attribute object is either a dictionary or a
* stream; the value of this entry may be either a single attribute object or
@@ -636,13 +600,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", NULL));
}
- SkPdfObject* A() const {
- SkPdfObject* ret;
- if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfObject* A() const;
/** (Optional) The attribute class or classes, if any, to which this structure
* element belongs. The value of this entry may be either a single class
* name or an array of class names together with their revision numbers
@@ -661,26 +619,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getCAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getCAsName() const;
bool isCAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getCAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getCAsArray() const;
/** (Optional) The current revision number of this structure element (see
* "Attribute Revision Numbers" on page 606). The value must be a non-
* negative integer. Default value: 0.
@@ -689,13 +635,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", NULL));
}
- long R() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long R() const;
/** (Optional) The title of the structure element, a text string representing it
* in human-readable form. The title should characterize the specific struc-
* ture element, such as Chapter 1, rather than merely a generic element
@@ -705,13 +645,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
}
- std::string T() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string T() const;
/** (Optional; PDF 1.4) A language identifier specifying the natural language
* for all text in the structure element except where overridden by language
* specifications for nested structure elements or marked content (see Sec-
@@ -722,13 +656,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", NULL));
}
- std::string Lang() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Lang() const;
/** (Optional) An alternate description of the structure element and its
* children in human-readable form, useful when extracting the docu-
* ment's contents in support of accessibility to disabled users or for other
@@ -738,13 +666,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alt", "", NULL));
}
- std::string Alt() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alt", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Alt() const;
/** (Optional; PDF 1.4) Text that is an exact replacement for the structure
* element and its children. This replacement text (which should apply to
* as small a piece of content as possible) is useful when extracting the doc-
@@ -755,13 +677,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ActualText", "", NULL));
}
- std::string ActualText() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ActualText", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string ActualText() const;
};
#endif // __DEFINED__SkPdfStructureElementDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.cpp
new file mode 100644
index 0000000..b6c9442
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.cpp
@@ -0,0 +1,72 @@
+#include "SkPdfStructureTreeRootDictionary_autogen.h"
+
+std::string SkPdfStructureTreeRootDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfStructureTreeRootDictionary::getKAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfStructureTreeRootDictionary::getKAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfStructureTreeRootDictionary::getIDTreeAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfTree* SkPdfStructureTreeRootDictionary::getIDTreeAsTree() const {
+ SkPdfTree* ret = NULL;
+ if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+double SkPdfStructureTreeRootDictionary::getParentTreeAsNumber() const {
+ double ret = 0;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfTree* SkPdfStructureTreeRootDictionary::getParentTreeAsTree() const {
+ SkPdfTree* ret = NULL;
+ if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfStructureTreeRootDictionary::ParentTreeNextKey() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTreeNextKey", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfDictionary* SkPdfStructureTreeRootDictionary::RoleMap() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RoleMap", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfStructureTreeRootDictionary::ClassMap() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClassMap", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.h
index 83f337e..f722733 100644
--- a/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Optional) The immediate child or children of the structure tree root in
* the structure hierarchy. The value may be either a dictionary represent-
* ing a single structure element or an array of such dictionaries.
@@ -553,26 +547,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getKAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getKAsDictionary() const;
bool isKAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getKAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getKAsArray() const;
/** (Required if any structure elements have element identifiers) A name tree
* that maps element identifiers (see Table 9.10) to the structure elements
* they denote.
@@ -587,26 +569,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getIDTreeAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getIDTreeAsName() const;
bool isIDTreeATree() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfTree* getIDTreeAsTree() const {
- SkPdfTree* ret = NULL;
- if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfTree* getIDTreeAsTree() const;
/** (Required if any structure element contains PDF objects or marked-content
* sequences as content items) A number tree (see Section 3.8.5, "Number
* Trees") used in finding the structure elements to which content items
@@ -635,26 +605,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Real || ret->podofo()->GetDataType() == ePdfDataType_Number;
}
- double getParentTreeAsNumber() const {
- double ret = 0;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double getParentTreeAsNumber() const;
bool isParentTreeATree() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfTree* getParentTreeAsTree() const {
- SkPdfTree* ret = NULL;
- if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfTree* getParentTreeAsTree() const;
/** (Optional) An integer greater than any key in the parent tree, to be used
* as a key for the next entry added to the tree.
**/
@@ -662,13 +620,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTreeNextKey", "", NULL));
}
- long ParentTreeNextKey() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTreeNextKey", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long ParentTreeNextKey() const;
/** (Optional) A dictionary mapping the names of structure types used in
* the document to their approximate equivalents in the set of standard
* structure types (see Section 9.7.4, "Standard Structure Types").
@@ -677,13 +629,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RoleMap", "", NULL));
}
- SkPdfDictionary* RoleMap() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RoleMap", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* RoleMap() const;
/** (Optional) A dictionary mapping name objects designating attribute
* classes to the corresponding attribute objects or arrays of attribute ob-
* jects (see "Attribute Classes" on page 605).
@@ -692,13 +638,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClassMap", "", NULL));
}
- SkPdfDictionary* ClassMap() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClassMap", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* ClassMap() const;
};
#endif // __DEFINED__SkPdfStructureTreeRootDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.cpp
new file mode 100644
index 0000000..0aa92a8
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfSubmitFormActionDictionary_autogen.h"
+
+std::string SkPdfSubmitFormActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfFileSpec SkPdfSubmitFormActionDictionary::F() const {
+ SkPdfFileSpec ret;
+ if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFileSpec();
+}
+
+SkPdfArray* SkPdfSubmitFormActionDictionary::Fields() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfSubmitFormActionDictionary::Flags() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.h
index 178a223..3a7d6a6 100644
--- a/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) A URL file specification (see Section 3.10.4, "URL Speci-
* fications") giving the uniform resource locator (URL) of the script
* at the Web server that will process the submission.
@@ -547,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- SkPdfFileSpec F() const {
- SkPdfFileSpec ret;
- if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFileSpec();
- }
-
+ SkPdfFileSpec F() const;
/** (Optional) An array identifying which fields to include in the sub-
* mission or which to exclude, depending on the setting of the
* Include/Exclude flag in the Flags entry (see Table 8.62). Each ele-
@@ -571,13 +559,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", NULL));
}
- SkPdfArray* Fields() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Fields() const;
/** (Optional; inheritable) A set of flags specifying various characteris-
* tics of the action (see Table 8.62). Default value: 0.
**/
@@ -585,13 +567,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", NULL));
}
- long Flags() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Flags() const;
};
#endif // __DEFINED__SkPdfSubmitFormActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.cpp
new file mode 100644
index 0000000..dbdb373
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfTableAttributesDictionary_autogen.h"
+
+long SkPdfTableAttributesDictionary::RowSpan() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RowSpan", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfTableAttributesDictionary::ColSpan() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColSpan", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.h
index 2fd1fc0..a73508b 100644
--- a/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RowSpan", "", NULL));
}
- long RowSpan() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RowSpan", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long RowSpan() const;
/** (Optional) The number of columns in the enclosing table that are spanned by
* the cell. The cell expands by adding columns in the inline-progression direction
* specified by the table's WritingMode attribute. Default value: 1.
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColSpan", "", NULL));
}
- long ColSpan() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColSpan", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long ColSpan() const;
};
#endif // __DEFINED__SkPdfTableAttributesDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..6b493a6
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfTextAnnotationDictionary_autogen.h"
+
+std::string SkPdfTextAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfTextAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+bool SkPdfTextAnnotationDictionary::Open() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+std::string SkPdfTextAnnotationDictionary::Name() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.h
index a52d7bf..f164423 100644
--- a/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) The text to be displayed in the pop-up window when the annotation
* is opened. Carriage returns may be used to separate the text into paragraphs.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Optional) A flag specifying whether the annotation should initially be displayed
* open. Default value: false (closed).
**/
@@ -560,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", NULL));
}
- bool Open() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool Open() const;
/** (Optional) The name of an icon to be used in displaying the annotation. Viewer
* applications should provide predefined icon appearances for at least the follow-
* ing standard names:
@@ -581,13 +563,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
}
- std::string Name() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Name() const;
};
#endif // __DEFINED__SkPdfTextAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..ca3187c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfTextFieldDictionary_autogen.h"
+
+long SkPdfTextFieldDictionary::MaxLen() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxLen", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.h
index 56c6472..30a7e41 100644
--- a/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.h
@@ -531,13 +531,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxLen", "", NULL));
}
- long MaxLen() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxLen", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long MaxLen() const;
};
#endif // __DEFINED__SkPdfTextFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.cpp
new file mode 100644
index 0000000..8544c8c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfThreadActionDictionary_autogen.h"
+
+std::string SkPdfThreadActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfFileSpec SkPdfThreadActionDictionary::F() const {
+ SkPdfFileSpec ret;
+ if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFileSpec();
+}
+
+SkPdfDictionary* SkPdfThreadActionDictionary::getDAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfThreadActionDictionary::getDAsInteger() const {
+ long ret = 0;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfThreadActionDictionary::getDAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfThreadActionDictionary::getBAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfThreadActionDictionary::getBAsInteger() const {
+ long ret = 0;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.h
index 3158d85..5b5a813 100644
--- a/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Optional) The file containing the desired thread. If this entry is absent, the
* thread is in the current file.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- SkPdfFileSpec F() const {
- SkPdfFileSpec ret;
- if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFileSpec();
- }
-
+ SkPdfFileSpec F() const;
/** (Required) The desired destination thread, specified in one of the following
* forms:
* * An indirect reference to a thread dictionary (see Section 8.3.2, "Articles").
@@ -574,39 +562,21 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getDAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getDAsDictionary() const;
bool isDAInteger() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Number;
}
- long getDAsInteger() const {
- long ret = 0;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long getDAsInteger() const;
bool isDAString() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getDAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getDAsString() const;
/** (Optional) The desired bead in the destination thread, specified in one of the
* following forms:
* * An indirect reference to a bead dictionary (see Section 8.3.2, "Articles"). In
@@ -624,26 +594,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getBAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getBAsDictionary() const;
bool isBAInteger() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Number;
}
- long getBAsInteger() const {
- long ret = 0;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long getBAsInteger() const;
};
#endif // __DEFINED__SkPdfThreadActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.cpp
new file mode 100644
index 0000000..d3e75f8
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfThreadDictionary_autogen.h"
+
+std::string SkPdfThreadDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfThreadDictionary::F() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfThreadDictionary::I() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.h
index 98ccf37..afb1813 100644
--- a/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.h
@@ -532,26 +532,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required; must be an indirect reference) The first bead in the thread.
**/
bool has_F() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- SkPdfDictionary* F() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* F() const;
/** (Optional) A thread information dictionary containing information about the
* thread, such as its title, author, and creation date. The contents of this dictionary are
* similar to those of the document information dictionary (see Section 9.2.1, "Docu-
@@ -561,13 +549,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", NULL));
}
- SkPdfDictionary* I() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* I() const;
};
#endif // __DEFINED__SkPdfThreadDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.cpp
new file mode 100644
index 0000000..dcd16e5
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfTransitionDictionary_autogen.h"
+
+std::string SkPdfTransitionDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+double SkPdfTransitionDictionary::D() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfTransitionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfTransitionDictionary::Dm() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dm", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfTransitionDictionary::M() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+double SkPdfTransitionDictionary::Di() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Di", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.h
index 64cbeb6..e3fa5b5 100644
--- a/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.h
@@ -532,26 +532,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Optional) The duration of the transition effect, in seconds. Default value: 1.
**/
bool has_D() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", NULL));
}
- double D() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double D() const;
/** (Optional) The transition style to use when moving to this page from another during a
* presentation:
* Split Two lines sweep across the screen, revealing the new page. The lines may
@@ -578,13 +566,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Optional; Split and Blinds transition styles only) The dimension in which the specified
* transition effect occurs:
* H Horizontal
@@ -595,13 +577,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dm", "", NULL));
}
- std::string Dm() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dm", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Dm() const;
/** (Optional; Split and Box transition styles only) The direction of motion for the specified
* transition effect:
* I Inward from the edges of the page
@@ -612,13 +588,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", NULL));
}
- std::string M() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string M() const;
/** (Optional; Wipe and Glitter transition styles only) The direction in which the specified
* transition effect moves, expressed in degrees counterclockwise starting from a left-to-
* right direction. (Note that this differs from the page object's Rotate entry, which is
@@ -634,13 +604,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Di", "", NULL));
}
- double Di() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Di", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double Di() const;
};
#endif // __DEFINED__SkPdfTransitionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.cpp
new file mode 100644
index 0000000..cb81161
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfTransparencyGroupDictionary_autogen.h"
+
+std::string SkPdfTransparencyGroupDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfTransparencyGroupDictionary::getCSAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfTransparencyGroupDictionary::getCSAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.h
index e883767..8424b4a 100644
--- a/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Sometimes required, as discussed below) The group color space, which is used for
* the following purposes:
* * As the color space into which colors are converted when painted into the
@@ -581,26 +575,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getCSAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getCSAsName() const;
bool isCSAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getCSAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getCSAsArray() const;
};
#endif // __DEFINED__SkPdfTransparencyGroupDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..e59e974
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfTrapNetworkAnnotationDictionary_autogen.h"
+
+std::string SkPdfTrapNetworkAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfTrapNetworkAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDate SkPdfTrapNetworkAnnotationDictionary::LastModified() const {
+ SkPdfDate ret;
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
+SkPdfArray* SkPdfTrapNetworkAnnotationDictionary::Version() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfTrapNetworkAnnotationDictionary::AnnotStates() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AnnotStates", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfTrapNetworkAnnotationDictionary::FontFauxing() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFauxing", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.h
index 6c7cf0e..79f3cbe 100644
--- a/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Optional; PDF 1.4) An alternate description of the annotation's contents in
* human-readable form, useful when extracting the document's contents in
* support of accessibility to disabled users or for other purposes (see Section
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Required if Version and AnnotStates are absent; must be absent if Version and
* AnnotStates are present; PDF 1.4) The date and time (see Section 3.8.2,
* "Dates") when the trap network was most recently modified.
@@ -563,13 +551,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", NULL));
}
- SkPdfDate LastModified() const {
- SkPdfDate ret;
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate LastModified() const;
/** (Required if AnnotStates is present; must be absent if LastModified is present)
* An unordered array of all objects present in the page description at the time
* the trap networks were generated and that, if changed, could affect the
@@ -588,13 +570,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", NULL));
}
- SkPdfArray* Version() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Version() const;
/** (Required if Version is present; must be absent if LastModified is present) An
* array of name objects representing the appearance states (value of the AS
* entry) for annotations associated with the page. The appearance states must
@@ -607,13 +583,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AnnotStates", "", NULL));
}
- SkPdfArray* AnnotStates() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AnnotStates", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* AnnotStates() const;
/** (Optional) An array of font dictionaries representing fonts that were "fauxed"
* (replaced by substitute fonts) during the generation of trap networks for the
* page.
@@ -622,13 +592,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFauxing", "", NULL));
}
- SkPdfArray* FontFauxing() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFauxing", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* FontFauxing() const;
};
#endif // __DEFINED__SkPdfTrapNetworkAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.cpp
new file mode 100644
index 0000000..729d96c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfTrapNetworkAppearanceStreamDictionary_autogen.h"
+
+std::string SkPdfTrapNetworkAppearanceStreamDictionary::PCM() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PCM", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfTrapNetworkAppearanceStreamDictionary::SeparationColorNames() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationColorNames", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfTrapNetworkAppearanceStreamDictionary::TrapRegions() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapRegions", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfTrapNetworkAppearanceStreamDictionary::TrapStyles() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapStyles", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.h
index 289058c..5b4c745 100644
--- a/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.h
@@ -536,13 +536,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PCM", "", NULL));
}
- std::string PCM() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PCM", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string PCM() const;
/** (Optional) An array of names identifying the colorants that were
* assumed when this network was created; equivalent to the Post-
* Script page device parameter of the same name (see Section 6.2.5 of
@@ -555,13 +549,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationColorNames", "", NULL));
}
- SkPdfArray* SeparationColorNames() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationColorNames", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* SeparationColorNames() const;
/** (Optional) An array of indirect references to TrapRegion objects
* defining the page's trapping zones and the associated trapping
* parameters, as described in Adobe Technical Note #5620, Portable
@@ -575,13 +563,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapRegions", "", NULL));
}
- SkPdfArray* TrapRegions() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapRegions", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* TrapRegions() const;
/** (Optional) A human-readable text string that applications can use
* to describe this trap network to the user (for example, to allow
* switching between trap networks).
@@ -590,13 +572,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapStyles", "", NULL));
}
- std::string TrapStyles() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapStyles", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string TrapStyles() const;
};
#endif // __DEFINED__SkPdfTrapNetworkAppearanceStreamDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.cpp
new file mode 100644
index 0000000..1929a9e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfTrueTypeFontDictionary_autogen.h"
+
+std::string SkPdfTrueTypeFontDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.h
index 8c2297f..c1bb7ef 100644
--- a/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.h
@@ -36,13 +36,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
};
#endif // __DEFINED__SkPdfTrueTypeFontDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.cpp
new file mode 100644
index 0000000..472b903
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfType0FontDictionary_autogen.h"
+
+std::string SkPdfType0FontDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfType0FontDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfType0FontDictionary::BaseFont() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfType0FontDictionary::getEncodingAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfType0FontDictionary::getEncodingAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfType0FontDictionary::DescendantFonts() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DescendantFonts", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfType0FontDictionary::ToUnicode() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.h
index c556575..4cbcd63 100644
--- a/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.h
@@ -49,26 +49,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The type of font; must be Type0 for a Type 0 font.
**/
bool has_Subtype() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required) The PostScript name of the font. In principle, this is an arbitrary
* name, since there is no font program associated directly with a Type 0 font
* dictionary. The conventions described here ensure maximum compatibility
@@ -83,13 +71,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", NULL));
}
- std::string BaseFont() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string BaseFont() const;
/** (Required) The name of a predefined CMap, or a stream containing a CMap
* program, that maps character codes to font numbers and CIDs. If the descen-
* dant is a Type 2 CIDFont whose associated TrueType font program is not em-
@@ -106,26 +88,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getEncodingAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getEncodingAsName() const;
bool isEncodingAStream() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return false;
return ret->podofo()->HasStream();
}
- SkPdfStream* getEncodingAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getEncodingAsStream() const;
/** (Required) An array specifying one or more fonts or CIDFonts that are
* descendants of this composite font. This array is indexed by the font number
* that is obtained by mapping a character code through the CMap specified in
@@ -137,13 +107,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DescendantFonts", "", NULL));
}
- SkPdfArray* DescendantFonts() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DescendantFonts", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* DescendantFonts() const;
/** (Optional) A stream containing a CMap file that maps character codes to
* Unicode values (see Section 5.9, "ToUnicode CMaps").
**/
@@ -151,13 +115,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", NULL));
}
- SkPdfStream* ToUnicode() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* ToUnicode() const;
};
#endif // __DEFINED__SkPdfType0FontDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.cpp
new file mode 100644
index 0000000..c28bbc3
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfType0FunctionDictionary_autogen.h"
+
+SkPdfArray* SkPdfType0FunctionDictionary::Size() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfType0FunctionDictionary::BitsPerSample() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerSample", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType0FunctionDictionary::Order() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Order", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfType0FunctionDictionary::Encode() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfType0FunctionDictionary::Decode() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.h
index a414a47..f14ec53 100644
--- a/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", NULL));
}
- SkPdfArray* Size() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Size() const;
/** (Required) The number of bits used to represent each sample. (If the function
* has multiple output values, each one occupies BitsPerSample bits.) Valid
* values are 1, 2, 4, 8, 12, 16, 24, and 32.
@@ -547,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerSample", "", NULL));
}
- long BitsPerSample() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerSample", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long BitsPerSample() const;
/** (Optional) The order of interpolation between samples. Valid values are 1
* and 3, specifying linear and cubic spline interpolation, respectively. (See im-
* plementation note 26 in Appendix H.) Default value: 1.
@@ -562,13 +550,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Order", "", NULL));
}
- long Order() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Order", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Order() const;
/** (Optional) An array of 2 x m numbers specifying the linear mapping of input
* values into the domain of the function's sample table. Default value:
* [0 (Size0 - 1) 0 (Size1 - 1) ...].
@@ -577,13 +559,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", NULL));
}
- SkPdfArray* Encode() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Encode() const;
/** (Optional) An array of 2 x n numbers specifying the linear mapping of sam-
* ple values into the range appropriate for the function's output values. Default
* value: same as the value of Range.
@@ -592,13 +568,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", NULL));
}
- SkPdfArray* Decode() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Decode() const;
};
#endif // __DEFINED__SkPdfType0FunctionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.cpp
new file mode 100644
index 0000000..3ac7e41
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfType10HalftoneDictionary_autogen.h"
+
+std::string SkPdfType10HalftoneDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfType10HalftoneDictionary::HalftoneType() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfType10HalftoneDictionary::HalftoneName() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfType10HalftoneDictionary::Xsquare() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Xsquare", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType10HalftoneDictionary::Ysquare() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ysquare", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfFunction SkPdfType10HalftoneDictionary::getTransferFunctionAsFunction() const {
+ SkPdfFunction ret = SkPdfFunction();
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+std::string SkPdfType10HalftoneDictionary::getTransferFunctionAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.h
index 30e6215..c993e0f 100644
--- a/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) A code identifying the halftone type that this dictionary
* describes; must be 10 for this type of halftone.
**/
@@ -546,52 +540,28 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", NULL));
}
- long HalftoneType() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long HalftoneType() const;
/** (Optional) The name of the halftone dictionary.
**/
bool has_HalftoneName() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", NULL));
}
- std::string HalftoneName() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string HalftoneName() const;
/** (Required) The side of square X, in device pixels; see below.
**/
bool has_Xsquare() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Xsquare", "", NULL));
}
- long Xsquare() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Xsquare", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Xsquare() const;
/** (Required) The side of square Y, in device pixels; see below.
**/
bool has_Ysquare() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ysquare", "", NULL));
}
- long Ysquare() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ysquare", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Ysquare() const;
/** (Optional) A transfer function, which overrides the current transfer
* function in the graphics state for the same component. This entry is
* required if the dictionary is a component of a type 5 halftone (see
@@ -610,26 +580,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfFunction getTransferFunctionAsFunction() const {
- SkPdfFunction ret = SkPdfFunction();
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction getTransferFunctionAsFunction() const;
bool isTransferFunctionAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getTransferFunctionAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getTransferFunctionAsName() const;
};
#endif // __DEFINED__SkPdfType10HalftoneDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.cpp
new file mode 100644
index 0000000..2cc4180
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.cpp
@@ -0,0 +1,65 @@
+#include "SkPdfType16HalftoneDictionary_autogen.h"
+
+std::string SkPdfType16HalftoneDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfType16HalftoneDictionary::HalftoneType() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfType16HalftoneDictionary::HalftoneName() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfType16HalftoneDictionary::Width() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType16HalftoneDictionary::Height() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType16HalftoneDictionary::Width2() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType16HalftoneDictionary::Height2() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height2", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfFunction SkPdfType16HalftoneDictionary::getTransferFunctionAsFunction() const {
+ SkPdfFunction ret = SkPdfFunction();
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+std::string SkPdfType16HalftoneDictionary::getTransferFunctionAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.h
index 4eacd84..c62b2e5 100644
--- a/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) A code identifying the halftone type that this dictionary
* describes; must be 16 for this type of halftone.
**/
@@ -546,26 +540,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", NULL));
}
- long HalftoneType() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long HalftoneType() const;
/** (Optional) The name of the halftone dictionary.
**/
bool has_HalftoneName() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", NULL));
}
- std::string HalftoneName() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string HalftoneName() const;
/** (Required) The width of the first (or only) rectangle in the threshold
* array, in device pixels.
**/
@@ -573,13 +555,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", NULL));
}
- long Width() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Width() const;
/** (Required) The height of the first (or only) rectangle in the threshold
* array, in device pixels.
**/
@@ -587,13 +563,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", NULL));
}
- long Height() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Height() const;
/** (Optional) The width of the optional second rectangle in the threshold
* array, in device pixels. If this entry is present, the Height2 entry must
* be present as well; if this entry is absent, the Height2 entry must also be
@@ -603,13 +573,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width2", "", NULL));
}
- long Width2() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Width2() const;
/** (Optional) The height of the optional second rectangle in the threshold
* array, in device pixels.
**/
@@ -617,13 +581,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height2", "", NULL));
}
- long Height2() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height2", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Height2() const;
/** (Optional) A transfer function, which overrides the current transfer
* function in the graphics state for the same component. This entry is
* required if the dictionary is a component of a type 5 halftone (see
@@ -642,26 +600,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfFunction getTransferFunctionAsFunction() const {
- SkPdfFunction ret = SkPdfFunction();
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction getTransferFunctionAsFunction() const;
bool isTransferFunctionAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getTransferFunctionAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getTransferFunctionAsName() const;
};
#endif // __DEFINED__SkPdfType16HalftoneDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.cpp
new file mode 100644
index 0000000..319cb55
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.cpp
@@ -0,0 +1,79 @@
+#include "SkPdfType1FontDictionary_autogen.h"
+
+std::string SkPdfType1FontDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfType1FontDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfType1FontDictionary::Name() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfType1FontDictionary::BaseFont() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfType1FontDictionary::FirstChar() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType1FontDictionary::LastChar() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfType1FontDictionary::Widths() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfType1FontDictionary::FontDescriptor() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfType1FontDictionary::getEncodingAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfType1FontDictionary::getEncodingAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfType1FontDictionary::ToUnicode() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.h
index bb5382b..371acc7 100644
--- a/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.h
@@ -40,26 +40,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The type of font; must be Type1 for a Type 1 font.
**/
bool has_Subtype() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required in PDF 1.0; optional otherwise) The name by which this font is ref-
* erenced in the Font subdictionary of the current resource dictionary.
* Note: This entry is obsolescent and its use is no longer recommended. (See
@@ -69,13 +57,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
}
- std::string Name() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Name() const;
/** (Required) The PostScript name of the font. For Type 1 fonts, this is usually
* the value of the FontName entry in the font program; for more information,
* see Section 5.2 of the PostScript Language Reference, Third Edition. The Post-
@@ -87,13 +69,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", NULL));
}
- std::string BaseFont() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string BaseFont() const;
/** (Required except for the standard 14 fonts) The first character code defined in
* the font's Widths array.
**/
@@ -101,13 +77,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", NULL));
}
- long FirstChar() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long FirstChar() const;
/** (Required except for the standard 14 fonts) The last character code defined in
* the font's Widths array.
**/
@@ -115,13 +85,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", NULL));
}
- long LastChar() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long LastChar() const;
/** (Required except for the standard 14 fonts; indirect reference preferred) An array
* of (LastChar - FirstChar + 1) widths, each element being the glyph width for
* the character whose code is FirstChar plus the array index. For character
@@ -137,13 +101,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", NULL));
}
- SkPdfArray* Widths() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Widths() const;
/** (Required except for the standard 14 fonts; must be an indirect reference) A font
* descriptor describing the font's metrics other than its glyph widths (see Sec-
* tion 5.7, "Font Descriptors").
@@ -156,13 +114,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", NULL));
}
- SkPdfDictionary* FontDescriptor() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* FontDescriptor() const;
/** (Optional) A specification of the font's character encoding, if different from
* its built-in encoding. The value of Encoding may be either the name of a pre-
* defined encoding (MacRomanEncoding, MacExpertEncoding, or WinAnsi-
@@ -180,26 +132,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getEncodingAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getEncodingAsName() const;
bool isEncodingADictionary() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getEncodingAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getEncodingAsDictionary() const;
/** (Optional; PDF 1.2) A stream containing a CMap file that maps character
* codes to Unicode values (see Section 5.9, "ToUnicode CMaps").
**/
@@ -207,13 +147,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", NULL));
}
- SkPdfStream* ToUnicode() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* ToUnicode() const;
};
#endif // __DEFINED__SkPdfType1FontDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.cpp
new file mode 100644
index 0000000..dd2736c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.cpp
@@ -0,0 +1,107 @@
+#include "SkPdfType1FormDictionary_autogen.h"
+
+std::string SkPdfType1FormDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfType1FormDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfType1FormDictionary::FormType() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FormType", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfType1FormDictionary::Name() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDate SkPdfType1FormDictionary::LastModified() const {
+ SkPdfDate ret;
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
+SkRect* SkPdfType1FormDictionary::BBox() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkMatrix* SkPdfType1FormDictionary::Matrix() const {
+ SkMatrix* ret;
+ if (SkMatrixFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfResourceDictionary* SkPdfType1FormDictionary::Resources() const {
+ SkPdfResourceDictionary* ret;
+ if (ResourceDictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfType1FormDictionary::Group() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfType1FormDictionary::Ref() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ref", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfType1FormDictionary::Metadata() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfType1FormDictionary::PieceInfo() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfType1FormDictionary::StructParent() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType1FormDictionary::StructParents() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfDictionary* SkPdfType1FormDictionary::OPI() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.h
index e975649..083eb20 100644
--- a/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.h
@@ -37,13 +37,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The type of XObject that this dictionary describes; must be Form
* for a form XObject.
**/
@@ -51,13 +45,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Optional) A code identifying the type of form XObject that this dictionary
* describes. The only valid value defined at the time of publication is 1. Default
* value: 1.
@@ -66,13 +54,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FormType", "", NULL));
}
- long FormType() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FormType", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long FormType() const;
/** (Required in PDF 1.0; optional otherwise) The name by which this form
* XObject is referenced in the XObject subdictionary of the current resource
* dictionary (see Section 3.7.2, "Resource Dictionaries").
@@ -83,13 +65,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
}
- std::string Name() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Name() const;
/** (Required if PieceInfo is present; optional otherwise; PDF 1.3) The date and
* time (see Section 3.8.2, "Dates") when the form XObject's contents were
* most recently modified. If a page-piece dictionary (PieceInfo) is present, the
@@ -101,13 +77,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", NULL));
}
- SkPdfDate LastModified() const {
- SkPdfDate ret;
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate LastModified() const;
/** (Required) An array of four numbers in the form coordinate system (see
* below), giving the coordinates of the left, bottom, right, and top edges,
* respectively, of the form XObject's bounding box. These boundaries are used
@@ -117,13 +87,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", NULL));
}
- SkRect* BBox() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* BBox() const;
/** (Optional) An array of six numbers specifying the form matrix, which maps
* form space into user space (see Section 4.2.3, "Transformation Matrices").
* Default value: the identity matrix [1 0 0 1 0 0].
@@ -132,13 +96,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", NULL));
}
- SkMatrix* Matrix() const {
- SkMatrix* ret;
- if (SkMatrixFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkMatrix* Matrix() const;
/** (Optional but strongly recommended; PDF 1.2) A dictionary specifying any
* resources (such as fonts and images) required by the form XObject (see Sec-
* tion 3.7, "Content Streams and Resources").
@@ -161,13 +119,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", NULL));
}
- SkPdfResourceDictionary* Resources() const {
- SkPdfResourceDictionary* ret;
- if (DictionaryFromDictionary2(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfResourceDictionary* Resources() const;
/** (Optional; PDF 1.4) A group attributes dictionary indicating that the contents
* of the form XObject are to be treated as a group and specifying the attributes
* of that group (see Section 4.9.2, "Group XObjects").
@@ -179,13 +131,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", NULL));
}
- SkPdfDictionary* Group() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Group() const;
/** (Optional; PDF 1.4) A reference dictionary identifying a page to be imported
* from another PDF file, and for which the form XObject serves as a proxy (see
* Section 4.9.3, "Reference XObjects").
@@ -194,13 +140,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ref", "", NULL));
}
- SkPdfDictionary* Ref() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ref", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Ref() const;
/** (Optional; PDF 1.4) A metadata stream containing metadata for the form
* XObject (see Section 9.2.2, "Metadata Streams").
**/
@@ -208,13 +148,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
}
- SkPdfStream* Metadata() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* Metadata() const;
/** (Optional; PDF 1.3) A page-piece dictionary associated with the form
* XObject (see Section 9.4, "Page-Piece Dictionaries").
**/
@@ -222,13 +156,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", NULL));
}
- SkPdfDictionary* PieceInfo() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* PieceInfo() const;
/** (Required if the form XObject is a structural content item; PDF 1.3) The integer
* key of the form XObject's entry in the structural parent tree (see "Finding
* Structure Elements from Content Items" on page 600).
@@ -237,13 +165,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", NULL));
}
- long StructParent() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long StructParent() const;
/** (Required if the form XObject contains marked-content sequences that are struc-
* tural content items; PDF 1.3) The integer key of the form XObject's entry in
* the structural parent tree (see "Finding Structure Elements from Content
@@ -256,13 +178,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", NULL));
}
- long StructParents() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long StructParents() const;
/** (Optional; PDF 1.2) An OPI version dictionary for the form XObject (see
* Section 9.10.6, "Open Prepress Interface (OPI)").
**/
@@ -270,13 +186,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", NULL));
}
- SkPdfDictionary* OPI() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* OPI() const;
};
#endif // __DEFINED__SkPdfType1FormDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.cpp
new file mode 100644
index 0000000..dc756bd
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.cpp
@@ -0,0 +1,72 @@
+#include "SkPdfType1HalftoneDictionary_autogen.h"
+
+std::string SkPdfType1HalftoneDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfType1HalftoneDictionary::HalftoneType() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfType1HalftoneDictionary::HalftoneName() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+double SkPdfType1HalftoneDictionary::Frequency() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Frequency", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+double SkPdfType1HalftoneDictionary::Angle() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Angle", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfFunction SkPdfType1HalftoneDictionary::getSpotFunctionAsFunction() const {
+ SkPdfFunction ret = SkPdfFunction();
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+std::string SkPdfType1HalftoneDictionary::getSpotFunctionAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+bool SkPdfType1HalftoneDictionary::AccurateScreens() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AccurateScreens", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+SkPdfFunction SkPdfType1HalftoneDictionary::getTransferFunctionAsFunction() const {
+ SkPdfFunction ret = SkPdfFunction();
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+std::string SkPdfType1HalftoneDictionary::getTransferFunctionAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.h
index 0f229d9..b70d0cf 100644
--- a/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) A code identifying the halftone type that this dictionary
* describes; must be 1 for this type of halftone.
**/
@@ -546,26 +540,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", NULL));
}
- long HalftoneType() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long HalftoneType() const;
/** (Optional) The name of the halftone dictionary.
**/
bool has_HalftoneName() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", NULL));
}
- std::string HalftoneName() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string HalftoneName() const;
/** (Required) The screen frequency, measured in halftone cells per inch in
* device space.
**/
@@ -573,13 +555,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Frequency", "", NULL));
}
- double Frequency() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Frequency", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double Frequency() const;
/** (Required) The screen angle, in degrees of rotation counterclockwise
* with respect to the device coordinate system. (Note that most output
* devices have left-handed device spaces; on such devices, a counter-
@@ -590,13 +566,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Angle", "", NULL));
}
- double Angle() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Angle", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double Angle() const;
/** (Required) A function object defining the order in which device pixels
* within a screen cell are adjusted for different gray levels, or the name of
* one of the predefined spot functions (see Table 6.1 on page 385).
@@ -611,26 +581,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfFunction getSpotFunctionAsFunction() const {
- SkPdfFunction ret = SkPdfFunction();
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction getSpotFunctionAsFunction() const;
bool isSpotFunctionAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getSpotFunctionAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getSpotFunctionAsName() const;
/** (Optional) A flag specifying whether to invoke a special halftone al-
* gorithm that is extremely precise, but computationally expensive; see
* below for further discussion. Default value: false.
@@ -639,13 +597,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AccurateScreens", "", NULL));
}
- bool AccurateScreens() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AccurateScreens", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool AccurateScreens() const;
/** (Optional) A transfer function, which overrides the current transfer
* function in the graphics state for the same component. This entry is
* required if the dictionary is a component of a type 5 halftone (see
@@ -664,26 +616,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfFunction getTransferFunctionAsFunction() const {
- SkPdfFunction ret = SkPdfFunction();
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction getTransferFunctionAsFunction() const;
bool isTransferFunctionAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getTransferFunctionAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getTransferFunctionAsName() const;
};
#endif // __DEFINED__SkPdfType1HalftoneDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.cpp
new file mode 100644
index 0000000..f2ac93a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfType1PatternDictionary_autogen.h"
+
+std::string SkPdfType1PatternDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfType1PatternDictionary::PatternType() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType1PatternDictionary::PaintType() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PaintType", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.h
index d191df0..4589339 100644
--- a/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) A code identifying the type of pattern that this dictionary de-
* scribes; must be 1 for a tiling pattern.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", NULL));
}
- long PatternType() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long PatternType() const;
/** (Required) A code that determines how the color of the pattern cell is to be
* specified:
* 1 Colored tiling pattern. The pattern's content stream itself specifies the
@@ -569,13 +557,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PaintType", "", NULL));
}
- long PaintType() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PaintType", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long PaintType() const;
};
#endif // __DEFINED__SkPdfType1PatternDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..be4929d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfType1ShadingDictionary_autogen.h"
+
+SkPdfArray* SkPdfType1ShadingDictionary::Domain() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfType1ShadingDictionary::Matrix() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfFunction SkPdfType1ShadingDictionary::Function() const {
+ SkPdfFunction ret;
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.h
index 6d2b740..80f82cf 100644
--- a/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.h
@@ -50,13 +50,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", NULL));
}
- SkPdfArray* Domain() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Domain() const;
/** (Optional) An array of six numbers specifying a transformation matrix mapping
* the coordinate space specified by the Domain entry into the shading's target co-
* ordinate space. For example, to map the domain rectangle [0.0 1.0 0.0 1.0] to a
@@ -68,13 +62,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", NULL));
}
- SkPdfArray* Matrix() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Matrix() const;
/** (Required) A 2-in, n-out function or an array of n 2-in, 1-out functions (where n
* is the number of color components in the shading dictionary's color space).
* Each function's domain must be a superset of that of the shading dictionary. If
@@ -85,13 +73,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", NULL));
}
- SkPdfFunction Function() const {
- SkPdfFunction ret;
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction Function() const;
};
#endif // __DEFINED__SkPdfType1ShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.cpp
new file mode 100644
index 0000000..c57e0f8
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfType2FunctionDictionary_autogen.h"
+
+SkPdfArray* SkPdfType2FunctionDictionary::C0() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C0", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfType2FunctionDictionary::C1() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C1", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+double SkPdfType2FunctionDictionary::N() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.h
index accbfd1..549db11 100644
--- a/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C0", "", NULL));
}
- SkPdfArray* C0() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C0", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* C0() const;
/** (Optional) An array of n numbers defining the function result when x = 1.0 (hence the "1"
* in the name). Default value: [1.0].
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C1", "", NULL));
}
- SkPdfArray* C1() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C1", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* C1() const;
/** (Required) The interpolation exponent. Each input value x will return n values, given by
* yj = C0j + xN x (C1j - C0j ), for 0 <= j < n.
**/
@@ -560,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", NULL));
}
- double N() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double N() const;
};
#endif // __DEFINED__SkPdfType2FunctionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.cpp
new file mode 100644
index 0000000..7f0976f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfType2PatternDictionary_autogen.h"
+
+long SkPdfType2PatternDictionary::Type() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType2PatternDictionary::PatternType() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfDictionary* SkPdfType2PatternDictionary::getShadingAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfType2PatternDictionary::getShadingAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfType2PatternDictionary::Matrix() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfType2PatternDictionary::ExtGState() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.h
index d88fa8a..d97b721 100644
--- a/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- long Type() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Type() const;
/** (Required) A code identifying the type of pattern that this dictionary de-
* scribes; must be 2 for a shading pattern.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", NULL));
}
- long PatternType() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long PatternType() const;
/** (Required) A shading object (see below) defining the shading pattern's gradient
* fill. The contents of the dictionary consist of the entries in Table 4.25 on page
* 234, plus those in one of Tables 4.26 to 4.31 on pages 237 to 253.
@@ -567,26 +555,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getShadingAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getShadingAsDictionary() const;
bool isShadingAStream() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return false;
return ret->podofo()->HasStream();
}
- SkPdfStream* getShadingAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getShadingAsStream() const;
/** (Optional) An array of six numbers specifying the pattern matrix (see Section
* 4.6.1, "General Properties of Patterns"). Default value: the identity matrix
* [1 0 0 1 0 0].
@@ -595,13 +571,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", NULL));
}
- SkPdfArray* Matrix() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Matrix() const;
/** (Optional) A graphics state parameter dictionary (see Section 4.3.4, "Graph-
* ics State Parameter Dictionaries") containing graphics state parameters to be
* put into effect temporarily while the shading pattern is painted. Any parame-
@@ -613,13 +583,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", NULL));
}
- SkPdfDictionary* ExtGState() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* ExtGState() const;
};
#endif // __DEFINED__SkPdfType2PatternDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..b0069d0
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfType2ShadingDictionary_autogen.h"
+
+SkPdfArray* SkPdfType2ShadingDictionary::Coords() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfType2ShadingDictionary::Domain() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfFunction SkPdfType2ShadingDictionary::Function() const {
+ SkPdfFunction ret;
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+SkPdfArray* SkPdfType2ShadingDictionary::Extend() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.h
index 8b5667f..3b91dee 100644
--- a/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.h
@@ -50,13 +50,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", NULL));
}
- SkPdfArray* Coords() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Coords() const;
/** (Optional) An array of two numbers [ t0 t1 ] specifying the limiting values of a
* parametric variable t. The variable is considered to vary linearly between these
* two values as the color gradient varies between the starting and ending points of
@@ -67,13 +61,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", NULL));
}
- SkPdfArray* Domain() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Domain() const;
/** (Required) A 1-in, n-out function or an array of n 1-in, 1-out functions (where n
* is the number of color components in the shading dictionary's color space). The
* function(s) are called with values of the parametric variable t in the domain de-
@@ -85,13 +73,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", NULL));
}
- SkPdfFunction Function() const {
- SkPdfFunction ret;
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction Function() const;
/** (Optional) An array of two boolean values specifying whether to extend the
* shading beyond the starting and ending points of the axis, respectively. Default
* value: [false false].
@@ -100,13 +82,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", NULL));
}
- SkPdfArray* Extend() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Extend() const;
};
#endif // __DEFINED__SkPdfType2ShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.cpp
new file mode 100644
index 0000000..7b413e3
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.cpp
@@ -0,0 +1,93 @@
+#include "SkPdfType3FontDictionary_autogen.h"
+
+std::string SkPdfType3FontDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfType3FontDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfType3FontDictionary::Name() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkRect* SkPdfType3FontDictionary::FontBBox() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkMatrix* SkPdfType3FontDictionary::FontMatrix() const {
+ SkMatrix* ret;
+ if (SkMatrixFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontMatrix", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfType3FontDictionary::CharProcs() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharProcs", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfType3FontDictionary::getEncodingAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfEncodingDictionary* SkPdfType3FontDictionary::getEncodingAsEncodingdictionary() const {
+ SkPdfEncodingDictionary* ret = NULL;
+ if (EncodingDictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+long SkPdfType3FontDictionary::FirstChar() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType3FontDictionary::LastChar() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfType3FontDictionary::Widths() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfType3FontDictionary::Resources() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfType3FontDictionary::ToUnicode() const {
+ SkPdfStream* ret;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.h
index 079930e..0bd04be 100644
--- a/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.h
@@ -40,39 +40,21 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The type of font; must be Type3 for a Type 3 font.
**/
bool has_Subtype() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Required in PDF 1.0; optional otherwise) See Table 5.8 on page 317.
**/
bool has_Name() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
}
- std::string Name() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Name() const;
/** (Required) A rectangle (see Section 3.8.3, "Rectangles"), expressed in the
* glyph coordinate system, specifying the font bounding box. This is the small-
* est rectangle enclosing the shape that would result if all of the glyphs of the
@@ -86,13 +68,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", NULL));
}
- SkRect* FontBBox() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* FontBBox() const;
/** (Required) An array of six numbers specifying the font matrix, mapping
* glyph space to text space (see Section 5.1.3, "Glyph Positioning and
* Metrics"). A common practice is to define glyphs in terms of a 1000-unit
@@ -103,13 +79,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontMatrix", "", NULL));
}
- SkMatrix* FontMatrix() const {
- SkMatrix* ret;
- if (SkMatrixFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontMatrix", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkMatrix* FontMatrix() const;
/** (Required) A dictionary in which each key is a character name and the value
* associated with that key is a content stream that constructs and paints the
* glyph for that character. The stream must include as its first operator either
@@ -121,13 +91,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharProcs", "", NULL));
}
- SkPdfDictionary* CharProcs() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharProcs", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* CharProcs() const;
/** (Required) An encoding dictionary whose Differences array specifies the
* complete character encoding for this font (see Section 5.5.5, "Character
* Encoding"; also see implementation note 46 in Appendix H).
@@ -142,52 +106,28 @@
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getEncodingAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getEncodingAsName() const;
bool isEncodingAEncodingdictionary() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfEncodingDictionary* getEncodingAsEncodingdictionary() const {
- SkPdfEncodingDictionary* ret = NULL;
- if (DictionaryFromDictionary2(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfEncodingDictionary* getEncodingAsEncodingdictionary() const;
/** (Required) The first character code defined in the font's Widths array.
**/
bool has_FirstChar() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", NULL));
}
- long FirstChar() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long FirstChar() const;
/** (Required) The last character code defined in the font's Widths array.
**/
bool has_LastChar() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", NULL));
}
- long LastChar() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long LastChar() const;
/** (Required; indirect reference preferred) An array of (LastChar - FirstChar + 1)
* widths, each element being the glyph width for the character whose code is
* FirstChar plus the array index. For character codes outside the range FirstChar
@@ -202,13 +142,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", NULL));
}
- SkPdfArray* Widths() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Widths() const;
/** (Optional but strongly recommended; PDF 1.2) A list of the named resources,
* such as fonts and images, required by the glyph descriptions in this font (see
* Section 3.7.2, "Resource Dictionaries"). If any glyph descriptions refer to
@@ -220,13 +154,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", NULL));
}
- SkPdfDictionary* Resources() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* Resources() const;
/** (Optional; PDF 1.2) A stream containing a CMap file that maps character
* codes to Unicode values (see Section 5.9, "ToUnicode CMaps").
**/
@@ -234,13 +162,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", NULL));
}
- SkPdfStream* ToUnicode() const {
- SkPdfStream* ret;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* ToUnicode() const;
};
#endif // __DEFINED__SkPdfType3FontDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.cpp
new file mode 100644
index 0000000..6449c31
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfType3FunctionDictionary_autogen.h"
+
+SkPdfArray* SkPdfType3FunctionDictionary::Functions() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Functions", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfType3FunctionDictionary::Bounds() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bounds", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfType3FunctionDictionary::Encode() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.h
index b09b9fa..38451fb 100644
--- a/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Functions", "", NULL));
}
- SkPdfArray* Functions() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Functions", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Functions() const;
/** (Required) An array of k - 1 numbers that, in combination with Domain, define the
* intervals to which each function from the Functions array applies. Bounds elements
* must be in order of increasing value, and each value must be within the domain
@@ -549,13 +543,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bounds", "", NULL));
}
- SkPdfArray* Bounds() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bounds", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Bounds() const;
/** (Required) An array of 2 x k numbers that, taken in pairs, map each subset of the do-
* main defined by Domain and the Bounds array to the domain of the corresponding
* function.
@@ -564,13 +552,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", NULL));
}
- SkPdfArray* Encode() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Encode() const;
};
#endif // __DEFINED__SkPdfType3FunctionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..042cc8f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfType3ShadingDictionary_autogen.h"
+
+SkPdfArray* SkPdfType3ShadingDictionary::Coords() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfType3ShadingDictionary::Domain() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfFunction SkPdfType3ShadingDictionary::Function() const {
+ SkPdfFunction ret;
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+SkPdfArray* SkPdfType3ShadingDictionary::Extend() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.h
index cff6013..68f4891 100644
--- a/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.h
@@ -52,13 +52,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", NULL));
}
- SkPdfArray* Coords() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Coords() const;
/** (Optional) An array of two numbers [ t0 t1 ] specifying the limiting values of a
* parametric variable t. The variable is considered to vary linearly between these
* two values as the color gradient varies between the starting and ending circles.
@@ -69,13 +63,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", NULL));
}
- SkPdfArray* Domain() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Domain() const;
/** (Required) A 1-in, n-out function or an array of n 1-in, 1-out functions (where n
* is the number of color components in the shading dictionary's color space). The
* function(s) are called with values of the parametric variable t in the domain de-
@@ -88,13 +76,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", NULL));
}
- SkPdfFunction Function() const {
- SkPdfFunction ret;
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction Function() const;
/** (Optional) An array of two boolean values specifying whether to extend the
* shading beyond the starting and ending circles, respectively. Default value:
* [false false].
@@ -103,13 +85,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", NULL));
}
- SkPdfArray* Extend() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Extend() const;
};
#endif // __DEFINED__SkPdfType3ShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..671856e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfType4ShadingDictionary_autogen.h"
+
+long SkPdfType4ShadingDictionary::BitsPerCoordinate() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType4ShadingDictionary::BitsPerComponent() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType4ShadingDictionary::BitsPerFlag() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkRect* SkPdfType4ShadingDictionary::Decode() const {
+ SkRect* ret;
+ if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfFunction SkPdfType4ShadingDictionary::Function() const {
+ SkPdfFunction ret;
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.h
index eeb531d..9deff01 100644
--- a/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.h
@@ -49,13 +49,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", NULL));
}
- long BitsPerCoordinate() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long BitsPerCoordinate() const;
/** (Required) The number of bits used to represent each color component.
* Valid values are 1, 2, 4, 8, 12, and 16.
**/
@@ -63,13 +57,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", NULL));
}
- long BitsPerComponent() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long BitsPerComponent() const;
/** (Required) The number of bits used to represent the edge flag for each ver-
* tex (see below). Valid values of BitsPerFlag are 2, 4, and 8, but only the
* least significant 2 bits in each flag value are used. Valid values for the edge
@@ -79,13 +67,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", NULL));
}
- long BitsPerFlag() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long BitsPerFlag() const;
/** (Required) An array of numbers specifying how to map vertex coordinates
* and color components into the appropriate ranges of values. The de-
* coding method is similar to that used in image dictionaries (see "Decode
@@ -98,13 +80,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", NULL));
}
- SkRect* Decode() const {
- SkRect* ret;
- if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkRect* Decode() const;
/** (Optional) A 1-in, n-out function or an array of n 1-in, 1-out functions
* (where n is the number of color components in the shading dictionary's
* color space). If this entry is present, the color data for each vertex must be
@@ -122,13 +98,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", NULL));
}
- SkPdfFunction Function() const {
- SkPdfFunction ret;
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction Function() const;
};
#endif // __DEFINED__SkPdfType4ShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.cpp
new file mode 100644
index 0000000..0d999dc
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.cpp
@@ -0,0 +1,53 @@
+#include "SkPdfType5HalftoneDictionary_autogen.h"
+
+std::string SkPdfType5HalftoneDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+double SkPdfType5HalftoneDictionary::HalftoneType() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfType5HalftoneDictionary::HalftoneName() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+/*
+SkPdfDictionary* SkPdfType5HalftoneDictionary::get[any_colorant_name]AsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfType5HalftoneDictionary::get[any_colorant_name]AsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+*/
+SkPdfDictionary* SkPdfType5HalftoneDictionary::getDefaultAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfStream* SkPdfType5HalftoneDictionary::getDefaultAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.h
index d3b3e77..0179af3 100644
--- a/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) A code identifying the halftone type that this dictionary describes;
* must be 5 for this type of halftone.
**/
@@ -546,26 +540,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", NULL));
}
- double HalftoneType() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double HalftoneType() const;
/** (Optional) The name of the halftone dictionary.
**/
bool has_HalftoneName() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", NULL));
}
- std::string HalftoneName() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string HalftoneName() const;
/** (Required, one per colorant) The halftone corresponding to the colorant or
* color component named by the key. The halftone may be of any type other
* than 5. Note that the key must be a name object; strings are not permitted, as
@@ -582,26 +564,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* get[any_colorant_name]AsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* get[any_colorant_name]AsDictionary() const;
bool is[any_colorant_name]AStream() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return false;
return ret->podofo()->HasStream();
}
- SkPdfStream* get[any_colorant_name]AsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* get[any_colorant_name]AsStream() const;
*/
/** (Required) A halftone to be used for any colorant or color component that
* does not have an entry of its own. The value may not be a type 5 halftone. If
@@ -618,26 +588,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getDefaultAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getDefaultAsDictionary() const;
bool isDefaultAStream() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return false;
return ret->podofo()->HasStream();
}
- SkPdfStream* getDefaultAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getDefaultAsStream() const;
};
#endif // __DEFINED__SkPdfType5HalftoneDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..4ec82d1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfType5ShadingDictionary_autogen.h"
+
+long SkPdfType5ShadingDictionary::BitsPerCoordinate() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType5ShadingDictionary::BitsPerComponent() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType5ShadingDictionary::VerticesPerRow() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "VerticesPerRow", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfType5ShadingDictionary::Decode() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfFunction SkPdfType5ShadingDictionary::Function() const {
+ SkPdfFunction ret;
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.h
index bfed8fb..399e713 100644
--- a/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.h
@@ -49,13 +49,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", NULL));
}
- long BitsPerCoordinate() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long BitsPerCoordinate() const;
/** (Required) The number of bits used to represent each color component.
* Valid values are 1, 2, 4, 8, 12, and 16.
**/
@@ -63,13 +57,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", NULL));
}
- long BitsPerComponent() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long BitsPerComponent() const;
/** (Required) The number of vertices in each row of the lattice; the value
* must be greater than or equal to 2. The number of rows need not be
* specified.
@@ -78,13 +66,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "VerticesPerRow", "", NULL));
}
- long VerticesPerRow() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "VerticesPerRow", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long VerticesPerRow() const;
/** (Required) An array of numbers specifying how to map vertex coordinates
* and color components into the appropriate ranges of values. The de-
* coding method is similar to that used in image dictionaries (see "Decode
@@ -97,13 +79,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", NULL));
}
- SkPdfArray* Decode() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Decode() const;
/** (Optional) A 1-in, n-out function or an array of n 1-in, 1-out functions
* (where n is the number of color components in the shading dictionary's
* color space). If this entry is present, the color data for each vertex must be
@@ -121,13 +97,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", NULL));
}
- SkPdfFunction Function() const {
- SkPdfFunction ret;
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction Function() const;
};
#endif // __DEFINED__SkPdfType5ShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.cpp
new file mode 100644
index 0000000..8f9ecd4
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfType6HalftoneDictionary_autogen.h"
+
+std::string SkPdfType6HalftoneDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfType6HalftoneDictionary::HalftoneType() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfType6HalftoneDictionary::HalftoneName() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfType6HalftoneDictionary::Width() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType6HalftoneDictionary::Height() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfFunction SkPdfType6HalftoneDictionary::getTransferFunctionAsFunction() const {
+ SkPdfFunction ret = SkPdfFunction();
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
+std::string SkPdfType6HalftoneDictionary::getTransferFunctionAsName() const {
+ std::string ret = "";
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.h
index 74dac95..9c68248 100644
--- a/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) A code identifying the halftone type that this dictionary
* describes; must be 6 for this type of halftone.
**/
@@ -546,52 +540,28 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", NULL));
}
- long HalftoneType() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long HalftoneType() const;
/** (Optional) The name of the halftone dictionary.
**/
bool has_HalftoneName() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", NULL));
}
- std::string HalftoneName() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string HalftoneName() const;
/** (Required) The width of the threshold array, in device pixels.
**/
bool has_Width() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", NULL));
}
- long Width() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Width() const;
/** (Required) The height of the threshold array, in device pixels.
**/
bool has_Height() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", NULL));
}
- long Height() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Height() const;
/** (Optional) A transfer function, which overrides the current transfer
* function in the graphics state for the same component. This entry is
* required if the dictionary is a component of a type 5 halftone (see
@@ -610,26 +580,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Reference;
}
- SkPdfFunction getTransferFunctionAsFunction() const {
- SkPdfFunction ret = SkPdfFunction();
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction getTransferFunctionAsFunction() const;
bool isTransferFunctionAName() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Name;
}
- std::string getTransferFunctionAsName() const {
- std::string ret = "";
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getTransferFunctionAsName() const;
};
#endif // __DEFINED__SkPdfType6HalftoneDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..c7fa09e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfType6ShadingDictionary_autogen.h"
+
+long SkPdfType6ShadingDictionary::BitsPerCoordinate() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType6ShadingDictionary::BitsPerComponent() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfType6ShadingDictionary::BitsPerFlag() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfType6ShadingDictionary::Decode() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfFunction SkPdfType6ShadingDictionary::Function() const {
+ SkPdfFunction ret;
+ if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfFunction();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.h
index dfb9fd4..59755ac 100644
--- a/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.h
@@ -49,13 +49,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", NULL));
}
- long BitsPerCoordinate() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long BitsPerCoordinate() const;
/** (Required) The number of bits used to represent each color component.
* Valid values are 1, 2, 4, 8, 12, and 16.
**/
@@ -63,13 +57,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", NULL));
}
- long BitsPerComponent() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long BitsPerComponent() const;
/** (Required) The number of bits used to represent the edge flag for each
* patch (see below). Valid values of BitsPerFlag are 2, 4, and 8, but only the
* least significant 2 bits in each flag value are used. Valid values for the edge
@@ -79,13 +67,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", NULL));
}
- long BitsPerFlag() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long BitsPerFlag() const;
/** (Required) An array of numbers specifying how to map coordinates and
* color components into the appropriate ranges of values. The decoding
* method is similar to that used in image dictionaries (see "Decode Arrays"
@@ -98,13 +80,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", NULL));
}
- SkPdfArray* Decode() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* Decode() const;
/** (Optional) A 1-in, n-out function or an array of n 1-in, 1-out functions
* (where n is the number of color components in the shading dictionary's
* color space). If this entry is present, the color data for each vertex must be
@@ -122,13 +98,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", NULL));
}
- SkPdfFunction Function() const {
- SkPdfFunction ret;
- if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfFunction();
- }
-
+ SkPdfFunction Function() const;
};
#endif // __DEFINED__SkPdfType6ShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.cpp
new file mode 100644
index 0000000..e2bf8cf
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfURIActionDictionary_autogen.h"
+
+std::string SkPdfURIActionDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfURIActionDictionary::URI() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+bool SkPdfURIActionDictionary::IsMap() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IsMap", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.h
index 8b21a61..212969e 100644
--- a/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.h
@@ -532,26 +532,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) The uniform resource identifier to resolve, encoded in 7-bit ASCII.
**/
bool has_URI() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", NULL));
}
- std::string URI() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string URI() const;
/** (Optional) A flag specifying whether to track the mouse position when the URI is re-
* solved (see below). Default value: false.
* This entry applies only to actions triggered by the user's clicking an annotation; it is
@@ -562,13 +550,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IsMap", "", NULL));
}
- bool IsMap() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IsMap", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool IsMap() const;
};
#endif // __DEFINED__SkPdfURIActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.cpp
new file mode 100644
index 0000000..1c10e0b
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfURIDictionary_autogen.h"
+
+std::string SkPdfURIDictionary::Base() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Base", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.h
index a35b94e..be21237 100644
--- a/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.h
@@ -536,13 +536,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Base", "", NULL));
}
- std::string Base() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Base", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Base() const;
};
#endif // __DEFINED__SkPdfURIDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.cpp
new file mode 100644
index 0000000..7368499
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfURLAliasDictionary_autogen.h"
+
+std::string SkPdfURLAliasDictionary::U() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfURLAliasDictionary::C() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.h
index 1360788..93ad7f6 100644
--- a/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.h
@@ -531,13 +531,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", NULL));
}
- std::string U() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string U() const;
/** (Optional) An array of one or more arrays of strings, each representing a chain of URLs
* leading to the common destination specified by U.
**/
@@ -545,13 +539,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
}
- SkPdfArray* C() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* C() const;
};
#endif // __DEFINED__SkPdfURLAliasDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..e927f3c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfVariableTextFieldDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfVariableTextFieldDictionary::DR() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfVariableTextFieldDictionary::DA() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfVariableTextFieldDictionary::Q() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.h
index 5543ca8..29e54a4 100644
--- a/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.h
@@ -535,13 +535,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", NULL));
}
- SkPdfDictionary* DR() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* DR() const;
/** (Required; inheritable) The default appearance string, containing a sequence of valid
* page-content graphics or text state operators defining such properties as the field's text
* size and color.
@@ -550,13 +544,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", NULL));
}
- std::string DA() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string DA() const;
/** (Optional; inheritable) A code specifying the form of quadding (justification) to be
* used in displaying the text:
* 0 Left-justified
@@ -568,13 +556,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", NULL));
}
- long Q() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long Q() const;
};
#endif // __DEFINED__SkPdfVariableTextFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.cpp
new file mode 100644
index 0000000..dac44df
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.cpp
@@ -0,0 +1,86 @@
+#include "SkPdfViewerPreferencesDictionary_autogen.h"
+
+bool SkPdfViewerPreferencesDictionary::HideToolbar() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideToolbar", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+bool SkPdfViewerPreferencesDictionary::HideMenubar() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideMenubar", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+bool SkPdfViewerPreferencesDictionary::HideWindowUI() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideWindowUI", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+bool SkPdfViewerPreferencesDictionary::FitWindow() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FitWindow", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+bool SkPdfViewerPreferencesDictionary::CenterWindow() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CenterWindow", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+bool SkPdfViewerPreferencesDictionary::DisplayDocTitle() const {
+ bool ret;
+ if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DisplayDocTitle", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return false;
+}
+
+std::string SkPdfViewerPreferencesDictionary::NonFullScreenPageMode() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NonFullScreenPageMode", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfViewerPreferencesDictionary::Direction() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Direction", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfViewerPreferencesDictionary::ViewArea() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewArea", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfViewerPreferencesDictionary::ViewClip() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewClip", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfViewerPreferencesDictionary::PrintArea() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintArea", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfViewerPreferencesDictionary::PrintClip() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintClip", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.h
index b604916..0f6a327 100644
--- a/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideToolbar", "", NULL));
}
- bool HideToolbar() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideToolbar", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool HideToolbar() const;
/** (Optional) A flag specifying whether to hide the viewer application's
* menu bar when the document is active. Default value: false.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideMenubar", "", NULL));
}
- bool HideMenubar() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideMenubar", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool HideMenubar() const;
/** (Optional) A flag specifying whether to hide user interface elements in
* the document's window (such as scroll bars and navigation controls),
* leaving only the document's contents displayed. Default value: false.
@@ -561,13 +549,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideWindowUI", "", NULL));
}
- bool HideWindowUI() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideWindowUI", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool HideWindowUI() const;
/** (Optional) A flag specifying whether to resize the document's window to
* fit the size of the first displayed page. Default value: false.
**/
@@ -575,13 +557,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FitWindow", "", NULL));
}
- bool FitWindow() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FitWindow", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool FitWindow() const;
/** (Optional) A flag specifying whether to position the document's window
* in the center of the screen. Default value: false.
**/
@@ -589,13 +565,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CenterWindow", "", NULL));
}
- bool CenterWindow() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CenterWindow", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool CenterWindow() const;
/** (Optional; PDF 1.4) A flag specifying whether the window's title bar
* should display the document title taken from the Title entry of the docu-
* ment information dictionary (see Section 9.2.1, "Document Informa-
@@ -606,13 +576,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DisplayDocTitle", "", NULL));
}
- bool DisplayDocTitle() const {
- bool ret;
- if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DisplayDocTitle", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return false;
- }
-
+ bool DisplayDocTitle() const;
/** (Optional) The document's page mode, specifying how to display the
* document on exiting full-screen mode:
* UseNone Neither document outline nor thumbnail images
@@ -627,13 +591,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NonFullScreenPageMode", "", NULL));
}
- std::string NonFullScreenPageMode() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NonFullScreenPageMode", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string NonFullScreenPageMode() const;
/** (Optional; PDF 1.3) The predominant reading order for text:
* L2R Left to right
* R2L Right to left (including vertical writing systems
@@ -646,13 +604,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Direction", "", NULL));
}
- std::string Direction() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Direction", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Direction() const;
/** (Optional; PDF 1.4) The name of the page boundary representing the
* area of a page to be displayed when viewing the document on the screen.
* The value is the key designating the relevant page boundary in the page
@@ -668,13 +620,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewArea", "", NULL));
}
- std::string ViewArea() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewArea", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string ViewArea() const;
/** (Optional; PDF 1.4) The name of the page boundary to which the con-
* tents of a page are to be clipped when viewing the document on the
* screen. The value is the key designating the relevant page boundary in
@@ -690,13 +636,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewClip", "", NULL));
}
- std::string ViewClip() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewClip", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string ViewClip() const;
/** (Optional; PDF 1.4) The name of the page boundary representing the
* area of a page to be rendered when printing the document. The value is
* the key designating the relevant page boundary in the page object (see
@@ -711,13 +651,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintArea", "", NULL));
}
- std::string PrintArea() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintArea", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string PrintArea() const;
/** (Optional; PDF 1.4) The name of the page boundary to which the con-
* tents of a page are to be clipped when printing the document. The value
* is the key designating the relevant page boundary in the page object (see
@@ -732,13 +666,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintClip", "", NULL));
}
- std::string PrintClip() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintClip", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string PrintClip() const;
};
#endif // __DEFINED__SkPdfViewerPreferencesDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.cpp
new file mode 100644
index 0000000..f09a7b1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.cpp
@@ -0,0 +1,58 @@
+#include "SkPdfWebCaptureCommandDictionary_autogen.h"
+
+std::string SkPdfWebCaptureCommandDictionary::URL() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URL", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfWebCaptureCommandDictionary::L() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+long SkPdfWebCaptureCommandDictionary::F() const {
+ long ret;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+std::string SkPdfWebCaptureCommandDictionary::getPAsString() const {
+ std::string ret = "";
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfStream* SkPdfWebCaptureCommandDictionary::getPAsStream() const {
+ SkPdfStream* ret = NULL;
+ if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfWebCaptureCommandDictionary::CT() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfWebCaptureCommandDictionary::H() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfWebCaptureCommandDictionary::S() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.h
index 4627361..acb84c0 100644
--- a/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.h
@@ -531,13 +531,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URL", "", NULL));
}
- std::string URL() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URL", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string URL() const;
/** (Optional) The number of levels of pages retrieved from the initial URL. Default
* value: 1.
**/
@@ -545,13 +539,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", NULL));
}
- long L() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long L() const;
/** (Optional) A set of flags specifying various characteristics of the command (see
* Table 9.39). Default value: 0.
**/
@@ -559,13 +547,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- long F() const {
- long ret;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long F() const;
/** (Optional) Data that was posted to the URL.
**/
bool has_P() const {
@@ -578,26 +560,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
}
- std::string getPAsString() const {
- std::string ret = "";
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string getPAsString() const;
bool isPAStream() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return false;
return ret->podofo()->HasStream();
}
- SkPdfStream* getPAsStream() const {
- SkPdfStream* ret = NULL;
- if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfStream* getPAsStream() const;
/** (Optional) A content type describing the data posted to the URL. Default value:
* application/x-www-form-urlencoded.
**/
@@ -605,26 +575,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", NULL));
}
- std::string CT() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string CT() const;
/** (Optional) Additional HTTP request headers sent to the URL.
**/
bool has_H() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", NULL));
}
- std::string H() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string H() const;
/** (Optional) A command settings dictionary containing settings used in the con-
* version process (see "Command Settings" on page 674).
**/
@@ -632,13 +590,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- SkPdfDictionary* S() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* S() const;
};
#endif // __DEFINED__SkPdfWebCaptureCommandDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.cpp
new file mode 100644
index 0000000..f0790e6
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfWebCaptureCommandSettingsDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfWebCaptureCommandSettingsDictionary::G() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfWebCaptureCommandSettingsDictionary::C() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.h
index d471d14..ecbff5c 100644
--- a/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", NULL));
}
- SkPdfDictionary* G() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* G() const;
/** (Optional) Settings for specific conversion engines. Each key in this dictionary is the
* internal name of a conversion engine (see below). The associated value is a dictionary
* containing the settings associated with that conversion engine. If the settings for a par-
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
}
- SkPdfDictionary* C() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* C() const;
};
#endif // __DEFINED__SkPdfWebCaptureCommandSettingsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.cpp
new file mode 100644
index 0000000..0892588
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.cpp
@@ -0,0 +1,58 @@
+#include "SkPdfWebCaptureDictionary_autogen.h"
+
+std::string SkPdfWebCaptureDictionary::Type() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfWebCaptureDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfWebCaptureDictionary::ID() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfArray* SkPdfWebCaptureDictionary::O() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfDictionary* SkPdfWebCaptureDictionary::getSIAsDictionary() const {
+ SkPdfDictionary* ret = NULL;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+SkPdfArray* SkPdfWebCaptureDictionary::getSIAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
+std::string SkPdfWebCaptureDictionary::CT() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDate SkPdfWebCaptureDictionary::TS() const {
+ SkPdfDate ret;
+ if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return SkPdfDate();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.h
index 2460a7a..c87963e 100644
--- a/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
}
- std::string Type() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Type() const;
/** (Required) The subtype of content set that this dictionary describes:
* SPS ("Spider page set") A page set
* SIS ("Spider image set") An image set
@@ -547,13 +541,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) The digital identifier of the content set (see "Digital Identifiers" on page
* 664). If the content set has been located via the URLS name tree, this allows its related
* entry in the IDS name tree to be found.
@@ -562,13 +550,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
}
- std::string ID() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string ID() const;
/** (Required) An array of indirect references to the objects belonging to the content set.
* The order of objects in the array is undefined in general, but may be restricted by spe-
* cific content set subtypes.
@@ -577,13 +559,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", NULL));
}
- SkPdfArray* O() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* O() const;
/** (Required) A source information dictionary (see Section 9.9.4, "Source Information"),
* or an array of such dictionaries, describing the sources from which the objects belong-
* ing to the content set were created.
@@ -598,26 +574,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
}
- SkPdfDictionary* getSIAsDictionary() const {
- SkPdfDictionary* ret = NULL;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* getSIAsDictionary() const;
bool isSIAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getSIAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getSIAsArray() const;
/** (Optional) The content type, a string characterizing the source from which the objects
* belonging to the content set were created. The string should conform to the content
* type specification described in Internet RFC 2045, Multipurpose Internet Mail Exten-
@@ -629,26 +593,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", NULL));
}
- std::string CT() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string CT() const;
/** (Optional) A time stamp giving the date and time at which the content set was created.
**/
bool has_TS() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", NULL));
}
- SkPdfDate TS() const {
- SkPdfDate ret;
- if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return SkPdfDate();
- }
-
+ SkPdfDate TS() const;
};
#endif // __DEFINED__SkPdfWebCaptureDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.cpp
new file mode 100644
index 0000000..db2c429
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfWebCaptureImageSetDictionary_autogen.h"
+
+std::string SkPdfWebCaptureImageSetDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+long SkPdfWebCaptureImageSetDictionary::getRAsInteger() const {
+ long ret = 0;
+ if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfWebCaptureImageSetDictionary::getRAsArray() const {
+ SkPdfArray* ret = NULL;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.h
index 287def7..ee23a8e 100644
--- a/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Required) The reference counts (see below) for the image XObjects belonging to the
* image set. For an image set containing a single XObject, the value is simply the integer
* reference count for that XObject. If the image set contains multiple XObjects, the value is
@@ -556,26 +550,14 @@
return ret->podofo()->GetDataType() == ePdfDataType_Number;
}
- long getRAsInteger() const {
- long ret = 0;
- if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ long getRAsInteger() const;
bool isRAArray() const {
SkPdfObject* ret = NULL;
if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return false;
return ret->podofo()->GetDataType() == ePdfDataType_Array;
}
- SkPdfArray* getRAsArray() const {
- SkPdfArray* ret = NULL;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* getRAsArray() const;
};
#endif // __DEFINED__SkPdfWebCaptureImageSetDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.cpp
new file mode 100644
index 0000000..dec583d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfWebCaptureInformationDictionary_autogen.h"
+
+double SkPdfWebCaptureInformationDictionary::V() const {
+ double ret;
+ if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return 0;
+}
+
+SkPdfArray* SkPdfWebCaptureInformationDictionary::C() const {
+ SkPdfArray* ret;
+ if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.h
index d8593a0..c94f93f 100644
--- a/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.h
@@ -533,13 +533,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
}
- double V() const {
- double ret;
- if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return 0;
- }
-
+ double V() const;
/** (Optional) An array of indirect references to Web Capture command dictionaries (see
* "Command Dictionaries" on page 672) describing commands that were used in building
* the PDF file. The commands appear in the array in the order in which they were executed
@@ -549,13 +543,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
}
- SkPdfArray* C() const {
- SkPdfArray* ret;
- if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfArray* C() const;
};
#endif // __DEFINED__SkPdfWebCaptureInformationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.cpp
new file mode 100644
index 0000000..ba6b144
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfWebCapturePageSetDictionary_autogen.h"
+
+std::string SkPdfWebCapturePageSetDictionary::S() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfWebCapturePageSetDictionary::T() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfWebCapturePageSetDictionary::TID() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TID", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.h
index 41c46d6..f5fc327 100644
--- a/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
}
- std::string S() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string S() const;
/** (Optional) The title of the page set, a text string representing it in human-readable
* form.
**/
@@ -546,13 +540,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
}
- std::string T() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string T() const;
/** (Optional) A text identifier generated from the text of the page set, as described in
* "Digital Identifiers" on page 664.
**/
@@ -560,13 +548,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TID", "", NULL));
}
- std::string TID() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TID", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string TID() const;
};
#endif // __DEFINED__SkPdfWebCapturePageSetDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..db8bbed
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfWidgetAnnotationDictionary_autogen.h"
+
+std::string SkPdfWidgetAnnotationDictionary::Subtype() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfWidgetAnnotationDictionary::Contents() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfWidgetAnnotationDictionary::H() const {
+ std::string ret;
+ if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+SkPdfDictionary* SkPdfWidgetAnnotationDictionary::MK() const {
+ SkPdfDictionary* ret;
+ if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MK", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.h
index ebe48fc..0a4d360 100644
--- a/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
}
- std::string Subtype() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Subtype() const;
/** (Optional; PDF 1.4) An alternate representation of the annotation's contents in
* human-readable form, useful when extracting the document's contents in sup-
* port of accessibility to disabled users or for other purposes (see Section 9.8.2,
@@ -548,13 +542,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
}
- std::string Contents() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string Contents() const;
/** (Optional) The annotation's highlighting mode, the visual effect to be used when
* the mouse button is pressed or held down inside its active area:
* N (None) No highlighting.
@@ -572,13 +560,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", NULL));
}
- std::string H() const {
- std::string ret;
- if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string H() const;
/** (Optional) An appearance characteristics dictionary to be used in constructing a
* dynamic appearance stream specifying the annotation's visual presentation on
* the page; see "Variable Text" on page 533 for further discussion.
@@ -589,13 +571,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MK", "", NULL));
}
- SkPdfDictionary* MK() const {
- SkPdfDictionary* ret;
- if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MK", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return NULL;
- }
-
+ SkPdfDictionary* MK() const;
};
#endif // __DEFINED__SkPdfWidgetAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.cpp
new file mode 100644
index 0000000..838e2be
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfWindowsLaunchActionDictionary_autogen.h"
+
+std::string SkPdfWindowsLaunchActionDictionary::F() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfWindowsLaunchActionDictionary::D() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfWindowsLaunchActionDictionary::O() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
+std::string SkPdfWindowsLaunchActionDictionary::P() const {
+ std::string ret;
+ if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+ // TODO(edisonn): warn about missing required field, assert for known good pdfs
+ return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.h
index c1bce3e..b3fe9e1 100644
--- a/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.h
@@ -535,26 +535,14 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
}
- std::string F() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string F() const;
/** (Optional) A string specifying the default directory in standard DOS syntax.
**/
bool has_D() const {
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", NULL));
}
- std::string D() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string D() const;
/** (Optional) A string specifying the operation to perform:
* open Open a document.
* print Print a document.
@@ -565,13 +553,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", NULL));
}
- std::string O() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string O() const;
/** (Optional) A parameter string to be passed to the application designated by
* the F entry. This entry should be omitted if F designates a document.
**/
@@ -579,13 +561,7 @@
return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", NULL));
}
- std::string P() const {
- std::string ret;
- if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
- // TODO(edisonn): warn about missing required field, assert for known good pdfs
- return "";
- }
-
+ std::string P() const;
};
#endif // __DEFINED__SkPdfWindowsLaunchActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfXObjectDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfXObjectDictionary_autogen.cpp
new file mode 100644
index 0000000..ef58c4f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfXObjectDictionary_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfXObjectDictionary_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/pdfspec_autogen.py b/experimental/PdfViewer/autogen/pdfspec_autogen.py
index 9e1dbd9..f43c848 100644
--- a/experimental/PdfViewer/autogen/pdfspec_autogen.py
+++ b/experimental/PdfViewer/autogen/pdfspec_autogen.py
@@ -5412,168 +5412,168 @@
def addDictionaryTypesTo(knowTypes):
- knowTypes['GoToActionDictionary'] = ['SkPdfGoToActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['SoundObjectDictionary'] = ['SkPdfSoundObjectDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['LaunchActionDictionary'] = ['SkPdfLaunchActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['RemoteGoToActionDictionary'] = ['SkPdfRemoteGoToActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['PageObjectActionsDictionary'] = ['SkPdfPageObjectActionsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['AnnotationActionsDictionary'] = ['SkPdfAnnotationActionsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['DocumentCatalogActionsDictionary'] = ['SkPdfDocumentCatalogActionsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FormFieldActionsDictionary'] = ['SkPdfFormFieldActionsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['JavascriptDictionary'] = ['SkPdfJavascriptDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['EncryptedEmbeddedFileStreamDictionary'] = ['SkPdfEncryptedEmbeddedFileStreamDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['IconFitDictionary'] = ['SkPdfIconFitDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FDFFieldDictionary'] = ['SkPdfFDFFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ThreadActionDictionary'] = ['SkPdfThreadActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['WindowsLaunchActionDictionary'] = ['SkPdfWindowsLaunchActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FileAttachmentAnnotationDictionary'] = ['SkPdfFileAttachmentAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FDFNamedPageReferenceDictionary'] = ['SkPdfFDFNamedPageReferenceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FileTrailerDictionary'] = ['SkPdfFileTrailerDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['EncryptionCommonDictionary'] = ['SkPdfEncryptionCommonDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Jbig2DecodeFilterDictionary'] = ['SkPdfJbig2DecodeFilterDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['DctdecodeFilterDictionary'] = ['SkPdfDctdecodeFilterDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['CatalogDictionary'] = ['SkPdfCatalogDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['PageTreeNodeDictionary'] = ['SkPdfPageTreeNodeDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['StandardSecurityHandlerDictionary'] = ['SkPdfStandardSecurityHandlerDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['PageObjectDictionary'] = ['SkPdfPageObjectDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['NameDictionary'] = ['SkPdfNameDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['VariableTextFieldDictionary'] = ['SkPdfVariableTextFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ObjectReferenceDictionary'] = ['SkPdfObjectReferenceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['TrapNetworkAppearanceStreamDictionary'] = ['SkPdfTrapNetworkAppearanceStreamDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ImageDictionary'] = ['SkPdfImageDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['OpiVersionDictionary'] = ['SkPdfOpiVersionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type1FontDictionary'] = ['SkPdfType1FontDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type3FontDictionary'] = ['SkPdfType3FontDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['EncodingDictionary'] = ['SkPdfEncodingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['CIDSystemInfoDictionary'] = ['SkPdfCIDSystemInfoDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['CIDFontDictionary'] = ['SkPdfCIDFontDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['CMapDictionary'] = ['SkPdfCMapDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type0FontDictionary'] = ['SkPdfType0FontDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FontDescriptorDictionary'] = ['SkPdfFontDescriptorDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ResetFormActionDictionary'] = ['SkPdfResetFormActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FDFPageDictionary'] = ['SkPdfFDFPageDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ChoiceFieldDictionary'] = ['SkPdfChoiceFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['StructureElementAccessDictionary'] = ['SkPdfStructureElementAccessDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['CalgrayColorSpaceDictionary'] = ['SkPdfCalgrayColorSpaceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['WebCaptureCommandDictionary'] = ['SkPdfWebCaptureCommandDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['IccProfileStreamDictionary'] = ['SkPdfIccProfileStreamDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['LabColorSpaceDictionary'] = ['SkPdfLabColorSpaceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['CalrgbColorSpaceDictionary'] = ['SkPdfCalrgbColorSpaceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['HideActionDictionary'] = ['SkPdfHideActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FDFTemplateDictionary'] = ['SkPdfFDFTemplateDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['NamedActionsDictionary'] = ['SkPdfNamedActionsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['InteractiveFormDictionary'] = ['SkPdfInteractiveFormDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['URIActionDictionary'] = ['SkPdfURIActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['URIDictionary'] = ['SkPdfURIDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['SoundActionDictionary'] = ['SkPdfSoundActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['MovieActionDictionary'] = ['SkPdfMovieActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['SourceInformationDictionary'] = ['SkPdfSourceInformationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FDFFileAnnotationDictionary'] = ['SkPdfFDFFileAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['TransitionDictionary'] = ['SkPdfTransitionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['BeadDictionary'] = ['SkPdfBeadDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ThreadDictionary'] = ['SkPdfThreadDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['PageLabelDictionary'] = ['SkPdfPageLabelDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['OutlineItemDictionary'] = ['SkPdfOutlineItemDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['OutlineDictionary'] = ['SkPdfOutlineDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ViewerPreferencesDictionary'] = ['SkPdfViewerPreferencesDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['MarkInformationDictionary'] = ['SkPdfMarkInformationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['URLAliasDictionary'] = ['SkPdfURLAliasDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['WebCaptureDictionary'] = ['SkPdfWebCaptureDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['AttributeObjectDictionary'] = ['SkPdfAttributeObjectDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ArtifactsDictionary'] = ['SkPdfArtifactsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['WebCaptureInformationDictionary'] = ['SkPdfWebCaptureInformationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['TrapNetworkAnnotationDictionary'] = ['SkPdfTrapNetworkAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type1FormDictionary'] = ['SkPdfType1FormDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['GroupAttributesDictionary'] = ['SkPdfGroupAttributesDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ReferenceDictionary'] = ['SkPdfReferenceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['PSXobjectDictionary'] = ['SkPdfPSXobjectDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['BoxStyleDictionary'] = ['SkPdfBoxStyleDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['BoxColorInformationDictionary'] = ['SkPdfBoxColorInformationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['WebCaptureCommandSettingsDictionary'] = ['SkPdfWebCaptureCommandSettingsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['InlineLevelStructureElementsDictionary'] = ['SkPdfInlineLevelStructureElementsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['AppearanceCharacteristicsDictionary'] = ['SkPdfAppearanceCharacteristicsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type3ShadingDictionary'] = ['SkPdfType3ShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type4ShadingDictionary'] = ['SkPdfType4ShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['TextFieldDictionary'] = ['SkPdfTextFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['RadioButtonFieldDictionary'] = ['SkPdfRadioButtonFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['CheckboxFieldDictionary'] = ['SkPdfCheckboxFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type1PatternDictionary'] = ['SkPdfType1PatternDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type2PatternDictionary'] = ['SkPdfType2PatternDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['DeviceNColorSpaceDictionary'] = ['SkPdfDeviceNColorSpaceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type1ShadingDictionary'] = ['SkPdfType1ShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type2ShadingDictionary'] = ['SkPdfType2ShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['StandardStructureDictionary'] = ['SkPdfStandardStructureDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ShadingDictionary'] = ['SkPdfShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['EmbeddedFileParameterDictionary'] = ['SkPdfEmbeddedFileParameterDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['MacOsFileInformationDictionary'] = ['SkPdfMacOsFileInformationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['WebCaptureImageSetDictionary'] = ['SkPdfWebCaptureImageSetDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['GraphicsStateDictionary'] = ['SkPdfGraphicsStateDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FileSpecificationDictionary'] = ['SkPdfFileSpecificationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['EmbeddedFileStreamDictionary'] = ['SkPdfEmbeddedFileStreamDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['MovieDictionary'] = ['SkPdfMovieDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FieldDictionary'] = ['SkPdfFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['MovieActivationDictionary'] = ['SkPdfMovieActivationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['TableAttributesDictionary'] = ['SkPdfTableAttributesDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ListAttributeDictionary'] = ['SkPdfListAttributeDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['SeparationDictionary'] = ['SkPdfSeparationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['BlockLevelStructureElementsDictionary'] = ['SkPdfBlockLevelStructureElementsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FDFCatalogDictionary'] = ['SkPdfFDFCatalogDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type1HalftoneDictionary'] = ['SkPdfType1HalftoneDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type10HalftoneDictionary'] = ['SkPdfType10HalftoneDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type6HalftoneDictionary'] = ['SkPdfType6HalftoneDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type5HalftoneDictionary'] = ['SkPdfType5HalftoneDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type16HalftoneDictionary'] = ['SkPdfType16HalftoneDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type6ShadingDictionary'] = ['SkPdfType6ShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['StreamCommonDictionary'] = ['SkPdfStreamCommonDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FDFDictionary'] = ['SkPdfFDFDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['LzwdecodeAndFlatedecodeFiltersDictionary'] = ['SkPdfLzwdecodeAndFlatedecodeFiltersDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['CcittfaxdecodeFilterDictionary'] = ['SkPdfCcittfaxdecodeFilterDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['MarkedContentReferenceDictionary'] = ['SkPdfMarkedContentReferenceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['SignatureDictionary'] = ['SkPdfSignatureDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['SoundAnnotationDictionary'] = ['SkPdfSoundAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['MovieAnnotationDictionary'] = ['SkPdfMovieAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type3FunctionDictionary'] = ['SkPdfType3FunctionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type2FunctionDictionary'] = ['SkPdfType2FunctionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['RubberStampAnnotationDictionary'] = ['SkPdfRubberStampAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['InkAnnotationDictionary'] = ['SkPdfInkAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['SquareOrCircleAnnotation'] = ['SkPdfSquareOrCircleAnnotation*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['MarkupAnnotationsDictionary'] = ['SkPdfMarkupAnnotationsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['NameTreeNodeDictionary'] = ['SkPdfNameTreeNodeDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type5ShadingDictionary'] = ['SkPdfType5ShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ResourceDictionary'] = ['SkPdfResourceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['SubmitFormActionDictionary'] = ['SkPdfSubmitFormActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['Type0FunctionDictionary'] = ['SkPdfType0FunctionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FunctionCommonDictionary'] = ['SkPdfFunctionCommonDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['NumberTreeNodeDictionary'] = ['SkPdfNumberTreeNodeDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ActionDictionary'] = ['SkPdfActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['WidgetAnnotationDictionary'] = ['SkPdfWidgetAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['StructureTreeRootDictionary'] = ['SkPdfStructureTreeRootDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['JavascriptActionDictionary'] = ['SkPdfJavascriptActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['AlternateImageDictionary'] = ['SkPdfAlternateImageDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['PDF_XOutputIntentDictionary'] = ['SkPdfPDF_XOutputIntentDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['DocumentInformationDictionary'] = ['SkPdfDocumentInformationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['MetadataStreamDictionary'] = ['SkPdfMetadataStreamDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ImportDataActionDictionary'] = ['SkPdfImportDataActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['PagePieceDictionary'] = ['SkPdfPagePieceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ApplicationDataDictionary'] = ['SkPdfApplicationDataDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ComponentsWithMetadataDictionary'] = ['SkPdfComponentsWithMetadataDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['PrinterMarkFormDictionary'] = ['SkPdfPrinterMarkFormDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['StructureElementDictionary'] = ['SkPdfStructureElementDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['PrinterMarkAnnotationDictionary'] = ['SkPdfPrinterMarkAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['SoftMaskImageDictionary'] = ['SkPdfSoftMaskImageDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['TransparencyGroupDictionary'] = ['SkPdfTransparencyGroupDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['SoftMaskDictionary'] = ['SkPdfSoftMaskDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['BorderStyleDictionary'] = ['SkPdfBorderStyleDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['PopUpAnnotationDictionary'] = ['SkPdfPopUpAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FDFTrailerDictionary'] = ['SkPdfFDFTrailerDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['LineAnnotationDictionary'] = ['SkPdfLineAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['FreeTextAnnotationDictionary'] = ['SkPdfFreeTextAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['ALinkAnnotationDictionary'] = ['SkPdfALinkAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['TextAnnotationDictionary'] = ['SkPdfTextAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['WebCapturePageSetDictionary'] = ['SkPdfWebCapturePageSetDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['AppearanceDictionary'] = ['SkPdfAppearanceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['CIDFontDescriptorDictionary'] = ['SkPdfCIDFontDescriptorDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['EmbeddedFontStreamDictionary'] = ['SkPdfEmbeddedFontStreamDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
- knowTypes['AnnotationDictionary'] = ['SkPdfAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['GoToActionDictionary'] = ['SkPdfGoToActionDictionary*', 'GoToActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['SoundObjectDictionary'] = ['SkPdfSoundObjectDictionary*', 'SoundObjectDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['LaunchActionDictionary'] = ['SkPdfLaunchActionDictionary*', 'LaunchActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['RemoteGoToActionDictionary'] = ['SkPdfRemoteGoToActionDictionary*', 'RemoteGoToActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['PageObjectActionsDictionary'] = ['SkPdfPageObjectActionsDictionary*', 'PageObjectActionsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['AnnotationActionsDictionary'] = ['SkPdfAnnotationActionsDictionary*', 'AnnotationActionsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['DocumentCatalogActionsDictionary'] = ['SkPdfDocumentCatalogActionsDictionary*', 'DocumentCatalogActionsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FormFieldActionsDictionary'] = ['SkPdfFormFieldActionsDictionary*', 'FormFieldActionsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['JavascriptDictionary'] = ['SkPdfJavascriptDictionary*', 'JavascriptDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['EncryptedEmbeddedFileStreamDictionary'] = ['SkPdfEncryptedEmbeddedFileStreamDictionary*', 'EncryptedEmbeddedFileStreamDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['IconFitDictionary'] = ['SkPdfIconFitDictionary*', 'IconFitDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FDFFieldDictionary'] = ['SkPdfFDFFieldDictionary*', 'FDFFieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ThreadActionDictionary'] = ['SkPdfThreadActionDictionary*', 'ThreadActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['WindowsLaunchActionDictionary'] = ['SkPdfWindowsLaunchActionDictionary*', 'WindowsLaunchActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FileAttachmentAnnotationDictionary'] = ['SkPdfFileAttachmentAnnotationDictionary*', 'FileAttachmentAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FDFNamedPageReferenceDictionary'] = ['SkPdfFDFNamedPageReferenceDictionary*', 'FDFNamedPageReferenceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FileTrailerDictionary'] = ['SkPdfFileTrailerDictionary*', 'FileTrailerDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['EncryptionCommonDictionary'] = ['SkPdfEncryptionCommonDictionary*', 'EncryptionCommonDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Jbig2DecodeFilterDictionary'] = ['SkPdfJbig2DecodeFilterDictionary*', 'Jbig2DecodeFilterDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['DctdecodeFilterDictionary'] = ['SkPdfDctdecodeFilterDictionary*', 'DctdecodeFilterDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['CatalogDictionary'] = ['SkPdfCatalogDictionary*', 'CatalogDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['PageTreeNodeDictionary'] = ['SkPdfPageTreeNodeDictionary*', 'PageTreeNodeDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['StandardSecurityHandlerDictionary'] = ['SkPdfStandardSecurityHandlerDictionary*', 'StandardSecurityHandlerDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['PageObjectDictionary'] = ['SkPdfPageObjectDictionary*', 'PageObjectDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['NameDictionary'] = ['SkPdfNameDictionary*', 'NameDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['VariableTextFieldDictionary'] = ['SkPdfVariableTextFieldDictionary*', 'VariableTextFieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ObjectReferenceDictionary'] = ['SkPdfObjectReferenceDictionary*', 'ObjectReferenceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['TrapNetworkAppearanceStreamDictionary'] = ['SkPdfTrapNetworkAppearanceStreamDictionary*', 'TrapNetworkAppearanceStreamDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ImageDictionary'] = ['SkPdfImageDictionary*', 'ImageDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['OpiVersionDictionary'] = ['SkPdfOpiVersionDictionary*', 'OpiVersionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type1FontDictionary'] = ['SkPdfType1FontDictionary*', 'Type1FontDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type3FontDictionary'] = ['SkPdfType3FontDictionary*', 'Type3FontDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['EncodingDictionary'] = ['SkPdfEncodingDictionary*', 'EncodingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['CIDSystemInfoDictionary'] = ['SkPdfCIDSystemInfoDictionary*', 'CIDSystemInfoDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['CIDFontDictionary'] = ['SkPdfCIDFontDictionary*', 'CIDFontDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['CMapDictionary'] = ['SkPdfCMapDictionary*', 'CMapDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type0FontDictionary'] = ['SkPdfType0FontDictionary*', 'Type0FontDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FontDescriptorDictionary'] = ['SkPdfFontDescriptorDictionary*', 'FontDescriptorDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ResetFormActionDictionary'] = ['SkPdfResetFormActionDictionary*', 'ResetFormActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FDFPageDictionary'] = ['SkPdfFDFPageDictionary*', 'FDFPageDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ChoiceFieldDictionary'] = ['SkPdfChoiceFieldDictionary*', 'ChoiceFieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['StructureElementAccessDictionary'] = ['SkPdfStructureElementAccessDictionary*', 'StructureElementAccessDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['CalgrayColorSpaceDictionary'] = ['SkPdfCalgrayColorSpaceDictionary*', 'CalgrayColorSpaceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['WebCaptureCommandDictionary'] = ['SkPdfWebCaptureCommandDictionary*', 'WebCaptureCommandDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['IccProfileStreamDictionary'] = ['SkPdfIccProfileStreamDictionary*', 'IccProfileStreamDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['LabColorSpaceDictionary'] = ['SkPdfLabColorSpaceDictionary*', 'LabColorSpaceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['CalrgbColorSpaceDictionary'] = ['SkPdfCalrgbColorSpaceDictionary*', 'CalrgbColorSpaceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['HideActionDictionary'] = ['SkPdfHideActionDictionary*', 'HideActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FDFTemplateDictionary'] = ['SkPdfFDFTemplateDictionary*', 'FDFTemplateDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['NamedActionsDictionary'] = ['SkPdfNamedActionsDictionary*', 'NamedActionsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['InteractiveFormDictionary'] = ['SkPdfInteractiveFormDictionary*', 'InteractiveFormDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['URIActionDictionary'] = ['SkPdfURIActionDictionary*', 'URIActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['URIDictionary'] = ['SkPdfURIDictionary*', 'URIDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['SoundActionDictionary'] = ['SkPdfSoundActionDictionary*', 'SoundActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['MovieActionDictionary'] = ['SkPdfMovieActionDictionary*', 'MovieActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['SourceInformationDictionary'] = ['SkPdfSourceInformationDictionary*', 'SourceInformationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FDFFileAnnotationDictionary'] = ['SkPdfFDFFileAnnotationDictionary*', 'FDFFileAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['TransitionDictionary'] = ['SkPdfTransitionDictionary*', 'TransitionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['BeadDictionary'] = ['SkPdfBeadDictionary*', 'BeadDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ThreadDictionary'] = ['SkPdfThreadDictionary*', 'ThreadDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['PageLabelDictionary'] = ['SkPdfPageLabelDictionary*', 'PageLabelDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['OutlineItemDictionary'] = ['SkPdfOutlineItemDictionary*', 'OutlineItemDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['OutlineDictionary'] = ['SkPdfOutlineDictionary*', 'OutlineDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ViewerPreferencesDictionary'] = ['SkPdfViewerPreferencesDictionary*', 'ViewerPreferencesDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['MarkInformationDictionary'] = ['SkPdfMarkInformationDictionary*', 'MarkInformationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['URLAliasDictionary'] = ['SkPdfURLAliasDictionary*', 'URLAliasDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['WebCaptureDictionary'] = ['SkPdfWebCaptureDictionary*', 'WebCaptureDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['AttributeObjectDictionary'] = ['SkPdfAttributeObjectDictionary*', 'AttributeObjectDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ArtifactsDictionary'] = ['SkPdfArtifactsDictionary*', 'ArtifactsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['WebCaptureInformationDictionary'] = ['SkPdfWebCaptureInformationDictionary*', 'WebCaptureInformationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['TrapNetworkAnnotationDictionary'] = ['SkPdfTrapNetworkAnnotationDictionary*', 'TrapNetworkAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type1FormDictionary'] = ['SkPdfType1FormDictionary*', 'Type1FormDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['GroupAttributesDictionary'] = ['SkPdfGroupAttributesDictionary*', 'GroupAttributesDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ReferenceDictionary'] = ['SkPdfReferenceDictionary*', 'ReferenceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['PSXobjectDictionary'] = ['SkPdfPSXobjectDictionary*', 'PSXobjectDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['BoxStyleDictionary'] = ['SkPdfBoxStyleDictionary*', 'BoxStyleDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['BoxColorInformationDictionary'] = ['SkPdfBoxColorInformationDictionary*', 'BoxColorInformationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['WebCaptureCommandSettingsDictionary'] = ['SkPdfWebCaptureCommandSettingsDictionary*', 'WebCaptureCommandSettingsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['InlineLevelStructureElementsDictionary'] = ['SkPdfInlineLevelStructureElementsDictionary*', 'InlineLevelStructureElementsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['AppearanceCharacteristicsDictionary'] = ['SkPdfAppearanceCharacteristicsDictionary*', 'AppearanceCharacteristicsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type3ShadingDictionary'] = ['SkPdfType3ShadingDictionary*', 'Type3ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type4ShadingDictionary'] = ['SkPdfType4ShadingDictionary*', 'Type4ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['TextFieldDictionary'] = ['SkPdfTextFieldDictionary*', 'TextFieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['RadioButtonFieldDictionary'] = ['SkPdfRadioButtonFieldDictionary*', 'RadioButtonFieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['CheckboxFieldDictionary'] = ['SkPdfCheckboxFieldDictionary*', 'CheckboxFieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type1PatternDictionary'] = ['SkPdfType1PatternDictionary*', 'Type1PatternDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type2PatternDictionary'] = ['SkPdfType2PatternDictionary*', 'Type2PatternDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['DeviceNColorSpaceDictionary'] = ['SkPdfDeviceNColorSpaceDictionary*', 'DeviceNColorSpaceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type1ShadingDictionary'] = ['SkPdfType1ShadingDictionary*', 'Type1ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type2ShadingDictionary'] = ['SkPdfType2ShadingDictionary*', 'Type2ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['StandardStructureDictionary'] = ['SkPdfStandardStructureDictionary*', 'StandardStructureDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ShadingDictionary'] = ['SkPdfShadingDictionary*', 'ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['EmbeddedFileParameterDictionary'] = ['SkPdfEmbeddedFileParameterDictionary*', 'EmbeddedFileParameterDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['MacOsFileInformationDictionary'] = ['SkPdfMacOsFileInformationDictionary*', 'MacOsFileInformationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['WebCaptureImageSetDictionary'] = ['SkPdfWebCaptureImageSetDictionary*', 'WebCaptureImageSetDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['GraphicsStateDictionary'] = ['SkPdfGraphicsStateDictionary*', 'GraphicsStateDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FileSpecificationDictionary'] = ['SkPdfFileSpecificationDictionary*', 'FileSpecificationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['EmbeddedFileStreamDictionary'] = ['SkPdfEmbeddedFileStreamDictionary*', 'EmbeddedFileStreamDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['MovieDictionary'] = ['SkPdfMovieDictionary*', 'MovieDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FieldDictionary'] = ['SkPdfFieldDictionary*', 'FieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['MovieActivationDictionary'] = ['SkPdfMovieActivationDictionary*', 'MovieActivationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['TableAttributesDictionary'] = ['SkPdfTableAttributesDictionary*', 'TableAttributesDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ListAttributeDictionary'] = ['SkPdfListAttributeDictionary*', 'ListAttributeDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['SeparationDictionary'] = ['SkPdfSeparationDictionary*', 'SeparationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['BlockLevelStructureElementsDictionary'] = ['SkPdfBlockLevelStructureElementsDictionary*', 'BlockLevelStructureElementsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FDFCatalogDictionary'] = ['SkPdfFDFCatalogDictionary*', 'FDFCatalogDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type1HalftoneDictionary'] = ['SkPdfType1HalftoneDictionary*', 'Type1HalftoneDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type10HalftoneDictionary'] = ['SkPdfType10HalftoneDictionary*', 'Type10HalftoneDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type6HalftoneDictionary'] = ['SkPdfType6HalftoneDictionary*', 'Type6HalftoneDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type5HalftoneDictionary'] = ['SkPdfType5HalftoneDictionary*', 'Type5HalftoneDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type16HalftoneDictionary'] = ['SkPdfType16HalftoneDictionary*', 'Type16HalftoneDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type6ShadingDictionary'] = ['SkPdfType6ShadingDictionary*', 'Type6ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['StreamCommonDictionary'] = ['SkPdfStreamCommonDictionary*', 'StreamCommonDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FDFDictionary'] = ['SkPdfFDFDictionary*', 'FDFDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['LzwdecodeAndFlatedecodeFiltersDictionary'] = ['SkPdfLzwdecodeAndFlatedecodeFiltersDictionary*', 'LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['CcittfaxdecodeFilterDictionary'] = ['SkPdfCcittfaxdecodeFilterDictionary*', 'CcittfaxdecodeFilterDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['MarkedContentReferenceDictionary'] = ['SkPdfMarkedContentReferenceDictionary*', 'MarkedContentReferenceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['SignatureDictionary'] = ['SkPdfSignatureDictionary*', 'SignatureDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['SoundAnnotationDictionary'] = ['SkPdfSoundAnnotationDictionary*', 'SoundAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['MovieAnnotationDictionary'] = ['SkPdfMovieAnnotationDictionary*', 'MovieAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type3FunctionDictionary'] = ['SkPdfType3FunctionDictionary*', 'Type3FunctionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type2FunctionDictionary'] = ['SkPdfType2FunctionDictionary*', 'Type2FunctionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['RubberStampAnnotationDictionary'] = ['SkPdfRubberStampAnnotationDictionary*', 'RubberStampAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['InkAnnotationDictionary'] = ['SkPdfInkAnnotationDictionary*', 'InkAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['SquareOrCircleAnnotation'] = ['SkPdfSquareOrCircleAnnotation*', 'SquareOrCircleAnnotationFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['MarkupAnnotationsDictionary'] = ['SkPdfMarkupAnnotationsDictionary*', 'MarkupAnnotationsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['NameTreeNodeDictionary'] = ['SkPdfNameTreeNodeDictionary*', 'NameTreeNodeDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type5ShadingDictionary'] = ['SkPdfType5ShadingDictionary*', 'Type5ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ResourceDictionary'] = ['SkPdfResourceDictionary*', 'ResourceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['SubmitFormActionDictionary'] = ['SkPdfSubmitFormActionDictionary*', 'SubmitFormActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['Type0FunctionDictionary'] = ['SkPdfType0FunctionDictionary*', 'Type0FunctionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FunctionCommonDictionary'] = ['SkPdfFunctionCommonDictionary*', 'FunctionCommonDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['NumberTreeNodeDictionary'] = ['SkPdfNumberTreeNodeDictionary*', 'NumberTreeNodeDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ActionDictionary'] = ['SkPdfActionDictionary*', 'ActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['WidgetAnnotationDictionary'] = ['SkPdfWidgetAnnotationDictionary*', 'WidgetAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['StructureTreeRootDictionary'] = ['SkPdfStructureTreeRootDictionary*', 'StructureTreeRootDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['JavascriptActionDictionary'] = ['SkPdfJavascriptActionDictionary*', 'JavascriptActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['AlternateImageDictionary'] = ['SkPdfAlternateImageDictionary*', 'AlternateImageDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['PDF_XOutputIntentDictionary'] = ['SkPdfPDF_XOutputIntentDictionary*', 'PDF_XOutputIntentDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['DocumentInformationDictionary'] = ['SkPdfDocumentInformationDictionary*', 'DocumentInformationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['MetadataStreamDictionary'] = ['SkPdfMetadataStreamDictionary*', 'MetadataStreamDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ImportDataActionDictionary'] = ['SkPdfImportDataActionDictionary*', 'ImportDataActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['PagePieceDictionary'] = ['SkPdfPagePieceDictionary*', 'PagePieceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ApplicationDataDictionary'] = ['SkPdfApplicationDataDictionary*', 'ApplicationDataDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ComponentsWithMetadataDictionary'] = ['SkPdfComponentsWithMetadataDictionary*', 'ComponentsWithMetadataDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['PrinterMarkFormDictionary'] = ['SkPdfPrinterMarkFormDictionary*', 'PrinterMarkFormDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['StructureElementDictionary'] = ['SkPdfStructureElementDictionary*', 'StructureElementDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['PrinterMarkAnnotationDictionary'] = ['SkPdfPrinterMarkAnnotationDictionary*', 'PrinterMarkAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['SoftMaskImageDictionary'] = ['SkPdfSoftMaskImageDictionary*', 'SoftMaskImageDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['TransparencyGroupDictionary'] = ['SkPdfTransparencyGroupDictionary*', 'TransparencyGroupDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['SoftMaskDictionary'] = ['SkPdfSoftMaskDictionary*', 'SoftMaskDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['BorderStyleDictionary'] = ['SkPdfBorderStyleDictionary*', 'BorderStyleDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['PopUpAnnotationDictionary'] = ['SkPdfPopUpAnnotationDictionary*', 'PopUpAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FDFTrailerDictionary'] = ['SkPdfFDFTrailerDictionary*', 'FDFTrailerDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['LineAnnotationDictionary'] = ['SkPdfLineAnnotationDictionary*', 'LineAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['FreeTextAnnotationDictionary'] = ['SkPdfFreeTextAnnotationDictionary*', 'FreeTextAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['ALinkAnnotationDictionary'] = ['SkPdfALinkAnnotationDictionary*', 'ALinkAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['TextAnnotationDictionary'] = ['SkPdfTextAnnotationDictionary*', 'TextAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['WebCapturePageSetDictionary'] = ['SkPdfWebCapturePageSetDictionary*', 'WebCapturePageSetDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['AppearanceDictionary'] = ['SkPdfAppearanceDictionary*', 'AppearanceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['CIDFontDescriptorDictionary'] = ['SkPdfCIDFontDescriptorDictionary*', 'CIDFontDescriptorDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['EmbeddedFontStreamDictionary'] = ['SkPdfEmbeddedFontStreamDictionary*', 'EmbeddedFontStreamDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+ knowTypes['AnnotationDictionary'] = ['SkPdfAnnotationDictionary*', 'AnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
diff --git a/experimental/PdfViewer/generate_code.py b/experimental/PdfViewer/generate_code.py
index 02736d3..0028cf3 100644
--- a/experimental/PdfViewer/generate_code.py
+++ b/experimental/PdfViewer/generate_code.py
@@ -233,6 +233,7 @@
def write(self):
global fileHeaders
+ global fileHeadersCpp
global knowTypes
# generate enum
@@ -246,6 +247,7 @@
cls.fEnumEnd = 'k' + name + '__End_SkPdfObjectType'
fileHeaders.write('#include "SkPdf' + cls.fName + '_autogen.h"\n')
+ fileHeadersCpp.write('#include "SkPdf' + cls.fName + '_autogen.cpp"\n')
if cls.fBase != '':
self.fClasses[cls.fBase].fEnumSubclasses.append(cls.fEnum)
@@ -286,10 +288,12 @@
enum = cls.fEnum
fileClass = open('SkPdf' + cls.fName + '_autogen.h', 'w')
+ fileClassCpp = open('SkPdf' + cls.fName + '_autogen.cpp', 'w')
fileClass.write('#ifndef __DEFINED__SkPdf' + cls.fName + '\n')
fileClass.write('#define __DEFINED__SkPdf' + cls.fName + '\n')
fileClass.write('\n')
+ fileClassCpp.write('#include "SkPdf' + cls.fName + '_autogen.h"\n\n')
fileClass.write('#include "SkPdfUtils.h"\n')
fileClass.write('#include "SkPdfEnums_autogen.h"\n')
fileClass.write('#include "SkPdfArray_autogen.h"\n')
@@ -363,6 +367,7 @@
if prop.fCppName[0] == '[':
fileClass.write('/*\n') # comment code of the atributes that can have any name
+ fileClassCpp.write('/*\n') # comment code of the atributes that can have any name
# TODO(edisonn): has_foo();
fileClass.write(' bool has_' + prop.fCppName + '() const {\n')
@@ -372,16 +377,17 @@
if len(prop.fTypes.split()) == 1:
t = prop.fTypes.strip()
- fileClass.write(' ' + knowTypes[t][0] + ' ' + prop.fCppName + '() const {\n')
- fileClass.write(' ' + knowTypes[t][0] + ' ret;\n')
- fileClass.write(' if (' + knowTypes[t][1] + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;\n')
+ fileClass.write(' ' + knowTypes[t][0] + ' ' + prop.fCppName + '() const;\n')
+ fileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::' + prop.fCppName + '() const {\n')
+ fileClassCpp.write(' ' + knowTypes[t][0] + ' ret;\n')
+ fileClassCpp.write(' if (' + knowTypes[t][1] + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;\n')
if field.fRequired == False and prop.fDefault != '':
- fileClass.write(' return ' + prop.fDefault.toCpp() + ';\n');
+ fileClassCpp.write(' return ' + prop.fDefault.toCpp() + ';\n');
else:
- fileClass.write(' // TODO(edisonn): warn about missing required field, assert for known good pdfs\n')
- fileClass.write(' return ' + knowTypes[t][2].toCpp() + ';\n');
- fileClass.write(' }\n')
- fileClass.write('\n')
+ fileClassCpp.write(' // TODO(edisonn): warn about missing required field, assert for known good pdfs\n')
+ fileClassCpp.write(' return ' + knowTypes[t][2].toCpp() + ';\n');
+ fileClassCpp.write('}\n')
+ fileClassCpp.write('\n')
else:
for type in prop.fTypes.split():
t = type.strip()
@@ -392,17 +398,19 @@
fileClass.write(' }\n')
fileClass.write('\n')
- fileClass.write(' ' + knowTypes[t][0] + ' get' + prop.fCppName + 'As' + t.title() + '() const {\n')
- fileClass.write(' ' + knowTypes[t][0] + ' ret = ' + knowTypes[t][2].toCpp() + ';\n')
- fileClass.write(' if (' + knowTypes[t][1] + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;\n')
- fileClass.write(' // TODO(edisonn): warn about missing required field, assert for known good pdfs\n')
- fileClass.write(' return ' + knowTypes[t][2].toCpp() + ';\n')
- fileClass.write(' }\n')
- fileClass.write('\n')
+ fileClass.write(' ' + knowTypes[t][0] + ' get' + prop.fCppName + 'As' + t.title() + '() const;\n')
+ fileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::get' + prop.fCppName + 'As' + t.title() + '() const {\n')
+ fileClassCpp.write(' ' + knowTypes[t][0] + ' ret = ' + knowTypes[t][2].toCpp() + ';\n')
+ fileClassCpp.write(' if (' + knowTypes[t][1] + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;\n')
+ fileClassCpp.write(' // TODO(edisonn): warn about missing required field, assert for known good pdfs\n')
+ fileClassCpp.write(' return ' + knowTypes[t][2].toCpp() + ';\n')
+ fileClassCpp.write('}\n')
+ fileClassCpp.write('\n')
if prop.fCppName[0] == '[':
fileClass.write('*/\n') # comment code of the atributes that can have any name
+ fileClassCpp.write('*/\n') # comment code of the atributes that can have any name
fileClass.write('};\n')
@@ -410,6 +418,7 @@
fileClass.write('#endif // __DEFINED__SkPdf' + cls.fName + '\n')
fileClass.close()
+ fileClassCpp.close()
@@ -419,25 +428,30 @@
# generate parser
# TODO(edisonn): fast recognition based on must attributes.
fileMapper = open('SkPdfPodofoMapper_autogen.h', 'w')
+ fileMapperCpp = open('SkPdfPodofoMapper_autogen.cpp', 'w')
fileMapper.write('#ifndef __DEFINED__SkPdfPodofoMapper\n')
fileMapper.write('#define __DEFINED__SkPdfPodofoMapper\n')
fileMapper.write('\n')
fileMapper.write('#include "SkPdfHeaders_autogen.h"\n')
- fileMapper.write('class PodofoMapper {\n')
- fileMapper.write('public:\n')
+ fileMapperCpp.write('#include "SkPdfPodofoMapper_autogen.h"\n')
+# fileMapper.write('class PodofoMapper {\n')
+# fileMapper.write('public:\n')
for name in self.fClassesNamesInOrder:
cls = self.fClasses[name]
- fileMapper.write(' static bool map(const SkPdfObject& in, SkPdf' + name + '** out) {\n')
- fileMapper.write(' return map(*in.doc(), *in.podofo(), out);\n')
- fileMapper.write(' }\n')
- fileMapper.write('\n')
+ fileMapper.write('bool map' + name + '(const SkPdfObject& in, SkPdf' + name + '** out);\n')
- fileMapper.write(' static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdf' + name + '** out) {\n')
- fileMapper.write(' if (!is' + name + '(podofoDoc, podofoObj)) return false;\n')
- fileMapper.write('\n')
+ fileMapperCpp.write('bool map' + name + '(const SkPdfObject& in, SkPdf' + name + '** out) {\n')
+ fileMapperCpp.write(' return map' + name + '(*in.doc(), *in.podofo(), out);\n')
+ fileMapperCpp.write('}\n')
+ fileMapperCpp.write('\n')
+
+ fileMapper.write('bool map' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdf' + name + '** out);\n')
+ fileMapperCpp.write('bool map' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdf' + name + '** out) {\n')
+ fileMapperCpp.write(' if (!is' + name + '(podofoDoc, podofoObj)) return false;\n')
+ fileMapperCpp.write('\n')
# stream must be last one
hasStream = False
@@ -445,34 +459,35 @@
if cls.fName == 'Object' and enumToCls[sub].fName == 'Stream':
hasStream = True
else:
- fileMapper.write(' if (map(podofoDoc, podofoObj, (SkPdf' + enumToCls[sub].fName + '**)out)) return true;\n')
+ fileMapperCpp.write(' if (map' + enumToCls[sub].fName + '(podofoDoc, podofoObj, (SkPdf' + enumToCls[sub].fName + '**)out)) return true;\n')
if hasStream:
- fileMapper.write(' if (map(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;\n')
+ fileMapperCpp.write(' if (mapStream(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;\n')
- fileMapper.write('\n')
+ fileMapperCpp.write('\n')
- fileMapper.write(' *out = new SkPdf' + name + '(&podofoDoc, &podofoObj);\n')
- fileMapper.write(' return true;\n')
- fileMapper.write(' }\n')
- fileMapper.write('\n')
+ fileMapperCpp.write(' *out = new SkPdf' + name + '(&podofoDoc, &podofoObj);\n')
+ fileMapperCpp.write(' return true;\n')
+ fileMapperCpp.write('}\n')
+ fileMapperCpp.write('\n')
for name in self.fClassesNamesInOrder:
cls = self.fClasses[name]
- fileMapper.write(' static bool is' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {\n')
+ fileMapper.write('bool is' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);\n')
+ fileMapperCpp.write('bool is' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {\n')
if cls.fCheck != '':
- fileMapper.write(' return ' + cls.fCheck + ';\n')
+ fileMapperCpp.write(' return ' + cls.fCheck + ';\n')
else:
cntMust = 0
for field in cls.fFields:
prop = field.fProp
if prop.fHasMust:
cntMust = cntMust + 1
- fileMapper.write(' ' + knowTypes[prop.fTypes.strip()][0] + ' ' + prop.fCppName + ';\n')
- fileMapper.write(' if (!' + knowTypes[prop.fTypes.strip()][1] + '(&podofoDoc, podofoObj.GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &' + prop.fCppName + ')) return false;\n')
+ fileMapperCpp.write(' ' + knowTypes[prop.fTypes.strip()][0] + ' ' + prop.fCppName + ';\n')
+ fileMapperCpp.write(' if (!' + knowTypes[prop.fTypes.strip()][1] + '(&podofoDoc, podofoObj.GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &' + prop.fCppName + ')) return false;\n')
eval = '';
# TODO(edisonn): this could get out of hand, and could have poor performance if continued on this path
@@ -486,15 +501,32 @@
eval = '(' + prop.fCppName + ' != ' + cnd.toCpp() + ')'
else:
eval = eval + ' && ' + '(' + prop.fCppName + ' != ' + cnd.toCpp() + ')'
- fileMapper.write(' if (' + eval + ') return false;\n')
- fileMapper.write('\n')
+ fileMapperCpp.write(' if (' + eval + ') return false;\n')
+ fileMapperCpp.write('\n')
- fileMapper.write(' return true;\n')
+ fileMapperCpp.write(' return true;\n')
- fileMapper.write(' }\n')
- fileMapper.write('\n')
+ fileMapperCpp.write('}\n')
+ fileMapperCpp.write('\n')
- fileMapper.write('};\n')
+ fileMapper.write('bool ' + name + 'FromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdf' + name + '** data);\n')
+ fileMapperCpp.write('bool ' + name + 'FromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdf' + name + '** data) {\n')
+ fileMapperCpp.write(' const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);\n')
+ fileMapperCpp.write(' if (value == NULL) { return false; }\n')
+ fileMapperCpp.write(' if (data == NULL) { return true; }\n')
+ fileMapperCpp.write(' return map' + name + '(*pdfDoc, *value, (SkPdf' + name + '**)data);\n')
+ fileMapperCpp.write('}\n')
+ fileMapperCpp.write('\n')
+
+ fileMapper.write('bool ' + name + 'FromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdf' + name + '** data);\n')
+ fileMapperCpp.write('bool ' + name + 'FromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdf' + name + '** data) {\n')
+ fileMapperCpp.write(' if (' + name + 'FromDictionary(pdfDoc, dict, key, data)) return true;\n')
+ fileMapperCpp.write(' if (abr == NULL || *abr == \'\\0\') return false;\n')
+ fileMapperCpp.write(' return ' + name + 'FromDictionary(pdfDoc, dict, abr, data);\n')
+ fileMapperCpp.write('}\n')
+ fileMapperCpp.write('\n')
+
+ #fileMapper.write('};\n')
fileMapper.write('\n')
fileMapper.write('#endif // __DEFINED__SkPdfPodofoMapper\n')
@@ -504,15 +536,19 @@
def generateCode():
global fileHeaders
+ global fileHeadersCpp
global knowTypes
fileHeaders = open('SkPdfHeaders_autogen.h', 'w')
+ fileHeadersCpp = open('SkPdfHeaders_autogen.cpp', 'w')
fileHeaders.write('#ifndef __DEFINED__SkPdfHeaders\n')
fileHeaders.write('#define __DEFINED__SkPdfHeaders\n')
fileHeaders.write('\n')
fileHeaders.write('#include "SkPdfEnums_autogen.h"\n')
+ fileHeadersCpp.write('#include "SkPdfHeaders_autogen.h"\n')
+
manager = PdfClassManager()
manager.addClass('Object')
@@ -581,6 +617,7 @@
fileHeaders.write('#endif // __DEFINED__SkPdfHeaders\n')
fileHeaders.close()
+ fileHeadersCpp.close()
return 1
diff --git a/experimental/PdfViewer/pdf_viewer_main.cpp b/experimental/PdfViewer/pdf_viewer_main.cpp
index 61997fa..20a6cae 100644
--- a/experimental/PdfViewer/pdf_viewer_main.cpp
+++ b/experimental/PdfViewer/pdf_viewer_main.cpp
@@ -1,10 +1,3 @@
-/*
- * Copyright 2013 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
#include "SkCanvas.h"
#include "SkDevice.h"
#include "SkForceLinking.h"
@@ -18,2509 +11,8 @@
#include "SkTArray.h"
#include "picture_utils.h"
-#include <iostream>
-#include <cstdio>
-#include <stack>
-
-#include "podofo.h"
-using namespace PoDoFo;
-
-
-__SK_FORCE_IMAGE_DECODER_LINKING;
-
-// TODO(edisonn): tool, show what objects were read at least, show the ones not even read
-// keep for each object pos in file
-// plug in for VS? syntax coloring, show selected object ... from the text, or from rendered x,y
-
-// TODO(edisonn): security - validate all the user input, all pdf!
-
-
-#include "SkPdfHeaders_autogen.h"
-#include "SkPdfPodofoMapper_autogen.h"
#include "SkPdfParser.h"
-#include "SkPdfBasics.h"
-#include "SkPdfUtils.h"
-
-#include "SkPdfFont.h"
-
-// TODO(edisonn): fix the mess with the files.
-#include "SkPdfFont.cpp"
-#include "SkPdfBasics.cpp"
-#include "SkPdfUtils.cpp"
-
-bool skpdfmap(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out) {
- return PodofoMapper::map(podofoDoc, podofoObj, out);
-}
-
-
-/*
- * TODO(edisonn):
- * - all font types and all ppdf font features
- * - word spacing
- * - load font for baidu.pdf
- * - load font for youtube.pdf
- * - parser for pdf from the definition already available in pdfspec_autogen.py
- * - all docs from ~/work
- * - encapsulate podofo in the pdf api so the skpdf does not know anything about podofo ... in progress
- * - load gs/ especially smask and already known prop (skp) ... in progress
- * - wrapper on classes for customizations? e.g.
- * SkPdfPageObjectVanila - has only the basic loaders/getters
- * SkPdfPageObject : public SkPdfPageObjectVanila, extends, and I can add customizations here
- * need to find a nice object model for all this with constructors and factories
- * - deal with inheritable automatically ?
- * - deal with specific type in spec directly, add all dictionary types to known types
-*/
-
-
-// TODO(edisonn): move in trace util.
-#ifdef PDF_TRACE
-static void SkTraceMatrix(const SkMatrix& matrix, const char* sz = "") {
- printf("SkMatrix %s ", sz);
- for (int i = 0 ; i < 9 ; i++) {
- printf("%f ", SkScalarToDouble(matrix.get(i)));
- }
- printf("\n");
-}
-
-static void SkTraceRect(const SkRect& rect, const char* sz = "") {
- printf("SkRect %s ", sz);
- printf("x = %f ", SkScalarToDouble(rect.x()));
- printf("y = %f ", SkScalarToDouble(rect.y()));
- printf("w = %f ", SkScalarToDouble(rect.width()));
- printf("h = %f ", SkScalarToDouble(rect.height()));
- printf("\n");
-}
-
-#else
-#define SkTraceMatrix(a,b)
-#define SkTraceRect(a,b)
-#endif
-
-using namespace std;
-using namespace PoDoFo;
-
-// Utilities
-static void setup_bitmap(SkBitmap* bitmap, int width, int height, SkColor color = SK_ColorWHITE) {
- bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height);
-
- bitmap->allocPixels();
- bitmap->eraseColor(color);
-}
-
-// TODO(edisonn): synonyms? DeviceRGB and RGB ...
-int GetColorSpaceComponents(const std::string& colorSpace) {
- if (colorSpace == "DeviceCMYK") {
- return 4;
- } else if (colorSpace == "DeviceGray" ||
- colorSpace == "CalGray" ||
- colorSpace == "Indexed") {
- return 1;
- } else if (colorSpace == "DeviceRGB" ||
- colorSpace == "CalRGB" ||
- colorSpace == "Lab") {
- return 3;
- } else {
- return 0;
- }
-}
-
-const PdfObject* resolveReferenceObject(const PdfMemDocument* pdfDoc,
- const PdfObject* obj,
- bool resolveOneElementArrays) {
- while (obj && (obj->IsReference() || (resolveOneElementArrays &&
- obj->IsArray() &&
- obj->GetArray().GetSize() == 1))) {
- if (obj->IsReference()) {
- // We need to force the non const, the only update we will do is for recurssion checks.
- PdfReference& ref = (PdfReference&)obj->GetReference();
- obj = pdfDoc->GetObjects().GetObject(ref);
- } else {
- obj = &obj->GetArray()[0];
- }
- }
-
- return obj;
-}
-
-static SkMatrix SkMatrixFromPdfMatrix(double array[6]) {
- SkMatrix matrix;
- matrix.setAll(SkDoubleToScalar(array[0]),
- SkDoubleToScalar(array[2]),
- SkDoubleToScalar(array[4]),
- SkDoubleToScalar(array[1]),
- SkDoubleToScalar(array[3]),
- SkDoubleToScalar(array[5]),
- SkDoubleToScalar(0),
- SkDoubleToScalar(0),
- SkDoubleToScalar(1));
-
- return matrix;
-}
-
-SkMatrix SkMatrixFromPdfArray(SkPdfArray* pdfArray) {
- double array[6];
-
- // TODO(edisonn): security issue, ret if size() != 6
- for (int i = 0; i < 6; i++) {
- const PdfObject* elem = resolveReferenceObject(pdfArray->doc(), (*pdfArray)[i]->podofo());
- if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
- return SkMatrix::I(); // TODO(edisonn): report issue
- }
- array[i] = elem->GetReal();
- }
-
- return SkMatrixFromPdfMatrix(array);
-}
-
-PdfContext* gPdfContext = NULL;
-SkBitmap* gDumpBitmap = NULL;
-SkCanvas* gDumpCanvas = NULL;
-char gLastKeyword[100] = "";
-int gLastOpKeyword = -1;
-char allOpWithVisualEffects[100] = ",S,s,f,F,f*,B,B*,b,b*,n,Tj,TJ,\',\",d0,d1,sh,EI,Do,EX,";
-int gReadOp = 0;
-
-
-
-bool hasVisualEffect(const char* pdfOp) {
- return true;
- if (*pdfOp == '\0') return false;
-
- char markedPdfOp[100] = ",";
- strcat(markedPdfOp, pdfOp);
- strcat(markedPdfOp, ",");
-
- return (strstr(allOpWithVisualEffects, markedPdfOp) != NULL);
-}
-
-// TODO(edisonn): Pass PdfContext and SkCanvasd only with the define for instrumentation.
-static bool readToken(SkPdfTokenizer* fTokenizer, PdfToken* token) {
- bool ret = fTokenizer->readToken(token);
-
- gReadOp++;
-
-#ifdef PDF_TRACE_DIFF_IN_PNG
- // TODO(edisonn): compare with old bitmap, and save only new bits are available, and save
- // the numbar and name of last operation, so the file name will reflect op that changed.
- if (hasVisualEffect(gLastKeyword)) { // TODO(edisonn): and has dirty bits.
- gDumpCanvas->flush();
-
- SkBitmap bitmap;
- setup_bitmap(&bitmap, gDumpBitmap->width(), gDumpBitmap->height());
-
- memcpy(bitmap.getPixels(), gDumpBitmap->getPixels(), gDumpBitmap->getSize());
-
- SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
- SkCanvas canvas(device);
-
- // draw context stuff here
- SkPaint blueBorder;
- blueBorder.setColor(SK_ColorBLUE);
- blueBorder.setStyle(SkPaint::kStroke_Style);
- blueBorder.setTextSize(SkDoubleToScalar(20));
-
- SkString str;
-
- const SkClipStack* clipStack = gDumpCanvas->getClipStack();
- if (clipStack) {
- SkClipStack::Iter iter(*clipStack, SkClipStack::Iter::kBottom_IterStart);
- const SkClipStack::Element* elem;
- double y = 0;
- int total = 0;
- while (elem = iter.next()) {
- total++;
- y += 30;
-
- switch (elem->getType()) {
- case SkClipStack::Element::kRect_Type:
- canvas.drawRect(elem->getRect(), blueBorder);
- canvas.drawText("Rect Clip", strlen("Rect Clip"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
- break;
- case SkClipStack::Element::kPath_Type:
- canvas.drawPath(elem->getPath(), blueBorder);
- canvas.drawText("Path Clip", strlen("Path Clip"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
- break;
- case SkClipStack::Element::kEmpty_Type:
- canvas.drawText("Empty Clip!!!", strlen("Empty Clip!!!"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
- break;
- default:
- canvas.drawText("Unkown Clip!!!", strlen("Unkown Clip!!!"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
- break;
- }
- }
-
- y += 30;
- str.printf("Number of clips in stack: %i", total);
- canvas.drawText(str.c_str(), str.size(), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
- }
-
- const SkRegion& clipRegion = gDumpCanvas->getTotalClip();
- SkPath clipPath;
- if (clipRegion.getBoundaryPath(&clipPath)) {
- SkPaint redBorder;
- redBorder.setColor(SK_ColorRED);
- redBorder.setStyle(SkPaint::kStroke_Style);
- canvas.drawPath(clipPath, redBorder);
- }
-
- canvas.flush();
-
- SkString out;
-
- // TODO(edisonn): get the image, and overlay on top of it, the clip , grafic state, teh stack,
- // ... and other properties, to be able to debug th code easily
-
- out.appendf("/usr/local/google/home/edisonn/log_view2/step-%i-%s.png", gLastOpKeyword, gLastKeyword);
- SkImageEncoder::EncodeFile(out.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100);
- }
-
- if (token->fType == kKeyword_TokenType) {
- strcpy(gLastKeyword, token->fKeyword);
- gLastOpKeyword = gReadOp;
- } else {
- strcpy(gLastKeyword, "");
- }
-#endif
-
- return ret;
-}
-
-// TODO(edisonn): Document PdfTokenLooper and subclasses.
-class PdfTokenLooper {
-protected:
- PdfTokenLooper* fParent;
- SkPdfTokenizer* fTokenizer;
- PdfContext* fPdfContext;
- SkCanvas* fCanvas;
-
-public:
- PdfTokenLooper(PdfTokenLooper* parent,
- SkPdfTokenizer* tokenizer,
- PdfContext* pdfContext,
- SkCanvas* canvas)
- : fParent(parent), fTokenizer(tokenizer), fPdfContext(pdfContext), fCanvas(canvas) {}
-
- virtual PdfResult consumeToken(PdfToken& token) = 0;
- virtual void loop() = 0;
-
- void setUp(PdfTokenLooper* parent) {
- fParent = parent;
- fTokenizer = parent->fTokenizer;
- fPdfContext = parent->fPdfContext;
- fCanvas = parent->fCanvas;
- }
-};
-
-class PdfMainLooper : public PdfTokenLooper {
-public:
- PdfMainLooper(PdfTokenLooper* parent,
- SkPdfTokenizer* tokenizer,
- PdfContext* pdfContext,
- SkCanvas* canvas)
- : PdfTokenLooper(parent, tokenizer, pdfContext, canvas) {}
-
- virtual PdfResult consumeToken(PdfToken& token);
- virtual void loop();
-};
-
-class PdfInlineImageLooper : public PdfTokenLooper {
-public:
- PdfInlineImageLooper()
- : PdfTokenLooper(NULL, NULL, NULL, NULL) {}
-
- virtual PdfResult consumeToken(PdfToken& token);
- virtual void loop();
- PdfResult done();
-};
-
-class PdfCompatibilitySectionLooper : public PdfTokenLooper {
-public:
- PdfCompatibilitySectionLooper()
- : PdfTokenLooper(NULL, NULL, NULL, NULL) {}
-
- virtual PdfResult consumeToken(PdfToken& token);
- virtual void loop();
-};
-
-typedef PdfResult (*PdfOperatorRenderer)(PdfContext*, SkCanvas*, PdfTokenLooper**);
-
-map<std::string, PdfOperatorRenderer> gPdfOps;
-
-map<std::string, int> gRenderStats[kCount_PdfResult];
-
-char* gRenderStatsNames[kCount_PdfResult] = {
- "Success",
- "Partially implemented",
- "Not yet implemented",
- "Ignore Error",
- "Error",
- "Unsupported/Unknown"
-};
-
-static SkTypeface* SkTypefaceFromPdfFont(PdfFont* font) {
- if (font == NULL) {
- return SkTypeface::CreateFromName("Times New Roman", SkTypeface::kNormal);
- }
-
- PdfObject* fontObject = font->GetObject();
-
- PdfObject* pBaseFont = NULL;
- // TODO(edisonn): warning, PoDoFo has a bug in PdfFont constructor, does not call InitVars()
- // for now fixed locally.
- pBaseFont = fontObject->GetIndirectKey( "BaseFont" );
- const char* pszBaseFontName = pBaseFont->GetName().GetName().c_str();
-
-#ifdef PDF_TRACE
- std::string str;
- fontObject->ToString(str);
- printf("Base Font Name: %s\n", pszBaseFontName);
- printf("Font Object Data: %s\n", str.c_str());
-#endif
-
- SkTypeface* typeface = SkTypefaceFromPdfStandardFont(pszBaseFontName, font->IsBold(), font->IsItalic());
-
- if (typeface != NULL) {
- return typeface;
- }
-
- char name[1000];
- // HACK
- strncpy(name, pszBaseFontName, 1000);
- char* comma = strstr(name, ",");
- char* dash = strstr(name, "-");
- if (comma) *comma = '\0';
- if (dash) *dash = '\0';
-
- typeface = SkTypeface::CreateFromName(
- name,
- SkTypeface::Style((font->IsBold() ? SkTypeface::kBold : 0) |
- (font->IsItalic() ? SkTypeface::kItalic : 0)));
-
- if (typeface != NULL) {
-#ifdef PDF_TRACE
- printf("HACKED FONT found %s\n", name);
-#endif
- return typeface;
- }
-
-#ifdef PDF_TRACE
- printf("FONT_NOT_FOUND %s\n", pszBaseFontName);
-#endif
-
- // TODO(edisonn): Report Warning, NYI
- return SkTypeface::CreateFromName(
- "Times New Roman",
- SkTypeface::Style((font->IsBold() ? SkTypeface::kBold : 0) |
- (font->IsItalic() ? SkTypeface::kItalic : 0)));
-}
-
-PdfResult DrawText(PdfContext* pdfContext,
- const SkPdfObject* str,
- SkCanvas* canvas)
-{
-
- SkPdfFont* skfont = pdfContext->fGraphicsState.fSkFont;
- if (skfont == NULL) {
- skfont = SkPdfFont::Default();
- }
-
- SkUnencodedText binary(str);
-
- SkDecodedText decoded;
-
- if (skfont->encoding() == NULL) {
- // TODO(edisonn): report warning
- return kNYI_PdfResult;
- }
-
- skfont->encoding()->decodeText(binary, &decoded);
-
- SkPaint paint;
- // TODO(edisonn): when should fCurFont->GetFontSize() used? When cur is fCurFontSize == 0?
- // Or maybe just not call setTextSize at all?
- if (pdfContext->fGraphicsState.fCurFontSize != 0) {
- paint.setTextSize(SkDoubleToScalar(pdfContext->fGraphicsState.fCurFontSize));
- }
-
-// if (fCurFont && fCurFont->GetFontScale() != 0) {
-// paint.setTextScaleX(SkFloatToScalar(fCurFont->GetFontScale() / 100.0));
-// }
-
- pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
-
- canvas->save();
-
-#if 1
- SkMatrix matrix = pdfContext->fGraphicsState.fMatrixTm;
-
- SkPoint point1;
- pdfContext->fGraphicsState.fMatrixTm.mapXY(SkIntToScalar(0), SkIntToScalar(0), &point1);
-
- SkMatrix mirror;
- mirror.setTranslate(0, -point1.y());
- // TODO(edisonn): fix rotated text, and skewed too
- mirror.postScale(SK_Scalar1, -SK_Scalar1);
- // TODO(edisonn): post rotate, skew
- mirror.postTranslate(0, point1.y());
-
- matrix.postConcat(mirror);
-
- canvas->setMatrix(matrix);
-
- SkTraceMatrix(matrix, "mirrored");
-#endif
-
- skfont->drawText(decoded, &paint, pdfContext, canvas, &pdfContext->fGraphicsState.fMatrixTm);
- canvas->restore();
-
- return kPartial_PdfResult;
-}
-
-// 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);
-
-// TODO(edisonn): deal with synonyms (/BPC == /BitsPerComponent), here or in GetKey?
-// Always pass long form in key, and have a map of long -> short key
-bool LongFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- long* data) {
- const PdfObject* value = resolveReferenceObject(pdfDoc,
- dict.GetKey(PdfName(key)));
-
- if (value == NULL || !value->IsNumber()) {
- return false;
- }
- if (data == NULL) {
- return true;
- }
-
- *data = value->GetNumber();
- return true;
-}
-
-bool LongFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- long* data) {
- if (LongFromDictionary(pdfDoc, dict, key, data)) return true;
- if (abr == NULL || *abr == '\0') return false;
- return LongFromDictionary(pdfDoc, dict, abr, data);
-}
-
-bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- double* data) {
- const PdfObject* value = resolveReferenceObject(pdfDoc,
- dict.GetKey(PdfName(key)));
-
- if (value == NULL || (!value->IsReal() && !value->IsNumber())) {
- return false;
- }
- if (data == NULL) {
- return true;
- }
-
- *data = value->GetReal();
- return true;
-}
-
-bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- double* data) {
- if (DoubleFromDictionary(pdfDoc, dict, key, data)) return true;
- if (abr == NULL || *abr == '\0') return false;
- return DoubleFromDictionary(pdfDoc, dict, abr, data);
-}
-
-
-bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- bool* data) {
- const PdfObject* value = resolveReferenceObject(pdfDoc,
- dict.GetKey(PdfName(key)));
-
- if (value == NULL || !value->IsBool()) {
- return false;
- }
- if (data == NULL) {
- return true;
- }
-
- *data = value->GetBool();
- return true;
-}
-
-bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- bool* data) {
- if (BoolFromDictionary(pdfDoc, dict, key, data)) return true;
- if (abr == NULL || *abr == '\0') return false;
- return BoolFromDictionary(pdfDoc, dict, abr, data);
-}
-
-bool NameFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- std::string* data) {
- const PdfObject* value = resolveReferenceObject(pdfDoc,
- dict.GetKey(PdfName(key)),
- true);
- if (value == NULL || !value->IsName()) {
- return false;
- }
- if (data == NULL) {
- return true;
- }
-
- *data = value->GetName().GetName();
- return true;
-}
-
-bool NameFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- std::string* data) {
- if (NameFromDictionary(pdfDoc, dict, key, data)) return true;
- if (abr == NULL || *abr == '\0') return false;
- return NameFromDictionary(pdfDoc, dict, abr, data);
-}
-
-bool StringFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- std::string* data) {
- const PdfObject* value = resolveReferenceObject(pdfDoc,
- dict.GetKey(PdfName(key)),
- true);
- if (value == NULL || (!value->IsString() && !value->IsHexString())) {
- return false;
- }
- if (data == NULL) {
- return true;
- }
-
- *data = value->GetString().GetString();
- return true;
-}
-
-bool StringFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- std::string* data) {
- if (StringFromDictionary(pdfDoc, dict, key, data)) return true;
- if (abr == NULL || *abr == '\0') return false;
- return StringFromDictionary(pdfDoc, dict, abr, data);
-}
-
-bool ArrayFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- SkPdfArray** data) {
- const PdfObject* value = resolveReferenceObject(pdfDoc,
- dict.GetKey(PdfName(key)),
- true);
- if (value == NULL || !value->IsArray()) {
- return false;
- }
- if (data == NULL) {
- return true;
- }
-
- return PodofoMapper::map(*pdfDoc, *value, (SkPdfObject**)data);
-}
-
-
-bool ArrayFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- SkPdfArray** data) {
- if (ArrayFromDictionary(pdfDoc, dict, key, data)) return true;
- if (abr == NULL || *abr == '\0') return false;
- return ArrayFromDictionary(pdfDoc, dict, abr, data);
-}
-
-
-bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- SkPdfDictionary** data) {
- const PdfObject* value = resolveReferenceObject(pdfDoc,
- dict.GetKey(PdfName(key)),
- true);
- if (value == NULL || !value->IsDictionary()) {
- return false;
- }
- if (data == NULL) {
- return true;
- }
-
- return PodofoMapper::map(*pdfDoc, *value, (SkPdfObject**)data);
-}
-
-bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- SkPdfDictionary** data) {
- if (DictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
- if (abr == NULL || *abr == '\0') return false;
- return DictionaryFromDictionary(pdfDoc, dict, abr, data);
-}
-
-template <typename T>
-bool DictionaryFromDictionary2(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- T** data) {
- const PdfObject* value = resolveReferenceObject(pdfDoc,
- dict.GetKey(PdfName(key)),
- true);
- if (value == NULL || !value->IsDictionary()) {
- return false;
- }
-
- if (data == NULL) {
- return true;
- }
-
- return PodofoMapper::map(*pdfDoc, *value, (T**)data);
-}
-
-template <typename T>
-bool DictionaryFromDictionary2(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- T** data) {
- if (DictionaryFromDictionary2<T>(pdfDoc, dict, key, data)) return true;
- if (abr == NULL || *abr == '\0') return false;
- return DictionaryFromDictionary2<T>(pdfDoc, dict, abr, data);
-}
-
-bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- SkPdfObject** data) {
- const PdfObject* value = resolveReferenceObject(pdfDoc,
- dict.GetKey(PdfName(key)),
- true);
- if (value == NULL) {
- return false;
- }
- if (data == NULL) {
- return true;
- }
- return PodofoMapper::map(*pdfDoc, *value, data);
-}
-
-bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- SkPdfObject** data) {
- if (ObjectFromDictionary(pdfDoc, dict, key, data)) return true;
- if (abr == NULL || *abr == '\0') return false;
- return ObjectFromDictionary(pdfDoc, dict, abr, data);
-}
-
-bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- SkPdfStream** data) {
- const PdfObject* value = resolveReferenceObject(pdfDoc,
- dict.GetKey(PdfName(key)),
- true);
- if (value == NULL) {
- return false;
- }
- if (data == NULL) {
- return true;
- }
- return PodofoMapper::map(*pdfDoc, *value, data);
-}
-
-bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- SkPdfStream** data) {
- if (StreamFromDictionary(pdfDoc, dict, key, data)) return true;
- if (abr == NULL || *abr == '\0') return false;
- return StreamFromDictionary(pdfDoc, dict, abr, data);
-}
-
-
-// TODO(edisonn): perf!!!
-
-static SkColorTable* getGrayColortable() {
- static SkColorTable* grayColortable = NULL;
- if (grayColortable == NULL) {
- SkPMColor* colors = new SkPMColor[256];
- for (int i = 0 ; i < 256; i++) {
- colors[i] = SkPreMultiplyARGB(255, i, i, i);
- }
- grayColortable = new SkColorTable(colors, 256);
- }
- return grayColortable;
-}
-
-SkBitmap transferImageStreamToBitmap(unsigned char* uncompressedStream, pdf_long uncompressedStreamLength,
- int width, int height, int bytesPerLine,
- int bpc, const std::string& colorSpace,
- bool transparencyMask) {
- SkBitmap bitmap;
-
- int components = GetColorSpaceComponents(colorSpace);
-//#define MAX_COMPONENTS 10
-
- int bitsPerLine = width * components * bpc;
- // TODO(edisonn): assume start of lines are aligned at 32 bits?
- // Is there a faster way to load the uncompressed stream into a bitmap?
-
- // minimal support for now
- if ((colorSpace == "DeviceRGB" || colorSpace == "RGB") && bpc == 8) {
- SkColor* uncompressedStreamArgb = (SkColor*)malloc(width * height * sizeof(SkColor));
-
- for (int h = 0 ; h < height; h++) {
- long i = width * (height - 1 - h);
- for (int w = 0 ; w < width; w++) {
- uncompressedStreamArgb[i] = SkColorSetRGB(uncompressedStream[3 * w],
- uncompressedStream[3 * w + 1],
- uncompressedStream[3 * w + 2]);
- i++;
- }
- uncompressedStream += bytesPerLine;
- }
-
- bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
- bitmap.setPixels(uncompressedStreamArgb);
- }
- else if ((colorSpace == "DeviceGray" || colorSpace == "Gray") && bpc == 8) {
- unsigned char* uncompressedStreamA8 = (unsigned char*)malloc(width * height);
-
- for (int h = 0 ; h < height; h++) {
- long i = width * (height - 1 - h);
- for (int w = 0 ; w < width; w++) {
- uncompressedStreamA8[i] = transparencyMask ? 255 - uncompressedStream[w] :
- uncompressedStream[w];
- i++;
- }
- uncompressedStream += bytesPerLine;
- }
-
- bitmap.setConfig(transparencyMask ? SkBitmap::kA8_Config : SkBitmap::kIndex8_Config,
- width, height);
- bitmap.setPixels(uncompressedStreamA8, transparencyMask ? NULL : getGrayColortable());
- }
-
- // TODO(edisonn): Report Warning, NYI, or error
- return bitmap;
-}
-
-bool transferImageStreamToARGB(unsigned char* uncompressedStream, pdf_long uncompressedStreamLength,
- int width, int bytesPerLine,
- int bpc, const std::string& colorSpace,
- SkColor** uncompressedStreamArgb,
- pdf_long* uncompressedStreamLengthInBytesArgb) {
- int components = GetColorSpaceComponents(colorSpace);
-//#define MAX_COMPONENTS 10
-
- int bitsPerLine = width * components * bpc;
- // TODO(edisonn): assume start of lines are aligned at 32 bits?
- int height = uncompressedStreamLength / bytesPerLine;
-
- // minimal support for now
- if ((colorSpace == "DeviceRGB" || colorSpace == "RGB") && bpc == 8) {
- *uncompressedStreamLengthInBytesArgb = width * height * 4;
- *uncompressedStreamArgb = (SkColor*)malloc(*uncompressedStreamLengthInBytesArgb);
-
- for (int h = 0 ; h < height; h++) {
- long i = width * (height - 1 - h);
- for (int w = 0 ; w < width; w++) {
- (*uncompressedStreamArgb)[i] = SkColorSetRGB(uncompressedStream[3 * w],
- uncompressedStream[3 * w + 1],
- uncompressedStream[3 * w + 2]);
- i++;
- }
- uncompressedStream += bytesPerLine;
- }
- return true;
- }
-
- if ((colorSpace == "DeviceGray" || colorSpace == "Gray") && bpc == 8) {
- *uncompressedStreamLengthInBytesArgb = width * height * 4;
- *uncompressedStreamArgb = (SkColor*)malloc(*uncompressedStreamLengthInBytesArgb);
-
- for (int h = 0 ; h < height; h++) {
- long i = width * (height - 1 - h);
- for (int w = 0 ; w < width; w++) {
- (*uncompressedStreamArgb)[i] = SkColorSetRGB(uncompressedStream[w],
- uncompressedStream[w],
- uncompressedStream[w]);
- i++;
- }
- uncompressedStream += bytesPerLine;
- }
- return true;
- }
-
- return false;
-}
-
-// utils
-
-// TODO(edisonn): add cache, or put the bitmap property directly on the PdfObject
-// TODO(edisonn): deal with colorSpaces, we could add them to SkBitmap::Config
-// TODO(edisonn): preserve A1 format that skia knows, + fast convert from 111, 222, 444 to closest
-// skia format, through a table
-
-// this functions returns the image, it does not look at the smask.
-
-SkBitmap getImageFromObject(PdfContext* pdfContext, const SkPdfImageDictionary* image, bool transparencyMask) {
- if (image == NULL || !image->valid()) {
- // TODO(edisonn): report warning to be used in testing.
- return SkBitmap();
- }
-
- // TODO (edisonn): Fast Jpeg(DCTDecode) draw, or fast PNG(FlateDecode) draw ...
-// PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
-// obj.GetDictionary().GetKey(PdfName("Filter")));
-// if (value && value->IsArray() && value->GetArray().GetSize() == 1) {
-// value = resolveReferenceObject(pdfContext->fPdfDoc,
-// &value->GetArray()[0]);
-// }
-// if (value && value->IsName() && value->GetName().GetName() == "DCTDecode") {
-// SkStream stream = SkStream::
-// SkImageDecoder::Factory()
-// }
-
- long bpc = image->BitsPerComponent();
- long width = image->Width();
- long height = image->Height();
- std::string colorSpace = "DeviceRGB";
-
- // TODO(edisonn): color space can be an array too!
- if (image->isColorSpaceAName()) {
- colorSpace = image->getColorSpaceAsName();
- }
-
-/*
- bool imageMask = image->imageMask();
-
- if (imageMask) {
- if (bpc != 0 && bpc != 1) {
- // TODO(edisonn): report warning to be used in testing.
- return SkBitmap();
- }
- bpc = 1;
- }
-*/
-
- const PdfObject* obj = image->podofo();
-
- char* uncompressedStream = NULL;
- pdf_long uncompressedStreamLength = 0;
-
- PdfResult ret = kPartial_PdfResult;
- // TODO(edisonn): get rid of try/catch exceptions! We should not throw on user data!
- try {
- obj->GetStream()->GetFilteredCopy(&uncompressedStream, &uncompressedStreamLength);
- } catch (PdfError& e) {
- // TODO(edisonn): report warning to be used in testing.
- return SkBitmap();
- }
-
- int bytesPerLine = uncompressedStreamLength / height;
-#ifdef PDF_TRACE
- if (uncompressedStreamLength % height != 0) {
- printf("Warning uncompressedStreamLength % height != 0 !!!\n");
- }
-#endif
-
- SkBitmap bitmap = transferImageStreamToBitmap(
- (unsigned char*)uncompressedStream, uncompressedStreamLength,
- width, height, bytesPerLine,
- bpc, colorSpace,
- transparencyMask);
-
- free(uncompressedStream);
-
- return bitmap;
-}
-
-SkBitmap getSmaskFromObject(PdfContext* pdfContext, const SkPdfImageDictionary* obj) {
- const PdfObject* sMask = resolveReferenceObject(&pdfContext->fPdfDoc->podofo(),
- obj->podofo()->GetDictionary().GetKey(PdfName("SMask")));
-
-#ifdef PDF_TRACE
- std::string str;
- if (sMask) {
- sMask->ToString(str);
- printf("/SMask of /Subtype /Image: %s\n", str.c_str());
- }
-#endif
-
- if (sMask) {
- SkPdfImageDictionary skxobjmask(&pdfContext->fPdfDoc->podofo(), sMask);
- return getImageFromObject(pdfContext, &skxobjmask, true);
- }
-
- // TODO(edisonn): implement GS SMask. Default to empty right now.
- return pdfContext->fGraphicsState.fSMask;
-}
-
-PdfResult doXObject_Image(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfImageDictionary* skpdfimage) {
- if (skpdfimage == NULL || !skpdfimage->valid()) {
- return kIgnoreError_PdfResult;
- }
-
- SkBitmap image = getImageFromObject(pdfContext, skpdfimage, false);
- SkBitmap sMask = getSmaskFromObject(pdfContext, skpdfimage);
-
- canvas->save();
- canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
- SkRect dst = SkRect::MakeXYWH(SkDoubleToScalar(0.0), SkDoubleToScalar(0.0), SkDoubleToScalar(1.0), SkDoubleToScalar(1.0));
-
- if (sMask.empty()) {
- canvas->drawBitmapRect(image, dst, NULL);
- } else {
- canvas->saveLayer(&dst, NULL);
- canvas->drawBitmapRect(image, dst, NULL);
- SkPaint xfer;
- pdfContext->fGraphicsState.applyGraphicsState(&xfer, false);
- xfer.setXfermodeMode(SkXfermode::kSrcOut_Mode); // SkXfermode::kSdtOut_Mode
- canvas->drawBitmapRect(sMask, dst, &xfer);
- canvas->restore();
- }
-
- canvas->restore();
-
- return kPartial_PdfResult;
-}
-
-bool SkMatrixFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- SkMatrix** matrix) {
- const PdfObject* value = resolveReferenceObject(pdfDoc,
- dict.GetKey(PdfName(key)));
-
- if (value == NULL || !value->IsArray()) {
- return false;
- }
-
- if (value->GetArray().GetSize() != 6) {
- return false;
- }
-
- double array[6];
- for (int i = 0; i < 6; i++) {
- const PdfObject* elem = resolveReferenceObject(pdfDoc, &value->GetArray()[i]);
- if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
- return false;
- }
- array[i] = elem->GetReal();
- }
-
- *matrix = new SkMatrix();
- **matrix = SkMatrixFromPdfMatrix(array);
- return true;
-}
-
-bool SkMatrixFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- SkMatrix** data) {
- if (SkMatrixFromDictionary(pdfDoc, dict, key, data)) return true;
- if (abr == NULL || *abr == '\0') return false;
- return SkMatrixFromDictionary(pdfDoc, dict, abr, data);
-
-}
-
-bool SkRectFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- SkRect** rect) {
- const PdfObject* value = resolveReferenceObject(pdfDoc,
- dict.GetKey(PdfName(key)));
-
- if (value == NULL || !value->IsArray()) {
- return false;
- }
-
- if (value->GetArray().GetSize() != 4) {
- return false;
- }
-
- double array[4];
- for (int i = 0; i < 4; i++) {
- const PdfObject* elem = resolveReferenceObject(pdfDoc, &value->GetArray()[i]);
- if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
- return false;
- }
- array[i] = elem->GetReal();
- }
-
- *rect = new SkRect();
- **rect = SkRect::MakeLTRB(SkDoubleToScalar(array[0]),
- SkDoubleToScalar(array[1]),
- SkDoubleToScalar(array[2]),
- SkDoubleToScalar(array[3]));
- return true;
-}
-
-bool SkRectFromDictionary(const PdfMemDocument* pdfDoc,
- const PdfDictionary& dict,
- const char* key,
- const char* abr,
- SkRect** data) {
- if (SkRectFromDictionary(pdfDoc, dict, key, data)) return true;
- if (abr == NULL || *abr == '\0') return false;
- return SkRectFromDictionary(pdfDoc, dict, abr, data);
-
-}
-
-
-SkPdfObject* get(const SkPdfObject* obj, const char* key, const char* abr = "") {
- SkPdfObject* ret = NULL;
- if (obj == NULL) return NULL;
- const SkPdfDictionary* dict = obj->asDictionary();
- if (dict == NULL) return NULL;
- if (!dict->podofo()->IsDictionary()) return NULL;
- ObjectFromDictionary(dict->doc(), dict->podofo()->GetDictionary(), key, abr, &ret);
- return ret;
-}
-
-PdfResult doXObject_Form(PdfContext* pdfContext, SkCanvas* canvas, SkPdfType1FormDictionary* skobj) {
- if (!skobj || !skobj->podofo() || !skobj->podofo()->HasStream() || skobj->podofo()->GetStream() == NULL || skobj->podofo()->GetStream()->GetLength() == 0) {
- return kOK_PdfResult;
- }
-
- PdfOp_q(pdfContext, canvas, NULL);
- canvas->save();
-
-
- if (skobj->Resources()) {
- pdfContext->fGraphicsState.fResources = skobj->Resources();
- }
-
- SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Current matrix");
-
- if (skobj->Matrix()) {
- pdfContext->fGraphicsState.fMatrix.preConcat(*skobj->Matrix());
- pdfContext->fGraphicsState.fMatrixTm = pdfContext->fGraphicsState.fMatrix;
- pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix;
- // TODO(edisonn) reset matrixTm and matricTlm also?
- }
-
- SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Total matrix");
-
- canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
-
- if (skobj->BBox()) {
- canvas->clipRect(*skobj->BBox(), SkRegion::kIntersect_Op, true); // TODO(edisonn): AA from settings.
- }
-
- // TODO(edisonn): iterate smart on the stream even if it is compressed, tokenize it as we go.
- // For this PdfContentsTokenizer needs to be extended.
-
- PdfResult ret = kPartial_PdfResult;
- SkPdfTokenizer tokenizer(skobj);
- PdfMainLooper looper(NULL, &tokenizer, pdfContext, canvas);
- looper.loop();
-
- // TODO(edisonn): should we restore the variable stack at the same state?
- // There could be operands left, that could be consumed by a parent tokenizer when we pop.
- canvas->restore();
- PdfOp_Q(pdfContext, canvas, NULL);
- return ret;
-}
-
-PdfResult doXObject_PS(PdfContext* pdfContext, SkCanvas* canvas, const PdfObject& obj) {
- return kNYI_PdfResult;
-}
-
-PdfResult doType3Char(PdfContext* pdfContext, SkCanvas* canvas, SkPdfObject* skobj, SkRect bBox, SkMatrix matrix, double textSize) {
- if (!skobj || !skobj->podofo() || !skobj->podofo()->HasStream() || skobj->podofo()->GetStream() == NULL || skobj->podofo()->GetStream()->GetLength() == 0) {
- return kOK_PdfResult;
- }
-
- PdfOp_q(pdfContext, canvas, NULL);
- canvas->save();
-
- pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
- pdfContext->fGraphicsState.fMatrixTm.preScale(SkDoubleToScalar(textSize), SkDoubleToScalar(textSize));
-
- pdfContext->fGraphicsState.fMatrix = pdfContext->fGraphicsState.fMatrixTm;
- pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix;
-
- SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Total matrix");
-
- canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
-
- SkRect rm = bBox;
- pdfContext->fGraphicsState.fMatrix.mapRect(&rm);
-
- SkTraceRect(rm, "bbox mapped");
-
- canvas->clipRect(bBox, SkRegion::kIntersect_Op, true); // TODO(edisonn): AA from settings.
-
- // TODO(edisonn): iterate smart on the stream even if it is compressed, tokenize it as we go.
- // For this PdfContentsTokenizer needs to be extended.
-
- PdfResult ret = kPartial_PdfResult;
- SkPdfTokenizer tokenizer(skobj);
- PdfMainLooper looper(NULL, &tokenizer, pdfContext, canvas);
- looper.loop();
-
- // TODO(edisonn): should we restore the variable stack at the same state?
- // There could be operands left, that could be consumed by a parent tokenizer when we pop.
- canvas->restore();
- PdfOp_Q(pdfContext, canvas, NULL);
- return ret;
-}
-
-
-// TODO(edisonn): faster, have the property on the SkPdfObject itself?
-std::set<const PdfObject*> gInRendering;
-
-class CheckRecursiveRendering {
- const PdfObject& fObj;
-public:
- CheckRecursiveRendering(const PdfObject& obj) : fObj(obj) {
- gInRendering.insert(&obj);
- }
-
- ~CheckRecursiveRendering() {
- //SkASSERT(fObj.fInRendering);
- gInRendering.erase(&fObj);
- }
-
- static bool IsInRendering(const PdfObject& obj) {
- return gInRendering.find(&obj) != gInRendering.end();
- }
-};
-
-PdfResult doXObject(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfObject& obj) {
- if (CheckRecursiveRendering::IsInRendering(*obj.podofo())) {
- // Oops, corrupt PDF!
- return kIgnoreError_PdfResult;
- }
-
- CheckRecursiveRendering checkRecursion(*obj.podofo());
-
- // TODO(edisonn): check type
- SkPdfXObjectDictionary* skobj = NULL;
- if (!PodofoMapper::map(obj, &skobj)) return kIgnoreError_PdfResult;
-
- if (!skobj || !skobj->valid()) return kIgnoreError_PdfResult;
-
- PdfResult ret = kIgnoreError_PdfResult;
- switch (skobj->getType())
- {
- case kImageDictionary_SkPdfObjectType:
- ret = doXObject_Image(pdfContext, canvas, skobj->asImageDictionary());
- break;
- case kType1FormDictionary_SkPdfObjectType:
- ret = doXObject_Form(pdfContext, canvas, skobj->asType1FormDictionary());
- break;
- //case kObjectDictionaryXObjectPS_SkPdfObjectType:
- //return doXObject_PS(skxobj.asPS());
- }
-
- delete skobj;
- return ret;
-}
-
-PdfResult PdfOp_q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fStateStack.push(pdfContext->fGraphicsState);
- canvas->save();
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_Q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fGraphicsState = pdfContext->fStateStack.top();
- pdfContext->fStateStack.pop();
- canvas->restore();
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_cm(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- double array[6];
- for (int i = 0 ; i < 6 ; i++) {
- array[5 - i] = pdfContext->fObjectStack.top()->asNumber()->value();
- pdfContext->fObjectStack.pop();
- }
-
- // a b
- // c d
- // e f
-
- // 0 1
- // 2 3
- // 4 5
-
- // sx ky
- // kx sy
- // tx ty
- SkMatrix matrix = SkMatrixFromPdfMatrix(array);
-
- pdfContext->fGraphicsState.fMatrix.preConcat(matrix);
-
-#ifdef PDF_TRACE
- printf("cm ");
- for (int i = 0 ; i < 6 ; i++) {
- printf("%f ", array[i]);
- }
- printf("\n");
- SkTraceMatrix(pdfContext->fGraphicsState.fMatrix);
-#endif
-
- return kOK_PdfResult;
-}
-
-//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.
-PdfResult PdfOp_TL(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- double ty = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- pdfContext->fGraphicsState.fTextLeading = ty;
-
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_Td(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- double ty = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double tx = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- double array[6] = {1, 0, 0, 1, tx, ty};
- SkMatrix matrix = SkMatrixFromPdfMatrix(array);
-
- pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
- pdfContext->fGraphicsState.fMatrixTlm.preConcat(matrix);
-
- return kPartial_PdfResult;
-}
-
-PdfResult PdfOp_TD(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- double ty = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double tx = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- // TODO(edisonn): Create factory methods or constructors so podofo is hidden
- PdfObject _ty(PdfVariant(-ty));
- pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc->podofo(), &_ty));
-
- PdfOp_TL(pdfContext, canvas, looper);
-
- PdfObject vtx(PdfVariant(-(-tx))); // TODO(edisonn): Hmm, the compiler thinks I have here a function pointer if we use (tx), but not -(-tx)
- pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc->podofo(), &vtx));
-
- PdfObject vty(PdfVariant(-(-ty)));
- pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc->podofo(), &vty));
-
- return PdfOp_Td(pdfContext, canvas, looper);
-}
-
-PdfResult PdfOp_Tm(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- double f = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double e = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double d = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double c = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double b = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double a = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- double array[6];
- array[0] = a;
- array[1] = b;
- array[2] = c;
- array[3] = d;
- array[4] = e;
- array[5] = f;
-
- SkMatrix matrix = SkMatrixFromPdfMatrix(array);
- matrix.postConcat(pdfContext->fGraphicsState.fMatrix);
-
- // TODO(edisonn): Text positioning.
- pdfContext->fGraphicsState.fMatrixTm = matrix;
- pdfContext->fGraphicsState.fMatrixTlm = matrix;;
-
- return kPartial_PdfResult;
-}
-
-//— 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
-PdfResult PdfOp_T_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- PdfObject zero(PdfVariant(0.0));
- PdfObject tl(PdfVariant(-(-pdfContext->fGraphicsState.fTextLeading)));
-
- pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc->podofo(), &zero));
- pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc->podofo(), &tl));
- return PdfOp_Td(pdfContext, canvas, looper);
-}
-
-PdfResult PdfOp_m(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- if (pdfContext->fGraphicsState.fPathClosed) {
- pdfContext->fGraphicsState.fPath.reset();
- pdfContext->fGraphicsState.fPathClosed = false;
- }
-
- pdfContext->fGraphicsState.fCurPosY = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- pdfContext->fGraphicsState.fCurPosX = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- pdfContext->fGraphicsState.fPath.moveTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX),
- SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY));
-
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_l(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- if (pdfContext->fGraphicsState.fPathClosed) {
- pdfContext->fGraphicsState.fPath.reset();
- pdfContext->fGraphicsState.fPathClosed = false;
- }
-
- pdfContext->fGraphicsState.fCurPosY = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- pdfContext->fGraphicsState.fCurPosX = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- pdfContext->fGraphicsState.fPath.lineTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX),
- SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY));
-
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_c(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- if (pdfContext->fGraphicsState.fPathClosed) {
- pdfContext->fGraphicsState.fPath.reset();
- pdfContext->fGraphicsState.fPathClosed = false;
- }
-
- double y3 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double x3 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double y2 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double x2 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double y1 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double x1 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1),
- SkDoubleToScalar(x2), SkDoubleToScalar(y2),
- SkDoubleToScalar(x3), SkDoubleToScalar(y3));
-
- pdfContext->fGraphicsState.fCurPosX = x3;
- pdfContext->fGraphicsState.fCurPosY = y3;
-
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_v(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- if (pdfContext->fGraphicsState.fPathClosed) {
- pdfContext->fGraphicsState.fPath.reset();
- pdfContext->fGraphicsState.fPathClosed = false;
- }
-
- double y3 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double x3 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double y2 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double x2 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double y1 = pdfContext->fGraphicsState.fCurPosY;
- double x1 = pdfContext->fGraphicsState.fCurPosX;
-
- pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1),
- SkDoubleToScalar(x2), SkDoubleToScalar(y2),
- SkDoubleToScalar(x3), SkDoubleToScalar(y3));
-
- pdfContext->fGraphicsState.fCurPosX = x3;
- pdfContext->fGraphicsState.fCurPosY = y3;
-
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_y(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- if (pdfContext->fGraphicsState.fPathClosed) {
- pdfContext->fGraphicsState.fPath.reset();
- pdfContext->fGraphicsState.fPathClosed = false;
- }
-
- double y3 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double x3 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double y2 = pdfContext->fGraphicsState.fCurPosY;
- double x2 = pdfContext->fGraphicsState.fCurPosX;
- double y1 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double x1 = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1),
- SkDoubleToScalar(x2), SkDoubleToScalar(y2),
- SkDoubleToScalar(x3), SkDoubleToScalar(y3));
-
- pdfContext->fGraphicsState.fCurPosX = x3;
- pdfContext->fGraphicsState.fCurPosY = y3;
-
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_re(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- if (pdfContext->fGraphicsState.fPathClosed) {
- pdfContext->fGraphicsState.fPath.reset();
- pdfContext->fGraphicsState.fPathClosed = false;
- }
-
- double height = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double width = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double y = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double x = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- pdfContext->fGraphicsState.fPath.addRect(SkDoubleToScalar(x), SkDoubleToScalar(y),
- SkDoubleToScalar(x + width), SkDoubleToScalar(y + height));
-
- pdfContext->fGraphicsState.fCurPosX = x;
- pdfContext->fGraphicsState.fCurPosY = y + height;
-
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_h(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fGraphicsState.fPath.close();
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_fillAndStroke(PdfContext* pdfContext, SkCanvas* canvas, bool fill, bool stroke, bool close, bool evenOdd) {
- SkPath path = pdfContext->fGraphicsState.fPath;
-
- if (close) {
- path.close();
- }
-
- canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
-
- SkPaint paint;
-
- SkPoint line[2];
- if (fill && !stroke && path.isLine(line)) {
- paint.setStyle(SkPaint::kStroke_Style);
-
- pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
- paint.setStrokeWidth(SkDoubleToScalar(0));
-
- canvas->drawPath(path, paint);
- } else {
- if (fill) {
- paint.setStyle(SkPaint::kFill_Style);
- if (evenOdd) {
- path.setFillType(SkPath::kEvenOdd_FillType);
- }
-
- pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
-
- canvas->drawPath(path, paint);
- }
-
- if (stroke) {
- paint.setStyle(SkPaint::kStroke_Style);
-
- pdfContext->fGraphicsState.applyGraphicsState(&paint, true);
-
- path.setFillType(SkPath::kWinding_FillType); // reset it, just in case it messes up the stroke
- canvas->drawPath(path, paint);
- }
- }
-
- pdfContext->fGraphicsState.fPath.reset();
- // todo zoom ... other stuff ?
-
- if (pdfContext->fGraphicsState.fHasClipPathToApply) {
-#ifndef PDF_DEBUG_NO_CLIPING
- canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true);
-#endif
- }
-
- //pdfContext->fGraphicsState.fClipPath.reset();
- pdfContext->fGraphicsState.fHasClipPathToApply = false;
-
- return kPartial_PdfResult;
-
-}
-
-PdfResult PdfOp_S(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_fillAndStroke(pdfContext, canvas, false, true, false, false);
-}
-
-PdfResult PdfOp_s(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_fillAndStroke(pdfContext, canvas, false, true, true, false);
-}
-
-PdfResult PdfOp_F(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
-}
-
-PdfResult PdfOp_f(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
-}
-
-PdfResult PdfOp_f_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, true);
-}
-
-PdfResult PdfOp_B(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, false);
-}
-
-PdfResult PdfOp_B_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, true);
-}
-
-PdfResult PdfOp_b(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, false);
-}
-
-PdfResult PdfOp_b_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, true);
-}
-
-PdfResult PdfOp_n(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
- if (pdfContext->fGraphicsState.fHasClipPathToApply) {
-#ifndef PDF_DEBUG_NO_CLIPING
- canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true);
-#endif
- }
-
- //pdfContext->fGraphicsState.fClipPath.reset();
- pdfContext->fGraphicsState.fHasClipPathToApply = false;
-
- pdfContext->fGraphicsState.fPathClosed = true;
-
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_BT(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fGraphicsState.fTextBlock = true;
- pdfContext->fGraphicsState.fMatrixTm = pdfContext->fGraphicsState.fMatrix;
- pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix;
-
- return kPartial_PdfResult;
-}
-
-PdfResult PdfOp_ET(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- if (!pdfContext->fGraphicsState.fTextBlock) {
- return kIgnoreError_PdfResult;
- }
- // TODO(edisonn): anything else to be done once we are done with draw text? Like restore stack?
- return kPartial_PdfResult;
-}
-
-//font size Tf Set the text font, Tf
-//, to font and the text font size, Tfs, to size. font is the name of a
-//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.
-PdfResult PdfOp_Tf(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fGraphicsState.fCurFontSize = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- std::string fontName = pdfContext->fObjectStack.top()->asName()->value(); pdfContext->fObjectStack.pop();
-
-#ifdef PDF_TRACE
- printf("font name: %s\n", fontName.c_str());
- std::string str;
- pdfContext->fGraphicsState.fResources->podofo()->ToString(str);
- printf("Print Tf Resources: %s\n", str.c_str());
- pdfContext->fGraphicsState.fResources->Font()->podofo()->ToString(str);
- printf("Print Tf Resources/Font: %s\n", str.c_str());
-#endif
-
- SkPdfFontDictionary* fd = NULL;
- if (pdfContext->fGraphicsState.fResources->Font()) {
- SkPdfObject* objFont = pdfContext->fGraphicsState.fResources->Font()->get(fontName.c_str());
- PodofoMapper::map(*objFont, &fd);
-
-#ifdef PDF_TRACE
- objFont->podofo()->ToString(str);
- printf("Print Font loaded: %s\n", str.c_str());
- fd->podofo()->ToString(str);
- printf("Print Font loaded and resolved and upgraded: %s\n", str.c_str());
-#endif
-
- }
-
- SkPdfFont* skfont = SkPdfFont::fontFromPdfDictionary(fd);
-
- if (skfont) {
- pdfContext->fGraphicsState.fSkFont = skfont;
- }
-
- return kPartial_PdfResult;
-}
-
-PdfResult PdfOp_Tj(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- if (!pdfContext->fGraphicsState.fTextBlock) {
- // TODO(edisonn): try to recover and draw it any way?
- return kIgnoreError_PdfResult;
- }
-
- PdfResult ret = DrawText(pdfContext,
- pdfContext->fObjectStack.top(),
- canvas);
- pdfContext->fObjectStack.pop();
-
- return ret;
-}
-
-PdfResult PdfOp_quote(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- if (!pdfContext->fGraphicsState.fTextBlock) {
- // TODO(edisonn): try to recover and draw it any way?
- return kIgnoreError_PdfResult;
- }
-
- PdfOp_T_star(pdfContext, canvas, looper);
- // Do not pop, and push, just transfer the param to Tj
- return PdfOp_Tj(pdfContext, canvas, looper);
-}
-
-PdfResult PdfOp_doublequote(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- if (!pdfContext->fGraphicsState.fTextBlock) {
- // TODO(edisonn): try to recover and draw it any way?
- return kIgnoreError_PdfResult;
- }
-
- SkPdfObject* str = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
- SkPdfObject* ac = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
- SkPdfObject* aw = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop();
-
- pdfContext->fObjectStack.push(aw);
- PdfOp_Tw(pdfContext, canvas, looper);
-
- pdfContext->fObjectStack.push(ac);
- PdfOp_Tc(pdfContext, canvas, looper);
-
- pdfContext->fObjectStack.push(str);
- PdfOp_quote(pdfContext, canvas, looper);
-
- return kPartial_PdfResult;
-}
-
-PdfResult PdfOp_TJ(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- if (!pdfContext->fGraphicsState.fTextBlock) {
- // TODO(edisonn): try to recover and draw it any way?
- return kIgnoreError_PdfResult;
- }
-
- SkPdfArray* array = pdfContext->fObjectStack.top()->asArray();
- pdfContext->fObjectStack.pop();
-
- for( int i=0; i<static_cast<int>(array->size()); i++ )
- {
- if( (*array)[i]->asString()) {
- SkPdfObject* obj = (*array)[i];
- DrawText(pdfContext,
- obj,
- canvas);
- } else if ((*array)[i]->asInteger() || (*array)[i]->asNumber()) {
- double dx = (*array)[i]->asNumber()->value();
- SkMatrix matrix;
- matrix.setAll(SkDoubleToScalar(1),
- SkDoubleToScalar(0),
- // TODO(edisonn): use writing mode, vertical/horizontal.
- SkDoubleToScalar(-dx), // amount is substracted!!!
- SkDoubleToScalar(0),
- SkDoubleToScalar(1),
- SkDoubleToScalar(0),
- SkDoubleToScalar(0),
- SkDoubleToScalar(0),
- SkDoubleToScalar(1));
-
- pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
- }
- }
- return kPartial_PdfResult; // TODO(edisonn): Implement fully DrawText before returing OK.
-}
-
-PdfResult PdfOp_CS_cs(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
- colorOperator->fColorSpace = pdfContext->fObjectStack.top()->asName()->value(); pdfContext->fObjectStack.pop();
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_CS(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
-}
-
-PdfResult PdfOp_cs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
-}
-
-PdfResult PdfOp_SC_sc(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
- double c[4];
- pdf_int64 v[4];
-
- int n = GetColorSpaceComponents(colorOperator->fColorSpace);
-
- bool doubles = true;
- if (colorOperator->fColorSpace == "Indexed") {
- doubles = false;
- }
-
-#ifdef PDF_TRACE
- printf("color space = %s, N = %i\n", colorOperator->fColorSpace.c_str(), n);
-#endif
-
- for (int i = n - 1; i >= 0 ; i--) {
- if (doubles) {
- c[i] = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- } else {
- v[i] = pdfContext->fObjectStack.top()->asInteger()->value(); pdfContext->fObjectStack.pop();
- }
- }
-
- // TODO(edisonn): Now, set that color. Only DeviceRGB supported.
- if (colorOperator->fColorSpace == "DeviceRGB") {
- colorOperator->setRGBColor(SkColorSetRGB(255*c[0], 255*c[1], 255*c[2]));
- }
- return kPartial_PdfResult;
-}
-
-PdfResult PdfOp_SC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
-}
-
-PdfResult PdfOp_sc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
-}
-
-PdfResult PdfOp_SCN_scn(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
- PdfString name;
-
- if (pdfContext->fObjectStack.top()->asName()) {
- pdfContext->fObjectStack.pop();
- }
-
- // TODO(edisonn): SCN supports more color spaces than SCN. Read and implement spec.
- PdfOp_SC_sc(pdfContext, canvas, colorOperator);
-
- return kPartial_PdfResult;
-}
-
-PdfResult PdfOp_SCN(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
-}
-
-PdfResult PdfOp_scn(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
-}
-
-PdfResult PdfOp_G_g(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
- double gray = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- return kNYI_PdfResult;
-}
-
-PdfResult PdfOp_G(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
-}
-
-PdfResult PdfOp_g(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
-}
-
-PdfResult PdfOp_RG_rg(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
- double b = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double g = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double r = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- colorOperator->fColorSpace = "DeviceRGB";
- colorOperator->setRGBColor(SkColorSetRGB(255*r, 255*g, 255*b));
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_RG(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
-}
-
-PdfResult PdfOp_rg(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
-}
-
-PdfResult PdfOp_K_k(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
- // TODO(edisonn): spec has some rules about overprint, implement them.
- double k = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double y = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double m = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- double c = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- colorOperator->fColorSpace = "DeviceCMYK";
- // TODO(edisonn): Set color.
- return kNYI_PdfResult;
-}
-
-PdfResult PdfOp_K(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
-}
-
-PdfResult PdfOp_k(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
-}
-
-PdfResult PdfOp_W(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
- pdfContext->fGraphicsState.fHasClipPathToApply = true;
-
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_W_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
-
-#ifdef PDF_TRACE
- if (pdfContext->fGraphicsState.fClipPath.isRect(NULL)) {
- printf("CLIP IS RECT\n");
- }
-#endif
-
- // TODO(edisonn): there seem to be a bug with clipPath of a rect with even odd.
- pdfContext->fGraphicsState.fClipPath.setFillType(SkPath::kEvenOdd_FillType);
- pdfContext->fGraphicsState.fHasClipPathToApply = true;
-
- return kPartial_PdfResult;
-}
-
-PdfResult PdfOp_BX(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- *looper = new PdfCompatibilitySectionLooper();
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_EX(PdfContext* 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;
-}
-
-PdfResult PdfOp_BI(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- *looper = new PdfInlineImageLooper();
- return kOK_PdfResult;
-}
-
-PdfResult PdfOp_ID(PdfContext* 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;
-}
-
-PdfResult PdfOp_EI(PdfContext* 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;
-}
-
-//lineWidth w Set the line width in the graphics state (see “Line Width” on page 152).
-PdfResult PdfOp_w(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- double lineWidth = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- pdfContext->fGraphicsState.fLineWidth = lineWidth;
-
- return kOK_PdfResult;
-}
-
-//lineCap J Set the line cap style in the graphics state (see “Line Cap Style” on page 153).
-PdfResult PdfOp_J(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
- //double lineCap = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//lineJoin j Set the line join style in the graphics state (see “Line Join Style” on page 153).
-PdfResult PdfOp_j(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
- //double lineJoin = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//miterLimit M Set the miter limit in the graphics state (see “Miter Limit” on page 153).
-PdfResult PdfOp_M(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
- //double miterLimit = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//dashArray dashPhase d Set the line dash pattern in the graphics state (see “Line Dash Pattern” on
-//page 155).
-PdfResult PdfOp_d(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
- pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//intent ri (PDF 1.1) Set the color rendering intent in the graphics state (see “Rendering Intents” on page 197).
-PdfResult PdfOp_ri(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//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.
-PdfResult PdfOp_i(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//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).
-PdfResult PdfOp_gs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- std::string name = pdfContext->fObjectStack.top()->asName()->value(); pdfContext->fObjectStack.pop();
-
-#ifdef PDF_TRACE
- std::string str;
-#endif
-
- //Next, get the ExtGState Dictionary from the Resource Dictionary:
- const SkPdfDictionary* extGStateDictionary = pdfContext->fGraphicsState.fResources->ExtGState();
-
- if (extGStateDictionary == NULL) {
-#ifdef PDF_TRACE
- printf("ExtGState is NULL!\n");
-#endif
- return kIgnoreError_PdfResult;
- }
-
- SkPdfObject* value = extGStateDictionary->get(name.c_str());
-
-#ifdef PDF_TRACE
-// value->ToString(str);
-// printf("gs object value: %s\n", str.c_str());
-#endif
-
- SkPdfGraphicsStateDictionary* gs = NULL;
- PodofoMapper::map(*value, &gs);
-
- // TODO(edisonn): now load all those properties in graphic state.
- if (gs == NULL) {
- return kIgnoreError_PdfResult;
- }
-
- if (gs->has_CA()) {
- pdfContext->fGraphicsState.fStroking.fOpacity = gs->CA();
- }
-
- if (gs->has_ca()) {
- pdfContext->fGraphicsState.fNonStroking.fOpacity = gs->ca();
- }
-
- if (gs->has_LW()) {
- pdfContext->fGraphicsState.fLineWidth = gs->LW();
- }
-
-
-
- return kNYI_PdfResult;
-}
-
-//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) {
- double charSpace = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- pdfContext->fGraphicsState.fCharSpace = charSpace;
-
- return kOK_PdfResult;
-}
-
-//wordSpace Tw Set the word spacing, T
-//w
-//, 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) {
- double wordSpace = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
- pdfContext->fGraphicsState.fWordSpace = wordSpace;
-
- return kOK_PdfResult;
-}
-
-//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).
-PdfResult PdfOp_Tz(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- double scale = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//render Tr Set the text rendering mode, T
-//mode, to render, which is an integer. Initial value: 0.
-PdfResult PdfOp_Tr(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- double render = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-//rise Ts Set the text rise, Trise, to rise, which is a number expressed in unscaled text space
-//units. Initial value: 0.
-PdfResult PdfOp_Ts(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- double rise = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//wx wy d0
-PdfResult PdfOp_d0(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
- pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//wx wy llx lly urx ury d1
-PdfResult PdfOp_d1(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
- pdfContext->fObjectStack.pop();
- pdfContext->fObjectStack.pop();
- pdfContext->fObjectStack.pop();
- pdfContext->fObjectStack.pop();
- pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//name sh
-PdfResult PdfOp_sh(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//name Do
-PdfResult PdfOp_Do(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- std::string name = pdfContext->fObjectStack.top()->asName()->value(); pdfContext->fObjectStack.pop();
-
- SkPdfDictionary* xObject = pdfContext->fGraphicsState.fResources->XObject();
-
- if (xObject == NULL) {
-#ifdef PDF_TRACE
- printf("XObject is NULL!\n");
-#endif
- return kIgnoreError_PdfResult;
- }
-
- SkPdfObject* value = xObject->get(name.c_str());
-
-#ifdef PDF_TRACE
-// value->ToString(str);
-// printf("Do object value: %s\n", str.c_str());
-#endif
-
- return doXObject(pdfContext, canvas, *value);
-}
-
-//tag MP Designate a marked-content point. tag is a name object indicating the role or
-//significance of the point.
-PdfResult PdfOp_MP(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//tag properties DP Designate a marked-content point with an associated property list. tag is a
-//name object indicating the role or significance of the point; properties is
-//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”).
-PdfResult PdfOp_DP(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
- pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//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.
-PdfResult PdfOp_BMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//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”).
-PdfResult PdfOp_BDC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- pdfContext->fObjectStack.pop();
- pdfContext->fObjectStack.pop();
-
- return kNYI_PdfResult;
-}
-
-//— EMC End a marked-content sequence begun by a BMC or BDC operator.
-PdfResult PdfOp_EMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
- return kNYI_PdfResult;
-}
-
-void initPdfOperatorRenderes() {
- static bool gInitialized = false;
- if (gInitialized) {
- return;
- }
-
- gPdfOps["q"] = PdfOp_q;
- gPdfOps["Q"] = PdfOp_Q;
- gPdfOps["cm"] = PdfOp_cm;
-
- gPdfOps["TD"] = PdfOp_TD;
- gPdfOps["Td"] = PdfOp_Td;
- gPdfOps["Tm"] = PdfOp_Tm;
- gPdfOps["T*"] = PdfOp_T_star;
-
- gPdfOps["m"] = PdfOp_m;
- gPdfOps["l"] = PdfOp_l;
- gPdfOps["c"] = PdfOp_c;
- gPdfOps["v"] = PdfOp_v;
- gPdfOps["y"] = PdfOp_y;
- gPdfOps["h"] = PdfOp_h;
- gPdfOps["re"] = PdfOp_re;
-
- gPdfOps["S"] = PdfOp_S;
- gPdfOps["s"] = PdfOp_s;
- gPdfOps["f"] = PdfOp_f;
- gPdfOps["F"] = PdfOp_F;
- gPdfOps["f*"] = PdfOp_f_star;
- gPdfOps["B"] = PdfOp_B;
- gPdfOps["B*"] = PdfOp_B_star;
- gPdfOps["b"] = PdfOp_b;
- gPdfOps["b*"] = PdfOp_b_star;
- gPdfOps["n"] = PdfOp_n;
-
- gPdfOps["BT"] = PdfOp_BT;
- gPdfOps["ET"] = PdfOp_ET;
-
- gPdfOps["Tj"] = PdfOp_Tj;
- gPdfOps["'"] = PdfOp_quote;
- gPdfOps["\""] = PdfOp_doublequote;
- gPdfOps["TJ"] = PdfOp_TJ;
-
- gPdfOps["CS"] = PdfOp_CS;
- gPdfOps["cs"] = PdfOp_cs;
- gPdfOps["SC"] = PdfOp_SC;
- gPdfOps["SCN"] = PdfOp_SCN;
- gPdfOps["sc"] = PdfOp_sc;
- gPdfOps["scn"] = PdfOp_scn;
- gPdfOps["G"] = PdfOp_G;
- gPdfOps["g"] = PdfOp_g;
- gPdfOps["RG"] = PdfOp_RG;
- gPdfOps["rg"] = PdfOp_rg;
- gPdfOps["K"] = PdfOp_K;
- gPdfOps["k"] = PdfOp_k;
-
- gPdfOps["W"] = PdfOp_W;
- gPdfOps["W*"] = PdfOp_W_star;
-
- gPdfOps["BX"] = PdfOp_BX;
- gPdfOps["EX"] = PdfOp_EX;
-
- gPdfOps["BI"] = PdfOp_BI;
- gPdfOps["ID"] = PdfOp_ID;
- gPdfOps["EI"] = PdfOp_EI;
-
- gPdfOps["w"] = PdfOp_w;
- gPdfOps["J"] = PdfOp_J;
- gPdfOps["j"] = PdfOp_j;
- gPdfOps["M"] = PdfOp_M;
- gPdfOps["d"] = PdfOp_d;
- gPdfOps["ri"] = PdfOp_ri;
- gPdfOps["i"] = PdfOp_i;
- gPdfOps["gs"] = PdfOp_gs;
-
- gPdfOps["Tc"] = PdfOp_Tc;
- gPdfOps["Tw"] = PdfOp_Tw;
- gPdfOps["Tz"] = PdfOp_Tz;
- gPdfOps["TL"] = PdfOp_TL;
- gPdfOps["Tf"] = PdfOp_Tf;
- gPdfOps["Tr"] = PdfOp_Tr;
- gPdfOps["Ts"] = PdfOp_Ts;
-
- gPdfOps["d0"] = PdfOp_d0;
- gPdfOps["d1"] = PdfOp_d1;
-
- gPdfOps["sh"] = PdfOp_sh;
-
- gPdfOps["Do"] = PdfOp_Do;
-
- gPdfOps["MP"] = PdfOp_MP;
- gPdfOps["DP"] = PdfOp_DP;
- gPdfOps["BMC"] = PdfOp_BMC;
- gPdfOps["BDC"] = PdfOp_BDC;
- gPdfOps["EMC"] = PdfOp_EMC;
-
- gInitialized = true;
-}
-
-void reportPdfRenderStats() {
- std::map<std::string, int>::iterator iter;
-
- for (int i = 0 ; i < kCount_PdfResult; i++) {
- for (iter = gRenderStats[i].begin(); iter != gRenderStats[i].end(); ++iter) {
- printf("%s: %s -> count %i\n", gRenderStatsNames[i], iter->first.c_str(), iter->second);
- }
- }
-}
-
-PdfResult PdfMainLooper::consumeToken(PdfToken& token) {
- if (token.fType == kKeyword_TokenType)
- {
- // TODO(edisonn): log trace flag (verbose, error, info, warning, ...)
- PdfOperatorRenderer pdfOperatorRenderer = gPdfOps[token.fKeyword];
- if (pdfOperatorRenderer) {
- // caller, main work is done by pdfOperatorRenderer(...)
- PdfTokenLooper* childLooper = NULL;
- gRenderStats[pdfOperatorRenderer(fPdfContext, fCanvas, &childLooper)][token.fKeyword]++;
-
- if (childLooper) {
- childLooper->setUp(this);
- childLooper->loop();
- delete childLooper;
- }
- } else {
- gRenderStats[kUnsupported_PdfResult][token.fKeyword]++;
- }
- }
- else if (token.fType == kObject_TokenType)
- {
- fPdfContext->fObjectStack.push( token.fObject );
- }
- else if ( token.fType == kImageData_TokenType) {
- // TODO(edisonn): implement inline image.
- }
- else {
- return kIgnoreError_PdfResult;
- }
- return kOK_PdfResult;
-}
-
-void PdfMainLooper::loop() {
- PdfToken token;
- while (readToken(fTokenizer, &token)) {
- consumeToken(token);
- }
-}
-
-PdfResult PdfInlineImageLooper::consumeToken(PdfToken& token) {
- //pdfContext.fInlineImage.fKeyValuePairs[key] = value;
- return kNYI_PdfResult;
-}
-
-void PdfInlineImageLooper::loop() {
- PdfToken token;
- while (readToken(fTokenizer, &token)) {
- if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) {
- PdfTokenLooper* looper = new PdfCompatibilitySectionLooper();
- looper->setUp(this);
- looper->loop();
- } else {
- if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EI") == 0) {
- done();
- return;
- }
-
- consumeToken(token);
- }
- }
- // TODO(edisonn): report error/warning, EOF without EI.
-}
-
-PdfResult PdfInlineImageLooper::done() {
-
- // TODO(edisonn): long to short names
- // TODO(edisonn): set properties in a map
- // TODO(edisonn): extract bitmap stream, check if PoDoFo has public utilities to uncompress
- // the stream.
-
- SkBitmap bitmap;
- setup_bitmap(&bitmap, 50, 50, SK_ColorRED);
-
- // TODO(edisonn): matrix use.
- // Draw dummy red square, to show the prezence of the inline image.
- fCanvas->drawBitmap(bitmap,
- SkDoubleToScalar(0),
- SkDoubleToScalar(0),
- NULL);
- return kNYI_PdfResult;
-}
-
-PdfResult PdfCompatibilitySectionLooper::consumeToken(PdfToken& token) {
- return fParent->consumeToken(token);
-}
-
-void PdfCompatibilitySectionLooper::loop() {
- // TODO(edisonn): save stacks position, or create a new stack?
- // TODO(edisonn): what happens if we pop out more variables then when we started?
- // restore them? fail? We could create a new operands stack for every new BX/EX section,
- // pop-ing too much will not affect outside the section.
- PdfToken token;
- while (readToken(fTokenizer, &token)) {
- if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) {
- PdfTokenLooper* looper = new PdfCompatibilitySectionLooper();
- looper->setUp(this);
- looper->loop();
- delete looper;
- } else {
- if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EX") == 0) break;
- fParent->consumeToken(token);
- }
- }
- // TODO(edisonn): restore stack.
-}
-
-// TODO(edisonn): fix PoDoFo load ~/crashing/Shading.pdf
-// TODO(edisonn): Add API for Forms viewing and editing
-// e.g. SkBitmap getPage(int page);
-// int formsCount();
-// SkForm getForm(int formID); // SkForm(SkRect, .. other data)
-// TODO (edisonn): Add intend when loading pdf, for example: for viewing, parsing all content, ...
-// if we load the first page, and we zoom to fit to screen horizontally, then load only those
-// resources needed, so the preview is fast.
-// TODO (edisonn): hide parser/tokenizer behind and interface and a query language, and resolve
-// references automatically.
-class SkPdfViewer : public SkRefCnt {
-public:
-
- bool load(const SkString inputFileName, SkPicture* out) {
-
- initPdfOperatorRenderes();
-
- try
- {
- std::cout << "Init: " << inputFileName.c_str() << std::endl;
-
- SkPdfDoc doc(inputFileName.c_str());
- if( !doc.pages() )
- {
- std::cout << "ERROR: Empty Document" << inputFileName.c_str() << std::endl;
- return false;
- } else {
-
- for (int pn = 0; pn < doc.pages(); ++pn) {
- SkPdfPageObjectDictionary* page = doc.page(pn);
-
- // TODO(edisonn): implement inheritance properties as per PDF spec
- //SkRect rect = page->MediaBox();
- SkRect rect = doc.MediaBox(pn);
-
-#ifdef PDF_TRACE
- printf("Page Width: %f, Page Height: %f\n", SkScalarToDouble(rect.width()), SkScalarToDouble(rect.height()));
-#endif
-
- // TODO(edisonn): page->GetCropBox(), page->GetTrimBox() ... how to use?
-
- SkBitmap bitmap;
-#ifdef PDF_DEBUG_3X
- setup_bitmap(&bitmap, 3 * (int)SkScalarToDouble(rect.width()), 3 * (int)SkScalarToDouble(rect.height()));
-#else
- setup_bitmap(&bitmap, (int)SkScalarToDouble(rect.width()), (int)SkScalarToDouble(rect.height()));
-#endif
- SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
- SkCanvas canvas(device);
-
- SkPdfTokenizer* tokenizer = doc.tokenizerOfPage(pn);
-
- PdfContext pdfContext(&doc);
- pdfContext.fOriginalMatrix = SkMatrix::I();
- pdfContext.fGraphicsState.fResources = NULL;
- PodofoMapper::map(*page->Resources(), &pdfContext.fGraphicsState.fResources);
-
- gPdfContext = &pdfContext;
- gDumpBitmap = &bitmap;
- gDumpCanvas = &canvas;
-
-
- // TODO(edisonn): get matrix stuff right.
- // TODO(edisonn): add DPI/scale/zoom.
- SkScalar z = SkIntToScalar(0);
- SkScalar w = rect.width();
- SkScalar h = rect.height();
-
- SkPoint pdfSpace[4] = {SkPoint::Make(z, z), SkPoint::Make(w, z), SkPoint::Make(w, h), SkPoint::Make(z, h)};
-// SkPoint skiaSpace[4] = {SkPoint::Make(z, h), SkPoint::Make(w, h), SkPoint::Make(w, z), SkPoint::Make(z, z)};
-
- // TODO(edisonn): add flag for this app to create sourunding buffer zone
- // TODO(edisonn): add flagg for no clipping.
- // Use larger image to make sure we do not draw anything outside of page
- // could be used in tests.
-
-#ifdef PDF_DEBUG_3X
- SkPoint skiaSpace[4] = {SkPoint::Make(w+z, h+h), SkPoint::Make(w+w, h+h), SkPoint::Make(w+w, h+z), SkPoint::Make(w+z, h+z)};
-#else
- SkPoint skiaSpace[4] = {SkPoint::Make(z, h), SkPoint::Make(w, h), SkPoint::Make(w, z), SkPoint::Make(z, z)};
-#endif
- //SkPoint pdfSpace[2] = {SkPoint::Make(z, z), SkPoint::Make(w, h)};
- //SkPoint skiaSpace[2] = {SkPoint::Make(w, z), SkPoint::Make(z, h)};
-
- //SkPoint pdfSpace[2] = {SkPoint::Make(z, z), SkPoint::Make(z, h)};
- //SkPoint skiaSpace[2] = {SkPoint::Make(z, h), SkPoint::Make(z, z)};
-
- //SkPoint pdfSpace[3] = {SkPoint::Make(z, z), SkPoint::Make(z, h), SkPoint::Make(w, h)};
- //SkPoint skiaSpace[3] = {SkPoint::Make(z, h), SkPoint::Make(z, z), SkPoint::Make(w, 0)};
-
- SkAssertResult(pdfContext.fOriginalMatrix.setPolyToPoly(pdfSpace, skiaSpace, 4));
- SkTraceMatrix(pdfContext.fOriginalMatrix, "Original matrix");
-
-
- pdfContext.fGraphicsState.fMatrix = pdfContext.fOriginalMatrix;
- pdfContext.fGraphicsState.fMatrixTm = pdfContext.fGraphicsState.fMatrix;
- pdfContext.fGraphicsState.fMatrixTlm = pdfContext.fGraphicsState.fMatrix;
-
- canvas.setMatrix(pdfContext.fOriginalMatrix);
-
-#ifndef PDF_DEBUG_NO_PAGE_CLIPING
- canvas.clipRect(SkRect::MakeXYWH(z, z, w, h), SkRegion::kIntersect_Op, true);
-#endif
-
- PdfMainLooper looper(NULL, tokenizer, &pdfContext, &canvas);
- looper.loop();
-
- delete tokenizer;
-
- canvas.flush();
-
- SkString out;
- out.appendf("%s-%i.png", inputFileName.c_str(), pn);
- SkImageEncoder::EncodeFile(out.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100);
- }
- return true;
- }
- }
- catch( PdfError & e )
- {
- std::cout << "ERROR: PDF can't be parsed!" << inputFileName.c_str() << std::endl;
- return false;
- }
-
- return true;
- }
- bool write(void*) const { return false; }
-};
-
-
-
/**
* Given list of directories and files to use as input, expects to find .pdf
* files and it will convert them to .png files writing them in the same directory
diff --git a/experimental/PdfViewer/spec2def.py b/experimental/PdfViewer/spec2def.py
index 6bebd87..dc78223 100644
--- a/experimental/PdfViewer/spec2def.py
+++ b/experimental/PdfViewer/spec2def.py
@@ -621,7 +621,7 @@
print 'def addDictionaryTypesTo(knowTypes):'
for e in tableToClassName:
- print(' knowTypes[\'' + tableToClassName[e][0] + '\'] = [\'SkPdf' + tableToClassName[e][0] + '*\', \'DictionaryFromDictionary2\', datatypes.CppNull(), \'ret->podofo()->GetDataType() == ePdfDataType_Dictionary\']')
+ print(' knowTypes[\'' + tableToClassName[e][0] + '\'] = [\'SkPdf' + tableToClassName[e][0] + '*\', \'' + tableToClassName[e][0] + 'FromDictionary\', datatypes.CppNull(), \'ret->podofo()->GetDataType() == ePdfDataType_Dictionary\']')
print
print
diff --git a/gyp/pdfviewer.gyp b/gyp/pdfviewer.gyp
index b8e605f..967002c 100644
--- a/gyp/pdfviewer.gyp
+++ b/gyp/pdfviewer.gyp
@@ -12,15 +12,19 @@
],
'targets': [
{
- 'target_name': 'pdfviewer',
- 'type': 'executable',
+ 'target_name': 'libpdfviewer',
+ 'type': 'static_library',
'cflags': ['-fexceptions'],
'cflags_cc': ['-fexceptions'],
'cflags!': [ '-fno-exceptions' ],
'cflags_cc!': [ '-fno-exceptions' ],
'sources': [
- '../experimental/PdfViewer/pdf_viewer_main.cpp',
- #'../experimental/PdfViewer/SkPdfFont.cpp',
+ '../experimental/PdfViewer/SkPdfBasics.cpp',
+ '../experimental/PdfViewer/SkPdfFont.cpp',
+ '../experimental/PdfViewer/SkPdfParser.cpp',
+ '../experimental/PdfViewer/SkPdfUtils.cpp',
+ '../experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.cpp',
+ '../experimental/PdfViewer/autogen/SkPdfHeaders_autogen.cpp',
],
'include_dirs': [
'../third_party/externals/podofo/src/base',
@@ -47,21 +51,30 @@
'BUILDING_PODOFO',
],
},
- ],
- 'conditions': [
- ['skia_os == "win"',
- {
- 'targets': [
- {
- 'target_name': 'win_lcid',
- 'type': 'executable',
- 'sources': [
- '../tools/win_lcid.cpp',
- ],
- },
- ],
- },
- ],
+ {
+ 'target_name': 'pdfviewer',
+ 'type': 'executable',
+ 'cflags': ['-fexceptions'],
+ 'cflags_cc': ['-fexceptions'],
+ 'cflags!': [ '-fno-exceptions' ],
+ 'cflags_cc!': [ '-fno-exceptions' ],
+ 'sources': [
+ '../experimental/PdfViewer/pdf_viewer_main.cpp',
+ ],
+ 'include_dirs': [
+ '../third_party/externals/podofo/src/base',
+ '../third_party/externals/podofo/src',
+ '../third_party/externals/podofo',
+ '../tools',
+ '../experimental/PdfViewer',
+ '../experimental/PdfViewer/autogen',
+ ],
+ 'dependencies': [
+ 'core.gyp:core',
+ 'images.gyp:images',
+ 'libpdfviewer',
+ ],
+ },
],
}