OLD | NEW |
| (Empty) |
1 #ifndef __DEFINED__SkPdfPodofoMapper | |
2 #define __DEFINED__SkPdfPodofoMapper | |
3 | |
4 #include "SkPdfHeaders_autogen.h" | |
5 class PodofoMapper { | |
6 public: | |
7 static bool map(const SkPdfObject& in, SkPdfObject** out) { | |
8 return map(*in.doc(), *in.podofo(), out); | |
9 } | |
10 | |
11 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfObject** out) { | |
12 if (!isObject(podofoDoc, podofoObj)) return false; | |
13 | |
14 if (map(podofoDoc, podofoObj, (SkPdfArray**)out)) return true; | |
15 if (map(podofoDoc, podofoObj, (SkPdfBoolean**)out)) return true; | |
16 if (map(podofoDoc, podofoObj, (SkPdfDictionary**)out)) return true; | |
17 if (map(podofoDoc, podofoObj, (SkPdfInteger**)out)) return true; | |
18 if (map(podofoDoc, podofoObj, (SkPdfName**)out)) return true; | |
19 if (map(podofoDoc, podofoObj, (SkPdfNull**)out)) return true; | |
20 if (map(podofoDoc, podofoObj, (SkPdfReference**)out)) return true; | |
21 if (map(podofoDoc, podofoObj, (SkPdfString**)out)) return true; | |
22 if (map(podofoDoc, podofoObj, (SkPdfStream**)out)) return true; | |
23 | |
24 *out = new SkPdfObject(&podofoDoc, &podofoObj); | |
25 return true; | |
26 } | |
27 | |
28 static bool map(const SkPdfObject& in, SkPdfNull** out) { | |
29 return map(*in.doc(), *in.podofo(), out); | |
30 } | |
31 | |
32 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfNull** out) { | |
33 if (!isNull(podofoDoc, podofoObj)) return false; | |
34 | |
35 | |
36 *out = new SkPdfNull(&podofoDoc, &podofoObj); | |
37 return true; | |
38 } | |
39 | |
40 static bool map(const SkPdfObject& in, SkPdfBoolean** out) { | |
41 return map(*in.doc(), *in.podofo(), out); | |
42 } | |
43 | |
44 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfBoolean** out) { | |
45 if (!isBoolean(podofoDoc, podofoObj)) return false; | |
46 | |
47 | |
48 *out = new SkPdfBoolean(&podofoDoc, &podofoObj); | |
49 return true; | |
50 } | |
51 | |
52 static bool map(const SkPdfObject& in, SkPdfInteger** out) { | |
53 return map(*in.doc(), *in.podofo(), out); | |
54 } | |
55 | |
56 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfInteger** out) { | |
57 if (!isInteger(podofoDoc, podofoObj)) return false; | |
58 | |
59 if (map(podofoDoc, podofoObj, (SkPdfNumber**)out)) return true; | |
60 | |
61 *out = new SkPdfInteger(&podofoDoc, &podofoObj); | |
62 return true; | |
63 } | |
64 | |
65 static bool map(const SkPdfObject& in, SkPdfNumber** out) { | |
66 return map(*in.doc(), *in.podofo(), out); | |
67 } | |
68 | |
69 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfNumber** out) { | |
70 if (!isNumber(podofoDoc, podofoObj)) return false; | |
71 | |
72 | |
73 *out = new SkPdfNumber(&podofoDoc, &podofoObj); | |
74 return true; | |
75 } | |
76 | |
77 static bool map(const SkPdfObject& in, SkPdfName** out) { | |
78 return map(*in.doc(), *in.podofo(), out); | |
79 } | |
80 | |
81 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfName** out) { | |
82 if (!isName(podofoDoc, podofoObj)) return false; | |
83 | |
84 | |
85 *out = new SkPdfName(&podofoDoc, &podofoObj); | |
86 return true; | |
87 } | |
88 | |
89 static bool map(const SkPdfObject& in, SkPdfReference** out) { | |
90 return map(*in.doc(), *in.podofo(), out); | |
91 } | |
92 | |
93 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfReference** out) { | |
94 if (!isReference(podofoDoc, podofoObj)) return false; | |
95 | |
96 | |
97 *out = new SkPdfReference(&podofoDoc, &podofoObj); | |
98 return true; | |
99 } | |
100 | |
101 static bool map(const SkPdfObject& in, SkPdfArray** out) { | |
102 return map(*in.doc(), *in.podofo(), out); | |
103 } | |
104 | |
105 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfArray** out) { | |
106 if (!isArray(podofoDoc, podofoObj)) return false; | |
107 | |
108 | |
109 *out = new SkPdfArray(&podofoDoc, &podofoObj); | |
110 return true; | |
111 } | |
112 | |
113 static bool map(const SkPdfObject& in, SkPdfString** out) { | |
114 return map(*in.doc(), *in.podofo(), out); | |
115 } | |
116 | |
117 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfString** out) { | |
118 if (!isString(podofoDoc, podofoObj)) return false; | |
119 | |
120 if (map(podofoDoc, podofoObj, (SkPdfHexString**)out)) return true; | |
121 | |
122 *out = new SkPdfString(&podofoDoc, &podofoObj); | |
123 return true; | |
124 } | |
125 | |
126 static bool map(const SkPdfObject& in, SkPdfHexString** out) { | |
127 return map(*in.doc(), *in.podofo(), out); | |
128 } | |
129 | |
130 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfHexString** out) { | |
131 if (!isHexString(podofoDoc, podofoObj)) return false; | |
132 | |
133 | |
134 *out = new SkPdfHexString(&podofoDoc, &podofoObj); | |
135 return true; | |
136 } | |
137 | |
138 static bool map(const SkPdfObject& in, SkPdfDictionary** out) { | |
139 return map(*in.doc(), *in.podofo(), out); | |
140 } | |
141 | |
142 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfDictionary** out) { | |
143 if (!isDictionary(podofoDoc, podofoObj)) return false; | |
144 | |
145 if (map(podofoDoc, podofoObj, (SkPdfALinkAnnotationDictionary**)out)) return
true; | |
146 if (map(podofoDoc, podofoObj, (SkPdfActionDictionary**)out)) return true; | |
147 if (map(podofoDoc, podofoObj, (SkPdfAlternateImageDictionary**)out)) return
true; | |
148 if (map(podofoDoc, podofoObj, (SkPdfAnnotationActionsDictionary**)out)) retu
rn true; | |
149 if (map(podofoDoc, podofoObj, (SkPdfAnnotationDictionary**)out)) return true
; | |
150 if (map(podofoDoc, podofoObj, (SkPdfAppearanceCharacteristicsDictionary**)ou
t)) return true; | |
151 if (map(podofoDoc, podofoObj, (SkPdfAppearanceDictionary**)out)) return true
; | |
152 if (map(podofoDoc, podofoObj, (SkPdfApplicationDataDictionary**)out)) return
true; | |
153 if (map(podofoDoc, podofoObj, (SkPdfArtifactsDictionary**)out)) return true; | |
154 if (map(podofoDoc, podofoObj, (SkPdfAttributeObjectDictionary**)out)) return
true; | |
155 if (map(podofoDoc, podofoObj, (SkPdfBeadDictionary**)out)) return true; | |
156 if (map(podofoDoc, podofoObj, (SkPdfBlockLevelStructureElementsDictionary**)
out)) return true; | |
157 if (map(podofoDoc, podofoObj, (SkPdfBorderStyleDictionary**)out)) return tru
e; | |
158 if (map(podofoDoc, podofoObj, (SkPdfBoxColorInformationDictionary**)out)) re
turn true; | |
159 if (map(podofoDoc, podofoObj, (SkPdfBoxStyleDictionary**)out)) return true; | |
160 if (map(podofoDoc, podofoObj, (SkPdfCIDFontDescriptorDictionary**)out)) retu
rn true; | |
161 if (map(podofoDoc, podofoObj, (SkPdfCIDSystemInfoDictionary**)out)) return t
rue; | |
162 if (map(podofoDoc, podofoObj, (SkPdfCMapDictionary**)out)) return true; | |
163 if (map(podofoDoc, podofoObj, (SkPdfCalgrayColorSpaceDictionary**)out)) retu
rn true; | |
164 if (map(podofoDoc, podofoObj, (SkPdfCalrgbColorSpaceDictionary**)out)) retur
n true; | |
165 if (map(podofoDoc, podofoObj, (SkPdfCatalogDictionary**)out)) return true; | |
166 if (map(podofoDoc, podofoObj, (SkPdfCcittfaxdecodeFilterDictionary**)out)) r
eturn true; | |
167 if (map(podofoDoc, podofoObj, (SkPdfCheckboxFieldDictionary**)out)) return t
rue; | |
168 if (map(podofoDoc, podofoObj, (SkPdfChoiceFieldDictionary**)out)) return tru
e; | |
169 if (map(podofoDoc, podofoObj, (SkPdfComponentsWithMetadataDictionary**)out))
return true; | |
170 if (map(podofoDoc, podofoObj, (SkPdfDctdecodeFilterDictionary**)out)) return
true; | |
171 if (map(podofoDoc, podofoObj, (SkPdfDeviceNColorSpaceDictionary**)out)) retu
rn true; | |
172 if (map(podofoDoc, podofoObj, (SkPdfDocumentCatalogActionsDictionary**)out))
return true; | |
173 if (map(podofoDoc, podofoObj, (SkPdfDocumentInformationDictionary**)out)) re
turn true; | |
174 if (map(podofoDoc, podofoObj, (SkPdfEmbeddedFileParameterDictionary**)out))
return true; | |
175 if (map(podofoDoc, podofoObj, (SkPdfEmbeddedFileStreamDictionary**)out)) ret
urn true; | |
176 if (map(podofoDoc, podofoObj, (SkPdfEmbeddedFontStreamDictionary**)out)) ret
urn true; | |
177 if (map(podofoDoc, podofoObj, (SkPdfEncodingDictionary**)out)) return true; | |
178 if (map(podofoDoc, podofoObj, (SkPdfEncryptedEmbeddedFileStreamDictionary**)
out)) return true; | |
179 if (map(podofoDoc, podofoObj, (SkPdfEncryptionCommonDictionary**)out)) retur
n true; | |
180 if (map(podofoDoc, podofoObj, (SkPdfFDFCatalogDictionary**)out)) return true
; | |
181 if (map(podofoDoc, podofoObj, (SkPdfFDFDictionary**)out)) return true; | |
182 if (map(podofoDoc, podofoObj, (SkPdfFDFFieldDictionary**)out)) return true; | |
183 if (map(podofoDoc, podofoObj, (SkPdfFDFFileAnnotationDictionary**)out)) retu
rn true; | |
184 if (map(podofoDoc, podofoObj, (SkPdfFDFNamedPageReferenceDictionary**)out))
return true; | |
185 if (map(podofoDoc, podofoObj, (SkPdfFDFPageDictionary**)out)) return true; | |
186 if (map(podofoDoc, podofoObj, (SkPdfFDFTemplateDictionary**)out)) return tru
e; | |
187 if (map(podofoDoc, podofoObj, (SkPdfFDFTrailerDictionary**)out)) return true
; | |
188 if (map(podofoDoc, podofoObj, (SkPdfFieldDictionary**)out)) return true; | |
189 if (map(podofoDoc, podofoObj, (SkPdfFileAttachmentAnnotationDictionary**)out
)) return true; | |
190 if (map(podofoDoc, podofoObj, (SkPdfFileSpecificationDictionary**)out)) retu
rn true; | |
191 if (map(podofoDoc, podofoObj, (SkPdfFileTrailerDictionary**)out)) return tru
e; | |
192 if (map(podofoDoc, podofoObj, (SkPdfFontDescriptorDictionary**)out)) return
true; | |
193 if (map(podofoDoc, podofoObj, (SkPdfFontDictionary**)out)) return true; | |
194 if (map(podofoDoc, podofoObj, (SkPdfFormFieldActionsDictionary**)out)) retur
n true; | |
195 if (map(podofoDoc, podofoObj, (SkPdfFreeTextAnnotationDictionary**)out)) ret
urn true; | |
196 if (map(podofoDoc, podofoObj, (SkPdfFunctionCommonDictionary**)out)) return
true; | |
197 if (map(podofoDoc, podofoObj, (SkPdfGoToActionDictionary**)out)) return true
; | |
198 if (map(podofoDoc, podofoObj, (SkPdfGraphicsStateDictionary**)out)) return t
rue; | |
199 if (map(podofoDoc, podofoObj, (SkPdfGroupAttributesDictionary**)out)) return
true; | |
200 if (map(podofoDoc, podofoObj, (SkPdfHideActionDictionary**)out)) return true
; | |
201 if (map(podofoDoc, podofoObj, (SkPdfIccProfileStreamDictionary**)out)) retur
n true; | |
202 if (map(podofoDoc, podofoObj, (SkPdfIconFitDictionary**)out)) return true; | |
203 if (map(podofoDoc, podofoObj, (SkPdfImportDataActionDictionary**)out)) retur
n true; | |
204 if (map(podofoDoc, podofoObj, (SkPdfInkAnnotationDictionary**)out)) return t
rue; | |
205 if (map(podofoDoc, podofoObj, (SkPdfInlineLevelStructureElementsDictionary**
)out)) return true; | |
206 if (map(podofoDoc, podofoObj, (SkPdfInteractiveFormDictionary**)out)) return
true; | |
207 if (map(podofoDoc, podofoObj, (SkPdfJavascriptActionDictionary**)out)) retur
n true; | |
208 if (map(podofoDoc, podofoObj, (SkPdfJavascriptDictionary**)out)) return true
; | |
209 if (map(podofoDoc, podofoObj, (SkPdfJbig2DecodeFilterDictionary**)out)) retu
rn true; | |
210 if (map(podofoDoc, podofoObj, (SkPdfLabColorSpaceDictionary**)out)) return t
rue; | |
211 if (map(podofoDoc, podofoObj, (SkPdfLaunchActionDictionary**)out)) return tr
ue; | |
212 if (map(podofoDoc, podofoObj, (SkPdfLineAnnotationDictionary**)out)) return
true; | |
213 if (map(podofoDoc, podofoObj, (SkPdfListAttributeDictionary**)out)) return t
rue; | |
214 if (map(podofoDoc, podofoObj, (SkPdfLzwdecodeAndFlatedecodeFiltersDictionary
**)out)) return true; | |
215 if (map(podofoDoc, podofoObj, (SkPdfMacOsFileInformationDictionary**)out)) r
eturn true; | |
216 if (map(podofoDoc, podofoObj, (SkPdfMarkInformationDictionary**)out)) return
true; | |
217 if (map(podofoDoc, podofoObj, (SkPdfMarkedContentReferenceDictionary**)out))
return true; | |
218 if (map(podofoDoc, podofoObj, (SkPdfMarkupAnnotationsDictionary**)out)) retu
rn true; | |
219 if (map(podofoDoc, podofoObj, (SkPdfMetadataStreamDictionary**)out)) return
true; | |
220 if (map(podofoDoc, podofoObj, (SkPdfMovieActionDictionary**)out)) return tru
e; | |
221 if (map(podofoDoc, podofoObj, (SkPdfMovieActivationDictionary**)out)) return
true; | |
222 if (map(podofoDoc, podofoObj, (SkPdfMovieAnnotationDictionary**)out)) return
true; | |
223 if (map(podofoDoc, podofoObj, (SkPdfMovieDictionary**)out)) return true; | |
224 if (map(podofoDoc, podofoObj, (SkPdfNameDictionary**)out)) return true; | |
225 if (map(podofoDoc, podofoObj, (SkPdfNameTreeNodeDictionary**)out)) return tr
ue; | |
226 if (map(podofoDoc, podofoObj, (SkPdfNamedActionsDictionary**)out)) return tr
ue; | |
227 if (map(podofoDoc, podofoObj, (SkPdfNumberTreeNodeDictionary**)out)) return
true; | |
228 if (map(podofoDoc, podofoObj, (SkPdfObjectReferenceDictionary**)out)) return
true; | |
229 if (map(podofoDoc, podofoObj, (SkPdfOpiVersionDictionary**)out)) return true
; | |
230 if (map(podofoDoc, podofoObj, (SkPdfOutlineDictionary**)out)) return true; | |
231 if (map(podofoDoc, podofoObj, (SkPdfOutlineItemDictionary**)out)) return tru
e; | |
232 if (map(podofoDoc, podofoObj, (SkPdfPDF_XOutputIntentDictionary**)out)) retu
rn true; | |
233 if (map(podofoDoc, podofoObj, (SkPdfPSXobjectDictionary**)out)) return true; | |
234 if (map(podofoDoc, podofoObj, (SkPdfPageLabelDictionary**)out)) return true; | |
235 if (map(podofoDoc, podofoObj, (SkPdfPageObjectActionsDictionary**)out)) retu
rn true; | |
236 if (map(podofoDoc, podofoObj, (SkPdfPageObjectDictionary**)out)) return true
; | |
237 if (map(podofoDoc, podofoObj, (SkPdfPagePieceDictionary**)out)) return true; | |
238 if (map(podofoDoc, podofoObj, (SkPdfPageTreeNodeDictionary**)out)) return tr
ue; | |
239 if (map(podofoDoc, podofoObj, (SkPdfPopUpAnnotationDictionary**)out)) return
true; | |
240 if (map(podofoDoc, podofoObj, (SkPdfPrinterMarkAnnotationDictionary**)out))
return true; | |
241 if (map(podofoDoc, podofoObj, (SkPdfPrinterMarkFormDictionary**)out)) return
true; | |
242 if (map(podofoDoc, podofoObj, (SkPdfRadioButtonFieldDictionary**)out)) retur
n true; | |
243 if (map(podofoDoc, podofoObj, (SkPdfReferenceDictionary**)out)) return true; | |
244 if (map(podofoDoc, podofoObj, (SkPdfRemoteGoToActionDictionary**)out)) retur
n true; | |
245 if (map(podofoDoc, podofoObj, (SkPdfResetFormActionDictionary**)out)) return
true; | |
246 if (map(podofoDoc, podofoObj, (SkPdfResourceDictionary**)out)) return true; | |
247 if (map(podofoDoc, podofoObj, (SkPdfRubberStampAnnotationDictionary**)out))
return true; | |
248 if (map(podofoDoc, podofoObj, (SkPdfSeparationDictionary**)out)) return true
; | |
249 if (map(podofoDoc, podofoObj, (SkPdfShadingDictionary**)out)) return true; | |
250 if (map(podofoDoc, podofoObj, (SkPdfSignatureDictionary**)out)) return true; | |
251 if (map(podofoDoc, podofoObj, (SkPdfSoftMaskDictionary**)out)) return true; | |
252 if (map(podofoDoc, podofoObj, (SkPdfSoftMaskImageDictionary**)out)) return t
rue; | |
253 if (map(podofoDoc, podofoObj, (SkPdfSoundActionDictionary**)out)) return tru
e; | |
254 if (map(podofoDoc, podofoObj, (SkPdfSoundAnnotationDictionary**)out)) return
true; | |
255 if (map(podofoDoc, podofoObj, (SkPdfSoundObjectDictionary**)out)) return tru
e; | |
256 if (map(podofoDoc, podofoObj, (SkPdfSourceInformationDictionary**)out)) retu
rn true; | |
257 if (map(podofoDoc, podofoObj, (SkPdfSquareOrCircleAnnotation**)out)) return
true; | |
258 if (map(podofoDoc, podofoObj, (SkPdfStandardSecurityHandlerDictionary**)out)
) return true; | |
259 if (map(podofoDoc, podofoObj, (SkPdfStandardStructureDictionary**)out)) retu
rn true; | |
260 if (map(podofoDoc, podofoObj, (SkPdfStreamCommonDictionary**)out)) return tr
ue; | |
261 if (map(podofoDoc, podofoObj, (SkPdfStructureElementAccessDictionary**)out))
return true; | |
262 if (map(podofoDoc, podofoObj, (SkPdfStructureElementDictionary**)out)) retur
n true; | |
263 if (map(podofoDoc, podofoObj, (SkPdfStructureTreeRootDictionary**)out)) retu
rn true; | |
264 if (map(podofoDoc, podofoObj, (SkPdfSubmitFormActionDictionary**)out)) retur
n true; | |
265 if (map(podofoDoc, podofoObj, (SkPdfTableAttributesDictionary**)out)) return
true; | |
266 if (map(podofoDoc, podofoObj, (SkPdfTextAnnotationDictionary**)out)) return
true; | |
267 if (map(podofoDoc, podofoObj, (SkPdfTextFieldDictionary**)out)) return true; | |
268 if (map(podofoDoc, podofoObj, (SkPdfThreadActionDictionary**)out)) return tr
ue; | |
269 if (map(podofoDoc, podofoObj, (SkPdfThreadDictionary**)out)) return true; | |
270 if (map(podofoDoc, podofoObj, (SkPdfTransitionDictionary**)out)) return true
; | |
271 if (map(podofoDoc, podofoObj, (SkPdfTransparencyGroupDictionary**)out)) retu
rn true; | |
272 if (map(podofoDoc, podofoObj, (SkPdfTrapNetworkAnnotationDictionary**)out))
return true; | |
273 if (map(podofoDoc, podofoObj, (SkPdfTrapNetworkAppearanceStreamDictionary**)
out)) return true; | |
274 if (map(podofoDoc, podofoObj, (SkPdfType0FunctionDictionary**)out)) return t
rue; | |
275 if (map(podofoDoc, podofoObj, (SkPdfType10HalftoneDictionary**)out)) return
true; | |
276 if (map(podofoDoc, podofoObj, (SkPdfType16HalftoneDictionary**)out)) return
true; | |
277 if (map(podofoDoc, podofoObj, (SkPdfType1HalftoneDictionary**)out)) return t
rue; | |
278 if (map(podofoDoc, podofoObj, (SkPdfType1PatternDictionary**)out)) return tr
ue; | |
279 if (map(podofoDoc, podofoObj, (SkPdfType2FunctionDictionary**)out)) return t
rue; | |
280 if (map(podofoDoc, podofoObj, (SkPdfType2PatternDictionary**)out)) return tr
ue; | |
281 if (map(podofoDoc, podofoObj, (SkPdfType3FunctionDictionary**)out)) return t
rue; | |
282 if (map(podofoDoc, podofoObj, (SkPdfType5HalftoneDictionary**)out)) return t
rue; | |
283 if (map(podofoDoc, podofoObj, (SkPdfType6HalftoneDictionary**)out)) return t
rue; | |
284 if (map(podofoDoc, podofoObj, (SkPdfURIActionDictionary**)out)) return true; | |
285 if (map(podofoDoc, podofoObj, (SkPdfURIDictionary**)out)) return true; | |
286 if (map(podofoDoc, podofoObj, (SkPdfURLAliasDictionary**)out)) return true; | |
287 if (map(podofoDoc, podofoObj, (SkPdfVariableTextFieldDictionary**)out)) retu
rn true; | |
288 if (map(podofoDoc, podofoObj, (SkPdfViewerPreferencesDictionary**)out)) retu
rn true; | |
289 if (map(podofoDoc, podofoObj, (SkPdfWebCaptureCommandDictionary**)out)) retu
rn true; | |
290 if (map(podofoDoc, podofoObj, (SkPdfWebCaptureCommandSettingsDictionary**)ou
t)) return true; | |
291 if (map(podofoDoc, podofoObj, (SkPdfWebCaptureDictionary**)out)) return true
; | |
292 if (map(podofoDoc, podofoObj, (SkPdfWebCaptureImageSetDictionary**)out)) ret
urn true; | |
293 if (map(podofoDoc, podofoObj, (SkPdfWebCaptureInformationDictionary**)out))
return true; | |
294 if (map(podofoDoc, podofoObj, (SkPdfWebCapturePageSetDictionary**)out)) retu
rn true; | |
295 if (map(podofoDoc, podofoObj, (SkPdfWidgetAnnotationDictionary**)out)) retur
n true; | |
296 if (map(podofoDoc, podofoObj, (SkPdfWindowsLaunchActionDictionary**)out)) re
turn true; | |
297 if (map(podofoDoc, podofoObj, (SkPdfXObjectDictionary**)out)) return true; | |
298 | |
299 *out = new SkPdfDictionary(&podofoDoc, &podofoObj); | |
300 return true; | |
301 } | |
302 | |
303 static bool map(const SkPdfObject& in, SkPdfStream** out) { | |
304 return map(*in.doc(), *in.podofo(), out); | |
305 } | |
306 | |
307 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfStream** out) { | |
308 if (!isStream(podofoDoc, podofoObj)) return false; | |
309 | |
310 | |
311 *out = new SkPdfStream(&podofoDoc, &podofoObj); | |
312 return true; | |
313 } | |
314 | |
315 static bool map(const SkPdfObject& in, SkPdfXObjectDictionary** out) { | |
316 return map(*in.doc(), *in.podofo(), out); | |
317 } | |
318 | |
319 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfXObjectDictionary** out) { | |
320 if (!isXObjectDictionary(podofoDoc, podofoObj)) return false; | |
321 | |
322 if (map(podofoDoc, podofoObj, (SkPdfImageDictionary**)out)) return true; | |
323 if (map(podofoDoc, podofoObj, (SkPdfType1FormDictionary**)out)) return true; | |
324 | |
325 *out = new SkPdfXObjectDictionary(&podofoDoc, &podofoObj); | |
326 return true; | |
327 } | |
328 | |
329 static bool map(const SkPdfObject& in, SkPdfFontDictionary** out) { | |
330 return map(*in.doc(), *in.podofo(), out); | |
331 } | |
332 | |
333 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFontDictionary** out) { | |
334 if (!isFontDictionary(podofoDoc, podofoObj)) return false; | |
335 | |
336 if (map(podofoDoc, podofoObj, (SkPdfCIDFontDictionary**)out)) return true; | |
337 if (map(podofoDoc, podofoObj, (SkPdfType0FontDictionary**)out)) return true; | |
338 if (map(podofoDoc, podofoObj, (SkPdfType1FontDictionary**)out)) return true; | |
339 | |
340 *out = new SkPdfFontDictionary(&podofoDoc, &podofoObj); | |
341 return true; | |
342 } | |
343 | |
344 static bool map(const SkPdfObject& in, SkPdfTrueTypeFontDictionary** out) { | |
345 return map(*in.doc(), *in.podofo(), out); | |
346 } | |
347 | |
348 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfTrueTypeFontDictionary** out) { | |
349 if (!isTrueTypeFontDictionary(podofoDoc, podofoObj)) return false; | |
350 | |
351 | |
352 *out = new SkPdfTrueTypeFontDictionary(&podofoDoc, &podofoObj); | |
353 return true; | |
354 } | |
355 | |
356 static bool map(const SkPdfObject& in, SkPdfStreamCommonDictionary** out) { | |
357 return map(*in.doc(), *in.podofo(), out); | |
358 } | |
359 | |
360 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfStreamCommonDictionary** out) { | |
361 if (!isStreamCommonDictionary(podofoDoc, podofoObj)) return false; | |
362 | |
363 | |
364 *out = new SkPdfStreamCommonDictionary(&podofoDoc, &podofoObj); | |
365 return true; | |
366 } | |
367 | |
368 static bool map(const SkPdfObject& in, SkPdfLzwdecodeAndFlatedecodeFiltersDict
ionary** out) { | |
369 return map(*in.doc(), *in.podofo(), out); | |
370 } | |
371 | |
372 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfLzwdecodeAndFlatedecodeFiltersDictionary** out) { | |
373 if (!isLzwdecodeAndFlatedecodeFiltersDictionary(podofoDoc, podofoObj)) retur
n false; | |
374 | |
375 | |
376 *out = new SkPdfLzwdecodeAndFlatedecodeFiltersDictionary(&podofoDoc, &podofo
Obj); | |
377 return true; | |
378 } | |
379 | |
380 static bool map(const SkPdfObject& in, SkPdfCcittfaxdecodeFilterDictionary** o
ut) { | |
381 return map(*in.doc(), *in.podofo(), out); | |
382 } | |
383 | |
384 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfCcittfaxdecodeFilterDictionary** out) { | |
385 if (!isCcittfaxdecodeFilterDictionary(podofoDoc, podofoObj)) return false; | |
386 | |
387 | |
388 *out = new SkPdfCcittfaxdecodeFilterDictionary(&podofoDoc, &podofoObj); | |
389 return true; | |
390 } | |
391 | |
392 static bool map(const SkPdfObject& in, SkPdfJbig2DecodeFilterDictionary** out)
{ | |
393 return map(*in.doc(), *in.podofo(), out); | |
394 } | |
395 | |
396 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfJbig2DecodeFilterDictionary** out) { | |
397 if (!isJbig2DecodeFilterDictionary(podofoDoc, podofoObj)) return false; | |
398 | |
399 | |
400 *out = new SkPdfJbig2DecodeFilterDictionary(&podofoDoc, &podofoObj); | |
401 return true; | |
402 } | |
403 | |
404 static bool map(const SkPdfObject& in, SkPdfDctdecodeFilterDictionary** out) { | |
405 return map(*in.doc(), *in.podofo(), out); | |
406 } | |
407 | |
408 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfDctdecodeFilterDictionary** out) { | |
409 if (!isDctdecodeFilterDictionary(podofoDoc, podofoObj)) return false; | |
410 | |
411 | |
412 *out = new SkPdfDctdecodeFilterDictionary(&podofoDoc, &podofoObj); | |
413 return true; | |
414 } | |
415 | |
416 static bool map(const SkPdfObject& in, SkPdfFileTrailerDictionary** out) { | |
417 return map(*in.doc(), *in.podofo(), out); | |
418 } | |
419 | |
420 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFileTrailerDictionary** out) { | |
421 if (!isFileTrailerDictionary(podofoDoc, podofoObj)) return false; | |
422 | |
423 | |
424 *out = new SkPdfFileTrailerDictionary(&podofoDoc, &podofoObj); | |
425 return true; | |
426 } | |
427 | |
428 static bool map(const SkPdfObject& in, SkPdfEncryptionCommonDictionary** out)
{ | |
429 return map(*in.doc(), *in.podofo(), out); | |
430 } | |
431 | |
432 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfEncryptionCommonDictionary** out) { | |
433 if (!isEncryptionCommonDictionary(podofoDoc, podofoObj)) return false; | |
434 | |
435 | |
436 *out = new SkPdfEncryptionCommonDictionary(&podofoDoc, &podofoObj); | |
437 return true; | |
438 } | |
439 | |
440 static bool map(const SkPdfObject& in, SkPdfStandardSecurityHandlerDictionary*
* out) { | |
441 return map(*in.doc(), *in.podofo(), out); | |
442 } | |
443 | |
444 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfStandardSecurityHandlerDictionary** out) { | |
445 if (!isStandardSecurityHandlerDictionary(podofoDoc, podofoObj)) return false
; | |
446 | |
447 | |
448 *out = new SkPdfStandardSecurityHandlerDictionary(&podofoDoc, &podofoObj); | |
449 return true; | |
450 } | |
451 | |
452 static bool map(const SkPdfObject& in, SkPdfCatalogDictionary** out) { | |
453 return map(*in.doc(), *in.podofo(), out); | |
454 } | |
455 | |
456 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfCatalogDictionary** out) { | |
457 if (!isCatalogDictionary(podofoDoc, podofoObj)) return false; | |
458 | |
459 | |
460 *out = new SkPdfCatalogDictionary(&podofoDoc, &podofoObj); | |
461 return true; | |
462 } | |
463 | |
464 static bool map(const SkPdfObject& in, SkPdfPageTreeNodeDictionary** out) { | |
465 return map(*in.doc(), *in.podofo(), out); | |
466 } | |
467 | |
468 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfPageTreeNodeDictionary** out) { | |
469 if (!isPageTreeNodeDictionary(podofoDoc, podofoObj)) return false; | |
470 | |
471 | |
472 *out = new SkPdfPageTreeNodeDictionary(&podofoDoc, &podofoObj); | |
473 return true; | |
474 } | |
475 | |
476 static bool map(const SkPdfObject& in, SkPdfPageObjectDictionary** out) { | |
477 return map(*in.doc(), *in.podofo(), out); | |
478 } | |
479 | |
480 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfPageObjectDictionary** out) { | |
481 if (!isPageObjectDictionary(podofoDoc, podofoObj)) return false; | |
482 | |
483 | |
484 *out = new SkPdfPageObjectDictionary(&podofoDoc, &podofoObj); | |
485 return true; | |
486 } | |
487 | |
488 static bool map(const SkPdfObject& in, SkPdfNameDictionary** out) { | |
489 return map(*in.doc(), *in.podofo(), out); | |
490 } | |
491 | |
492 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfNameDictionary** out) { | |
493 if (!isNameDictionary(podofoDoc, podofoObj)) return false; | |
494 | |
495 | |
496 *out = new SkPdfNameDictionary(&podofoDoc, &podofoObj); | |
497 return true; | |
498 } | |
499 | |
500 static bool map(const SkPdfObject& in, SkPdfResourceDictionary** out) { | |
501 return map(*in.doc(), *in.podofo(), out); | |
502 } | |
503 | |
504 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfResourceDictionary** out) { | |
505 if (!isResourceDictionary(podofoDoc, podofoObj)) return false; | |
506 | |
507 | |
508 *out = new SkPdfResourceDictionary(&podofoDoc, &podofoObj); | |
509 return true; | |
510 } | |
511 | |
512 static bool map(const SkPdfObject& in, SkPdfNameTreeNodeDictionary** out) { | |
513 return map(*in.doc(), *in.podofo(), out); | |
514 } | |
515 | |
516 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfNameTreeNodeDictionary** out) { | |
517 if (!isNameTreeNodeDictionary(podofoDoc, podofoObj)) return false; | |
518 | |
519 | |
520 *out = new SkPdfNameTreeNodeDictionary(&podofoDoc, &podofoObj); | |
521 return true; | |
522 } | |
523 | |
524 static bool map(const SkPdfObject& in, SkPdfNumberTreeNodeDictionary** out) { | |
525 return map(*in.doc(), *in.podofo(), out); | |
526 } | |
527 | |
528 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfNumberTreeNodeDictionary** out) { | |
529 if (!isNumberTreeNodeDictionary(podofoDoc, podofoObj)) return false; | |
530 | |
531 | |
532 *out = new SkPdfNumberTreeNodeDictionary(&podofoDoc, &podofoObj); | |
533 return true; | |
534 } | |
535 | |
536 static bool map(const SkPdfObject& in, SkPdfFunctionCommonDictionary** out) { | |
537 return map(*in.doc(), *in.podofo(), out); | |
538 } | |
539 | |
540 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFunctionCommonDictionary** out) { | |
541 if (!isFunctionCommonDictionary(podofoDoc, podofoObj)) return false; | |
542 | |
543 | |
544 *out = new SkPdfFunctionCommonDictionary(&podofoDoc, &podofoObj); | |
545 return true; | |
546 } | |
547 | |
548 static bool map(const SkPdfObject& in, SkPdfType0FunctionDictionary** out) { | |
549 return map(*in.doc(), *in.podofo(), out); | |
550 } | |
551 | |
552 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType0FunctionDictionary** out) { | |
553 if (!isType0FunctionDictionary(podofoDoc, podofoObj)) return false; | |
554 | |
555 | |
556 *out = new SkPdfType0FunctionDictionary(&podofoDoc, &podofoObj); | |
557 return true; | |
558 } | |
559 | |
560 static bool map(const SkPdfObject& in, SkPdfType2FunctionDictionary** out) { | |
561 return map(*in.doc(), *in.podofo(), out); | |
562 } | |
563 | |
564 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType2FunctionDictionary** out) { | |
565 if (!isType2FunctionDictionary(podofoDoc, podofoObj)) return false; | |
566 | |
567 | |
568 *out = new SkPdfType2FunctionDictionary(&podofoDoc, &podofoObj); | |
569 return true; | |
570 } | |
571 | |
572 static bool map(const SkPdfObject& in, SkPdfType3FunctionDictionary** out) { | |
573 return map(*in.doc(), *in.podofo(), out); | |
574 } | |
575 | |
576 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType3FunctionDictionary** out) { | |
577 if (!isType3FunctionDictionary(podofoDoc, podofoObj)) return false; | |
578 | |
579 | |
580 *out = new SkPdfType3FunctionDictionary(&podofoDoc, &podofoObj); | |
581 return true; | |
582 } | |
583 | |
584 static bool map(const SkPdfObject& in, SkPdfFileSpecificationDictionary** out)
{ | |
585 return map(*in.doc(), *in.podofo(), out); | |
586 } | |
587 | |
588 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFileSpecificationDictionary** out) { | |
589 if (!isFileSpecificationDictionary(podofoDoc, podofoObj)) return false; | |
590 | |
591 | |
592 *out = new SkPdfFileSpecificationDictionary(&podofoDoc, &podofoObj); | |
593 return true; | |
594 } | |
595 | |
596 static bool map(const SkPdfObject& in, SkPdfEmbeddedFileStreamDictionary** out
) { | |
597 return map(*in.doc(), *in.podofo(), out); | |
598 } | |
599 | |
600 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfEmbeddedFileStreamDictionary** out) { | |
601 if (!isEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false; | |
602 | |
603 | |
604 *out = new SkPdfEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj); | |
605 return true; | |
606 } | |
607 | |
608 static bool map(const SkPdfObject& in, SkPdfEmbeddedFileParameterDictionary**
out) { | |
609 return map(*in.doc(), *in.podofo(), out); | |
610 } | |
611 | |
612 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfEmbeddedFileParameterDictionary** out) { | |
613 if (!isEmbeddedFileParameterDictionary(podofoDoc, podofoObj)) return false; | |
614 | |
615 | |
616 *out = new SkPdfEmbeddedFileParameterDictionary(&podofoDoc, &podofoObj); | |
617 return true; | |
618 } | |
619 | |
620 static bool map(const SkPdfObject& in, SkPdfMacOsFileInformationDictionary** o
ut) { | |
621 return map(*in.doc(), *in.podofo(), out); | |
622 } | |
623 | |
624 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfMacOsFileInformationDictionary** out) { | |
625 if (!isMacOsFileInformationDictionary(podofoDoc, podofoObj)) return false; | |
626 | |
627 | |
628 *out = new SkPdfMacOsFileInformationDictionary(&podofoDoc, &podofoObj); | |
629 return true; | |
630 } | |
631 | |
632 static bool map(const SkPdfObject& in, SkPdfGraphicsStateDictionary** out) { | |
633 return map(*in.doc(), *in.podofo(), out); | |
634 } | |
635 | |
636 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfGraphicsStateDictionary** out) { | |
637 if (!isGraphicsStateDictionary(podofoDoc, podofoObj)) return false; | |
638 | |
639 | |
640 *out = new SkPdfGraphicsStateDictionary(&podofoDoc, &podofoObj); | |
641 return true; | |
642 } | |
643 | |
644 static bool map(const SkPdfObject& in, SkPdfCalgrayColorSpaceDictionary** out)
{ | |
645 return map(*in.doc(), *in.podofo(), out); | |
646 } | |
647 | |
648 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfCalgrayColorSpaceDictionary** out) { | |
649 if (!isCalgrayColorSpaceDictionary(podofoDoc, podofoObj)) return false; | |
650 | |
651 | |
652 *out = new SkPdfCalgrayColorSpaceDictionary(&podofoDoc, &podofoObj); | |
653 return true; | |
654 } | |
655 | |
656 static bool map(const SkPdfObject& in, SkPdfCalrgbColorSpaceDictionary** out)
{ | |
657 return map(*in.doc(), *in.podofo(), out); | |
658 } | |
659 | |
660 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfCalrgbColorSpaceDictionary** out) { | |
661 if (!isCalrgbColorSpaceDictionary(podofoDoc, podofoObj)) return false; | |
662 | |
663 | |
664 *out = new SkPdfCalrgbColorSpaceDictionary(&podofoDoc, &podofoObj); | |
665 return true; | |
666 } | |
667 | |
668 static bool map(const SkPdfObject& in, SkPdfLabColorSpaceDictionary** out) { | |
669 return map(*in.doc(), *in.podofo(), out); | |
670 } | |
671 | |
672 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfLabColorSpaceDictionary** out) { | |
673 if (!isLabColorSpaceDictionary(podofoDoc, podofoObj)) return false; | |
674 | |
675 | |
676 *out = new SkPdfLabColorSpaceDictionary(&podofoDoc, &podofoObj); | |
677 return true; | |
678 } | |
679 | |
680 static bool map(const SkPdfObject& in, SkPdfIccProfileStreamDictionary** out)
{ | |
681 return map(*in.doc(), *in.podofo(), out); | |
682 } | |
683 | |
684 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfIccProfileStreamDictionary** out) { | |
685 if (!isIccProfileStreamDictionary(podofoDoc, podofoObj)) return false; | |
686 | |
687 | |
688 *out = new SkPdfIccProfileStreamDictionary(&podofoDoc, &podofoObj); | |
689 return true; | |
690 } | |
691 | |
692 static bool map(const SkPdfObject& in, SkPdfDeviceNColorSpaceDictionary** out)
{ | |
693 return map(*in.doc(), *in.podofo(), out); | |
694 } | |
695 | |
696 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfDeviceNColorSpaceDictionary** out) { | |
697 if (!isDeviceNColorSpaceDictionary(podofoDoc, podofoObj)) return false; | |
698 | |
699 | |
700 *out = new SkPdfDeviceNColorSpaceDictionary(&podofoDoc, &podofoObj); | |
701 return true; | |
702 } | |
703 | |
704 static bool map(const SkPdfObject& in, SkPdfType1PatternDictionary** out) { | |
705 return map(*in.doc(), *in.podofo(), out); | |
706 } | |
707 | |
708 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType1PatternDictionary** out) { | |
709 if (!isType1PatternDictionary(podofoDoc, podofoObj)) return false; | |
710 | |
711 | |
712 *out = new SkPdfType1PatternDictionary(&podofoDoc, &podofoObj); | |
713 return true; | |
714 } | |
715 | |
716 static bool map(const SkPdfObject& in, SkPdfType2PatternDictionary** out) { | |
717 return map(*in.doc(), *in.podofo(), out); | |
718 } | |
719 | |
720 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType2PatternDictionary** out) { | |
721 if (!isType2PatternDictionary(podofoDoc, podofoObj)) return false; | |
722 | |
723 | |
724 *out = new SkPdfType2PatternDictionary(&podofoDoc, &podofoObj); | |
725 return true; | |
726 } | |
727 | |
728 static bool map(const SkPdfObject& in, SkPdfShadingDictionary** out) { | |
729 return map(*in.doc(), *in.podofo(), out); | |
730 } | |
731 | |
732 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfShadingDictionary** out) { | |
733 if (!isShadingDictionary(podofoDoc, podofoObj)) return false; | |
734 | |
735 if (map(podofoDoc, podofoObj, (SkPdfType1ShadingDictionary**)out)) return tr
ue; | |
736 if (map(podofoDoc, podofoObj, (SkPdfType2ShadingDictionary**)out)) return tr
ue; | |
737 if (map(podofoDoc, podofoObj, (SkPdfType3ShadingDictionary**)out)) return tr
ue; | |
738 if (map(podofoDoc, podofoObj, (SkPdfType4ShadingDictionary**)out)) return tr
ue; | |
739 if (map(podofoDoc, podofoObj, (SkPdfType5ShadingDictionary**)out)) return tr
ue; | |
740 if (map(podofoDoc, podofoObj, (SkPdfType6ShadingDictionary**)out)) return tr
ue; | |
741 | |
742 *out = new SkPdfShadingDictionary(&podofoDoc, &podofoObj); | |
743 return true; | |
744 } | |
745 | |
746 static bool map(const SkPdfObject& in, SkPdfType1ShadingDictionary** out) { | |
747 return map(*in.doc(), *in.podofo(), out); | |
748 } | |
749 | |
750 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType1ShadingDictionary** out) { | |
751 if (!isType1ShadingDictionary(podofoDoc, podofoObj)) return false; | |
752 | |
753 | |
754 *out = new SkPdfType1ShadingDictionary(&podofoDoc, &podofoObj); | |
755 return true; | |
756 } | |
757 | |
758 static bool map(const SkPdfObject& in, SkPdfType2ShadingDictionary** out) { | |
759 return map(*in.doc(), *in.podofo(), out); | |
760 } | |
761 | |
762 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType2ShadingDictionary** out) { | |
763 if (!isType2ShadingDictionary(podofoDoc, podofoObj)) return false; | |
764 | |
765 | |
766 *out = new SkPdfType2ShadingDictionary(&podofoDoc, &podofoObj); | |
767 return true; | |
768 } | |
769 | |
770 static bool map(const SkPdfObject& in, SkPdfType3ShadingDictionary** out) { | |
771 return map(*in.doc(), *in.podofo(), out); | |
772 } | |
773 | |
774 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType3ShadingDictionary** out) { | |
775 if (!isType3ShadingDictionary(podofoDoc, podofoObj)) return false; | |
776 | |
777 | |
778 *out = new SkPdfType3ShadingDictionary(&podofoDoc, &podofoObj); | |
779 return true; | |
780 } | |
781 | |
782 static bool map(const SkPdfObject& in, SkPdfType4ShadingDictionary** out) { | |
783 return map(*in.doc(), *in.podofo(), out); | |
784 } | |
785 | |
786 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType4ShadingDictionary** out) { | |
787 if (!isType4ShadingDictionary(podofoDoc, podofoObj)) return false; | |
788 | |
789 | |
790 *out = new SkPdfType4ShadingDictionary(&podofoDoc, &podofoObj); | |
791 return true; | |
792 } | |
793 | |
794 static bool map(const SkPdfObject& in, SkPdfType5ShadingDictionary** out) { | |
795 return map(*in.doc(), *in.podofo(), out); | |
796 } | |
797 | |
798 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType5ShadingDictionary** out) { | |
799 if (!isType5ShadingDictionary(podofoDoc, podofoObj)) return false; | |
800 | |
801 | |
802 *out = new SkPdfType5ShadingDictionary(&podofoDoc, &podofoObj); | |
803 return true; | |
804 } | |
805 | |
806 static bool map(const SkPdfObject& in, SkPdfType6ShadingDictionary** out) { | |
807 return map(*in.doc(), *in.podofo(), out); | |
808 } | |
809 | |
810 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType6ShadingDictionary** out) { | |
811 if (!isType6ShadingDictionary(podofoDoc, podofoObj)) return false; | |
812 | |
813 | |
814 *out = new SkPdfType6ShadingDictionary(&podofoDoc, &podofoObj); | |
815 return true; | |
816 } | |
817 | |
818 static bool map(const SkPdfObject& in, SkPdfImageDictionary** out) { | |
819 return map(*in.doc(), *in.podofo(), out); | |
820 } | |
821 | |
822 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfImageDictionary** out) { | |
823 if (!isImageDictionary(podofoDoc, podofoObj)) return false; | |
824 | |
825 | |
826 *out = new SkPdfImageDictionary(&podofoDoc, &podofoObj); | |
827 return true; | |
828 } | |
829 | |
830 static bool map(const SkPdfObject& in, SkPdfAlternateImageDictionary** out) { | |
831 return map(*in.doc(), *in.podofo(), out); | |
832 } | |
833 | |
834 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfAlternateImageDictionary** out) { | |
835 if (!isAlternateImageDictionary(podofoDoc, podofoObj)) return false; | |
836 | |
837 | |
838 *out = new SkPdfAlternateImageDictionary(&podofoDoc, &podofoObj); | |
839 return true; | |
840 } | |
841 | |
842 static bool map(const SkPdfObject& in, SkPdfType1FormDictionary** out) { | |
843 return map(*in.doc(), *in.podofo(), out); | |
844 } | |
845 | |
846 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType1FormDictionary** out) { | |
847 if (!isType1FormDictionary(podofoDoc, podofoObj)) return false; | |
848 | |
849 | |
850 *out = new SkPdfType1FormDictionary(&podofoDoc, &podofoObj); | |
851 return true; | |
852 } | |
853 | |
854 static bool map(const SkPdfObject& in, SkPdfGroupAttributesDictionary** out) { | |
855 return map(*in.doc(), *in.podofo(), out); | |
856 } | |
857 | |
858 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfGroupAttributesDictionary** out) { | |
859 if (!isGroupAttributesDictionary(podofoDoc, podofoObj)) return false; | |
860 | |
861 | |
862 *out = new SkPdfGroupAttributesDictionary(&podofoDoc, &podofoObj); | |
863 return true; | |
864 } | |
865 | |
866 static bool map(const SkPdfObject& in, SkPdfReferenceDictionary** out) { | |
867 return map(*in.doc(), *in.podofo(), out); | |
868 } | |
869 | |
870 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfReferenceDictionary** out) { | |
871 if (!isReferenceDictionary(podofoDoc, podofoObj)) return false; | |
872 | |
873 | |
874 *out = new SkPdfReferenceDictionary(&podofoDoc, &podofoObj); | |
875 return true; | |
876 } | |
877 | |
878 static bool map(const SkPdfObject& in, SkPdfPSXobjectDictionary** out) { | |
879 return map(*in.doc(), *in.podofo(), out); | |
880 } | |
881 | |
882 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfPSXobjectDictionary** out) { | |
883 if (!isPSXobjectDictionary(podofoDoc, podofoObj)) return false; | |
884 | |
885 | |
886 *out = new SkPdfPSXobjectDictionary(&podofoDoc, &podofoObj); | |
887 return true; | |
888 } | |
889 | |
890 static bool map(const SkPdfObject& in, SkPdfType1FontDictionary** out) { | |
891 return map(*in.doc(), *in.podofo(), out); | |
892 } | |
893 | |
894 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType1FontDictionary** out) { | |
895 if (!isType1FontDictionary(podofoDoc, podofoObj)) return false; | |
896 | |
897 if (map(podofoDoc, podofoObj, (SkPdfMultiMasterFontDictionary**)out)) return
true; | |
898 if (map(podofoDoc, podofoObj, (SkPdfTrueTypeFontDictionary**)out)) return tr
ue; | |
899 | |
900 *out = new SkPdfType1FontDictionary(&podofoDoc, &podofoObj); | |
901 return true; | |
902 } | |
903 | |
904 static bool map(const SkPdfObject& in, SkPdfType3FontDictionary** out) { | |
905 return map(*in.doc(), *in.podofo(), out); | |
906 } | |
907 | |
908 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType3FontDictionary** out) { | |
909 if (!isType3FontDictionary(podofoDoc, podofoObj)) return false; | |
910 | |
911 | |
912 *out = new SkPdfType3FontDictionary(&podofoDoc, &podofoObj); | |
913 return true; | |
914 } | |
915 | |
916 static bool map(const SkPdfObject& in, SkPdfEncodingDictionary** out) { | |
917 return map(*in.doc(), *in.podofo(), out); | |
918 } | |
919 | |
920 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfEncodingDictionary** out) { | |
921 if (!isEncodingDictionary(podofoDoc, podofoObj)) return false; | |
922 | |
923 | |
924 *out = new SkPdfEncodingDictionary(&podofoDoc, &podofoObj); | |
925 return true; | |
926 } | |
927 | |
928 static bool map(const SkPdfObject& in, SkPdfCIDSystemInfoDictionary** out) { | |
929 return map(*in.doc(), *in.podofo(), out); | |
930 } | |
931 | |
932 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfCIDSystemInfoDictionary** out) { | |
933 if (!isCIDSystemInfoDictionary(podofoDoc, podofoObj)) return false; | |
934 | |
935 | |
936 *out = new SkPdfCIDSystemInfoDictionary(&podofoDoc, &podofoObj); | |
937 return true; | |
938 } | |
939 | |
940 static bool map(const SkPdfObject& in, SkPdfCIDFontDictionary** out) { | |
941 return map(*in.doc(), *in.podofo(), out); | |
942 } | |
943 | |
944 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfCIDFontDictionary** out) { | |
945 if (!isCIDFontDictionary(podofoDoc, podofoObj)) return false; | |
946 | |
947 | |
948 *out = new SkPdfCIDFontDictionary(&podofoDoc, &podofoObj); | |
949 return true; | |
950 } | |
951 | |
952 static bool map(const SkPdfObject& in, SkPdfCMapDictionary** out) { | |
953 return map(*in.doc(), *in.podofo(), out); | |
954 } | |
955 | |
956 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfCMapDictionary** out) { | |
957 if (!isCMapDictionary(podofoDoc, podofoObj)) return false; | |
958 | |
959 | |
960 *out = new SkPdfCMapDictionary(&podofoDoc, &podofoObj); | |
961 return true; | |
962 } | |
963 | |
964 static bool map(const SkPdfObject& in, SkPdfType0FontDictionary** out) { | |
965 return map(*in.doc(), *in.podofo(), out); | |
966 } | |
967 | |
968 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType0FontDictionary** out) { | |
969 if (!isType0FontDictionary(podofoDoc, podofoObj)) return false; | |
970 | |
971 if (map(podofoDoc, podofoObj, (SkPdfType3FontDictionary**)out)) return true; | |
972 | |
973 *out = new SkPdfType0FontDictionary(&podofoDoc, &podofoObj); | |
974 return true; | |
975 } | |
976 | |
977 static bool map(const SkPdfObject& in, SkPdfFontDescriptorDictionary** out) { | |
978 return map(*in.doc(), *in.podofo(), out); | |
979 } | |
980 | |
981 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFontDescriptorDictionary** out) { | |
982 if (!isFontDescriptorDictionary(podofoDoc, podofoObj)) return false; | |
983 | |
984 | |
985 *out = new SkPdfFontDescriptorDictionary(&podofoDoc, &podofoObj); | |
986 return true; | |
987 } | |
988 | |
989 static bool map(const SkPdfObject& in, SkPdfCIDFontDescriptorDictionary** out)
{ | |
990 return map(*in.doc(), *in.podofo(), out); | |
991 } | |
992 | |
993 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfCIDFontDescriptorDictionary** out) { | |
994 if (!isCIDFontDescriptorDictionary(podofoDoc, podofoObj)) return false; | |
995 | |
996 | |
997 *out = new SkPdfCIDFontDescriptorDictionary(&podofoDoc, &podofoObj); | |
998 return true; | |
999 } | |
1000 | |
1001 static bool map(const SkPdfObject& in, SkPdfEmbeddedFontStreamDictionary** out
) { | |
1002 return map(*in.doc(), *in.podofo(), out); | |
1003 } | |
1004 | |
1005 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfEmbeddedFontStreamDictionary** out) { | |
1006 if (!isEmbeddedFontStreamDictionary(podofoDoc, podofoObj)) return false; | |
1007 | |
1008 | |
1009 *out = new SkPdfEmbeddedFontStreamDictionary(&podofoDoc, &podofoObj); | |
1010 return true; | |
1011 } | |
1012 | |
1013 static bool map(const SkPdfObject& in, SkPdfType1HalftoneDictionary** out) { | |
1014 return map(*in.doc(), *in.podofo(), out); | |
1015 } | |
1016 | |
1017 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType1HalftoneDictionary** out) { | |
1018 if (!isType1HalftoneDictionary(podofoDoc, podofoObj)) return false; | |
1019 | |
1020 | |
1021 *out = new SkPdfType1HalftoneDictionary(&podofoDoc, &podofoObj); | |
1022 return true; | |
1023 } | |
1024 | |
1025 static bool map(const SkPdfObject& in, SkPdfType6HalftoneDictionary** out) { | |
1026 return map(*in.doc(), *in.podofo(), out); | |
1027 } | |
1028 | |
1029 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType6HalftoneDictionary** out) { | |
1030 if (!isType6HalftoneDictionary(podofoDoc, podofoObj)) return false; | |
1031 | |
1032 | |
1033 *out = new SkPdfType6HalftoneDictionary(&podofoDoc, &podofoObj); | |
1034 return true; | |
1035 } | |
1036 | |
1037 static bool map(const SkPdfObject& in, SkPdfType10HalftoneDictionary** out) { | |
1038 return map(*in.doc(), *in.podofo(), out); | |
1039 } | |
1040 | |
1041 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType10HalftoneDictionary** out) { | |
1042 if (!isType10HalftoneDictionary(podofoDoc, podofoObj)) return false; | |
1043 | |
1044 | |
1045 *out = new SkPdfType10HalftoneDictionary(&podofoDoc, &podofoObj); | |
1046 return true; | |
1047 } | |
1048 | |
1049 static bool map(const SkPdfObject& in, SkPdfType16HalftoneDictionary** out) { | |
1050 return map(*in.doc(), *in.podofo(), out); | |
1051 } | |
1052 | |
1053 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType16HalftoneDictionary** out) { | |
1054 if (!isType16HalftoneDictionary(podofoDoc, podofoObj)) return false; | |
1055 | |
1056 | |
1057 *out = new SkPdfType16HalftoneDictionary(&podofoDoc, &podofoObj); | |
1058 return true; | |
1059 } | |
1060 | |
1061 static bool map(const SkPdfObject& in, SkPdfType5HalftoneDictionary** out) { | |
1062 return map(*in.doc(), *in.podofo(), out); | |
1063 } | |
1064 | |
1065 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType5HalftoneDictionary** out) { | |
1066 if (!isType5HalftoneDictionary(podofoDoc, podofoObj)) return false; | |
1067 | |
1068 | |
1069 *out = new SkPdfType5HalftoneDictionary(&podofoDoc, &podofoObj); | |
1070 return true; | |
1071 } | |
1072 | |
1073 static bool map(const SkPdfObject& in, SkPdfSoftMaskDictionary** out) { | |
1074 return map(*in.doc(), *in.podofo(), out); | |
1075 } | |
1076 | |
1077 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfSoftMaskDictionary** out) { | |
1078 if (!isSoftMaskDictionary(podofoDoc, podofoObj)) return false; | |
1079 | |
1080 | |
1081 *out = new SkPdfSoftMaskDictionary(&podofoDoc, &podofoObj); | |
1082 return true; | |
1083 } | |
1084 | |
1085 static bool map(const SkPdfObject& in, SkPdfSoftMaskImageDictionary** out) { | |
1086 return map(*in.doc(), *in.podofo(), out); | |
1087 } | |
1088 | |
1089 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfSoftMaskImageDictionary** out) { | |
1090 if (!isSoftMaskImageDictionary(podofoDoc, podofoObj)) return false; | |
1091 | |
1092 | |
1093 *out = new SkPdfSoftMaskImageDictionary(&podofoDoc, &podofoObj); | |
1094 return true; | |
1095 } | |
1096 | |
1097 static bool map(const SkPdfObject& in, SkPdfTransparencyGroupDictionary** out)
{ | |
1098 return map(*in.doc(), *in.podofo(), out); | |
1099 } | |
1100 | |
1101 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfTransparencyGroupDictionary** out) { | |
1102 if (!isTransparencyGroupDictionary(podofoDoc, podofoObj)) return false; | |
1103 | |
1104 | |
1105 *out = new SkPdfTransparencyGroupDictionary(&podofoDoc, &podofoObj); | |
1106 return true; | |
1107 } | |
1108 | |
1109 static bool map(const SkPdfObject& in, SkPdfViewerPreferencesDictionary** out)
{ | |
1110 return map(*in.doc(), *in.podofo(), out); | |
1111 } | |
1112 | |
1113 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfViewerPreferencesDictionary** out) { | |
1114 if (!isViewerPreferencesDictionary(podofoDoc, podofoObj)) return false; | |
1115 | |
1116 | |
1117 *out = new SkPdfViewerPreferencesDictionary(&podofoDoc, &podofoObj); | |
1118 return true; | |
1119 } | |
1120 | |
1121 static bool map(const SkPdfObject& in, SkPdfOutlineDictionary** out) { | |
1122 return map(*in.doc(), *in.podofo(), out); | |
1123 } | |
1124 | |
1125 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfOutlineDictionary** out) { | |
1126 if (!isOutlineDictionary(podofoDoc, podofoObj)) return false; | |
1127 | |
1128 | |
1129 *out = new SkPdfOutlineDictionary(&podofoDoc, &podofoObj); | |
1130 return true; | |
1131 } | |
1132 | |
1133 static bool map(const SkPdfObject& in, SkPdfOutlineItemDictionary** out) { | |
1134 return map(*in.doc(), *in.podofo(), out); | |
1135 } | |
1136 | |
1137 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfOutlineItemDictionary** out) { | |
1138 if (!isOutlineItemDictionary(podofoDoc, podofoObj)) return false; | |
1139 | |
1140 | |
1141 *out = new SkPdfOutlineItemDictionary(&podofoDoc, &podofoObj); | |
1142 return true; | |
1143 } | |
1144 | |
1145 static bool map(const SkPdfObject& in, SkPdfPageLabelDictionary** out) { | |
1146 return map(*in.doc(), *in.podofo(), out); | |
1147 } | |
1148 | |
1149 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfPageLabelDictionary** out) { | |
1150 if (!isPageLabelDictionary(podofoDoc, podofoObj)) return false; | |
1151 | |
1152 | |
1153 *out = new SkPdfPageLabelDictionary(&podofoDoc, &podofoObj); | |
1154 return true; | |
1155 } | |
1156 | |
1157 static bool map(const SkPdfObject& in, SkPdfThreadDictionary** out) { | |
1158 return map(*in.doc(), *in.podofo(), out); | |
1159 } | |
1160 | |
1161 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfThreadDictionary** out) { | |
1162 if (!isThreadDictionary(podofoDoc, podofoObj)) return false; | |
1163 | |
1164 | |
1165 *out = new SkPdfThreadDictionary(&podofoDoc, &podofoObj); | |
1166 return true; | |
1167 } | |
1168 | |
1169 static bool map(const SkPdfObject& in, SkPdfBeadDictionary** out) { | |
1170 return map(*in.doc(), *in.podofo(), out); | |
1171 } | |
1172 | |
1173 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfBeadDictionary** out) { | |
1174 if (!isBeadDictionary(podofoDoc, podofoObj)) return false; | |
1175 | |
1176 | |
1177 *out = new SkPdfBeadDictionary(&podofoDoc, &podofoObj); | |
1178 return true; | |
1179 } | |
1180 | |
1181 static bool map(const SkPdfObject& in, SkPdfTransitionDictionary** out) { | |
1182 return map(*in.doc(), *in.podofo(), out); | |
1183 } | |
1184 | |
1185 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfTransitionDictionary** out) { | |
1186 if (!isTransitionDictionary(podofoDoc, podofoObj)) return false; | |
1187 | |
1188 | |
1189 *out = new SkPdfTransitionDictionary(&podofoDoc, &podofoObj); | |
1190 return true; | |
1191 } | |
1192 | |
1193 static bool map(const SkPdfObject& in, SkPdfAnnotationDictionary** out) { | |
1194 return map(*in.doc(), *in.podofo(), out); | |
1195 } | |
1196 | |
1197 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfAnnotationDictionary** out) { | |
1198 if (!isAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
1199 | |
1200 | |
1201 *out = new SkPdfAnnotationDictionary(&podofoDoc, &podofoObj); | |
1202 return true; | |
1203 } | |
1204 | |
1205 static bool map(const SkPdfObject& in, SkPdfBorderStyleDictionary** out) { | |
1206 return map(*in.doc(), *in.podofo(), out); | |
1207 } | |
1208 | |
1209 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfBorderStyleDictionary** out) { | |
1210 if (!isBorderStyleDictionary(podofoDoc, podofoObj)) return false; | |
1211 | |
1212 | |
1213 *out = new SkPdfBorderStyleDictionary(&podofoDoc, &podofoObj); | |
1214 return true; | |
1215 } | |
1216 | |
1217 static bool map(const SkPdfObject& in, SkPdfAppearanceDictionary** out) { | |
1218 return map(*in.doc(), *in.podofo(), out); | |
1219 } | |
1220 | |
1221 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfAppearanceDictionary** out) { | |
1222 if (!isAppearanceDictionary(podofoDoc, podofoObj)) return false; | |
1223 | |
1224 | |
1225 *out = new SkPdfAppearanceDictionary(&podofoDoc, &podofoObj); | |
1226 return true; | |
1227 } | |
1228 | |
1229 static bool map(const SkPdfObject& in, SkPdfTextAnnotationDictionary** out) { | |
1230 return map(*in.doc(), *in.podofo(), out); | |
1231 } | |
1232 | |
1233 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfTextAnnotationDictionary** out) { | |
1234 if (!isTextAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
1235 | |
1236 | |
1237 *out = new SkPdfTextAnnotationDictionary(&podofoDoc, &podofoObj); | |
1238 return true; | |
1239 } | |
1240 | |
1241 static bool map(const SkPdfObject& in, SkPdfALinkAnnotationDictionary** out) { | |
1242 return map(*in.doc(), *in.podofo(), out); | |
1243 } | |
1244 | |
1245 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfALinkAnnotationDictionary** out) { | |
1246 if (!isALinkAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
1247 | |
1248 | |
1249 *out = new SkPdfALinkAnnotationDictionary(&podofoDoc, &podofoObj); | |
1250 return true; | |
1251 } | |
1252 | |
1253 static bool map(const SkPdfObject& in, SkPdfFreeTextAnnotationDictionary** out
) { | |
1254 return map(*in.doc(), *in.podofo(), out); | |
1255 } | |
1256 | |
1257 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFreeTextAnnotationDictionary** out) { | |
1258 if (!isFreeTextAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
1259 | |
1260 | |
1261 *out = new SkPdfFreeTextAnnotationDictionary(&podofoDoc, &podofoObj); | |
1262 return true; | |
1263 } | |
1264 | |
1265 static bool map(const SkPdfObject& in, SkPdfLineAnnotationDictionary** out) { | |
1266 return map(*in.doc(), *in.podofo(), out); | |
1267 } | |
1268 | |
1269 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfLineAnnotationDictionary** out) { | |
1270 if (!isLineAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
1271 | |
1272 | |
1273 *out = new SkPdfLineAnnotationDictionary(&podofoDoc, &podofoObj); | |
1274 return true; | |
1275 } | |
1276 | |
1277 static bool map(const SkPdfObject& in, SkPdfSquareOrCircleAnnotation** out) { | |
1278 return map(*in.doc(), *in.podofo(), out); | |
1279 } | |
1280 | |
1281 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfSquareOrCircleAnnotation** out) { | |
1282 if (!isSquareOrCircleAnnotation(podofoDoc, podofoObj)) return false; | |
1283 | |
1284 | |
1285 *out = new SkPdfSquareOrCircleAnnotation(&podofoDoc, &podofoObj); | |
1286 return true; | |
1287 } | |
1288 | |
1289 static bool map(const SkPdfObject& in, SkPdfMarkupAnnotationsDictionary** out)
{ | |
1290 return map(*in.doc(), *in.podofo(), out); | |
1291 } | |
1292 | |
1293 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfMarkupAnnotationsDictionary** out) { | |
1294 if (!isMarkupAnnotationsDictionary(podofoDoc, podofoObj)) return false; | |
1295 | |
1296 | |
1297 *out = new SkPdfMarkupAnnotationsDictionary(&podofoDoc, &podofoObj); | |
1298 return true; | |
1299 } | |
1300 | |
1301 static bool map(const SkPdfObject& in, SkPdfRubberStampAnnotationDictionary**
out) { | |
1302 return map(*in.doc(), *in.podofo(), out); | |
1303 } | |
1304 | |
1305 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfRubberStampAnnotationDictionary** out) { | |
1306 if (!isRubberStampAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
1307 | |
1308 | |
1309 *out = new SkPdfRubberStampAnnotationDictionary(&podofoDoc, &podofoObj); | |
1310 return true; | |
1311 } | |
1312 | |
1313 static bool map(const SkPdfObject& in, SkPdfInkAnnotationDictionary** out) { | |
1314 return map(*in.doc(), *in.podofo(), out); | |
1315 } | |
1316 | |
1317 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfInkAnnotationDictionary** out) { | |
1318 if (!isInkAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
1319 | |
1320 | |
1321 *out = new SkPdfInkAnnotationDictionary(&podofoDoc, &podofoObj); | |
1322 return true; | |
1323 } | |
1324 | |
1325 static bool map(const SkPdfObject& in, SkPdfPopUpAnnotationDictionary** out) { | |
1326 return map(*in.doc(), *in.podofo(), out); | |
1327 } | |
1328 | |
1329 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfPopUpAnnotationDictionary** out) { | |
1330 if (!isPopUpAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
1331 | |
1332 | |
1333 *out = new SkPdfPopUpAnnotationDictionary(&podofoDoc, &podofoObj); | |
1334 return true; | |
1335 } | |
1336 | |
1337 static bool map(const SkPdfObject& in, SkPdfFileAttachmentAnnotationDictionary
** out) { | |
1338 return map(*in.doc(), *in.podofo(), out); | |
1339 } | |
1340 | |
1341 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFileAttachmentAnnotationDictionary** out) { | |
1342 if (!isFileAttachmentAnnotationDictionary(podofoDoc, podofoObj)) return fals
e; | |
1343 | |
1344 | |
1345 *out = new SkPdfFileAttachmentAnnotationDictionary(&podofoDoc, &podofoObj); | |
1346 return true; | |
1347 } | |
1348 | |
1349 static bool map(const SkPdfObject& in, SkPdfSoundAnnotationDictionary** out) { | |
1350 return map(*in.doc(), *in.podofo(), out); | |
1351 } | |
1352 | |
1353 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfSoundAnnotationDictionary** out) { | |
1354 if (!isSoundAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
1355 | |
1356 | |
1357 *out = new SkPdfSoundAnnotationDictionary(&podofoDoc, &podofoObj); | |
1358 return true; | |
1359 } | |
1360 | |
1361 static bool map(const SkPdfObject& in, SkPdfMovieAnnotationDictionary** out) { | |
1362 return map(*in.doc(), *in.podofo(), out); | |
1363 } | |
1364 | |
1365 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfMovieAnnotationDictionary** out) { | |
1366 if (!isMovieAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
1367 | |
1368 | |
1369 *out = new SkPdfMovieAnnotationDictionary(&podofoDoc, &podofoObj); | |
1370 return true; | |
1371 } | |
1372 | |
1373 static bool map(const SkPdfObject& in, SkPdfWidgetAnnotationDictionary** out)
{ | |
1374 return map(*in.doc(), *in.podofo(), out); | |
1375 } | |
1376 | |
1377 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfWidgetAnnotationDictionary** out) { | |
1378 if (!isWidgetAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
1379 | |
1380 | |
1381 *out = new SkPdfWidgetAnnotationDictionary(&podofoDoc, &podofoObj); | |
1382 return true; | |
1383 } | |
1384 | |
1385 static bool map(const SkPdfObject& in, SkPdfActionDictionary** out) { | |
1386 return map(*in.doc(), *in.podofo(), out); | |
1387 } | |
1388 | |
1389 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfActionDictionary** out) { | |
1390 if (!isActionDictionary(podofoDoc, podofoObj)) return false; | |
1391 | |
1392 | |
1393 *out = new SkPdfActionDictionary(&podofoDoc, &podofoObj); | |
1394 return true; | |
1395 } | |
1396 | |
1397 static bool map(const SkPdfObject& in, SkPdfAnnotationActionsDictionary** out)
{ | |
1398 return map(*in.doc(), *in.podofo(), out); | |
1399 } | |
1400 | |
1401 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfAnnotationActionsDictionary** out) { | |
1402 if (!isAnnotationActionsDictionary(podofoDoc, podofoObj)) return false; | |
1403 | |
1404 | |
1405 *out = new SkPdfAnnotationActionsDictionary(&podofoDoc, &podofoObj); | |
1406 return true; | |
1407 } | |
1408 | |
1409 static bool map(const SkPdfObject& in, SkPdfPageObjectActionsDictionary** out)
{ | |
1410 return map(*in.doc(), *in.podofo(), out); | |
1411 } | |
1412 | |
1413 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfPageObjectActionsDictionary** out) { | |
1414 if (!isPageObjectActionsDictionary(podofoDoc, podofoObj)) return false; | |
1415 | |
1416 | |
1417 *out = new SkPdfPageObjectActionsDictionary(&podofoDoc, &podofoObj); | |
1418 return true; | |
1419 } | |
1420 | |
1421 static bool map(const SkPdfObject& in, SkPdfFormFieldActionsDictionary** out)
{ | |
1422 return map(*in.doc(), *in.podofo(), out); | |
1423 } | |
1424 | |
1425 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFormFieldActionsDictionary** out) { | |
1426 if (!isFormFieldActionsDictionary(podofoDoc, podofoObj)) return false; | |
1427 | |
1428 | |
1429 *out = new SkPdfFormFieldActionsDictionary(&podofoDoc, &podofoObj); | |
1430 return true; | |
1431 } | |
1432 | |
1433 static bool map(const SkPdfObject& in, SkPdfDocumentCatalogActionsDictionary**
out) { | |
1434 return map(*in.doc(), *in.podofo(), out); | |
1435 } | |
1436 | |
1437 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfDocumentCatalogActionsDictionary** out) { | |
1438 if (!isDocumentCatalogActionsDictionary(podofoDoc, podofoObj)) return false; | |
1439 | |
1440 | |
1441 *out = new SkPdfDocumentCatalogActionsDictionary(&podofoDoc, &podofoObj); | |
1442 return true; | |
1443 } | |
1444 | |
1445 static bool map(const SkPdfObject& in, SkPdfGoToActionDictionary** out) { | |
1446 return map(*in.doc(), *in.podofo(), out); | |
1447 } | |
1448 | |
1449 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfGoToActionDictionary** out) { | |
1450 if (!isGoToActionDictionary(podofoDoc, podofoObj)) return false; | |
1451 | |
1452 | |
1453 *out = new SkPdfGoToActionDictionary(&podofoDoc, &podofoObj); | |
1454 return true; | |
1455 } | |
1456 | |
1457 static bool map(const SkPdfObject& in, SkPdfRemoteGoToActionDictionary** out)
{ | |
1458 return map(*in.doc(), *in.podofo(), out); | |
1459 } | |
1460 | |
1461 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfRemoteGoToActionDictionary** out) { | |
1462 if (!isRemoteGoToActionDictionary(podofoDoc, podofoObj)) return false; | |
1463 | |
1464 | |
1465 *out = new SkPdfRemoteGoToActionDictionary(&podofoDoc, &podofoObj); | |
1466 return true; | |
1467 } | |
1468 | |
1469 static bool map(const SkPdfObject& in, SkPdfLaunchActionDictionary** out) { | |
1470 return map(*in.doc(), *in.podofo(), out); | |
1471 } | |
1472 | |
1473 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfLaunchActionDictionary** out) { | |
1474 if (!isLaunchActionDictionary(podofoDoc, podofoObj)) return false; | |
1475 | |
1476 | |
1477 *out = new SkPdfLaunchActionDictionary(&podofoDoc, &podofoObj); | |
1478 return true; | |
1479 } | |
1480 | |
1481 static bool map(const SkPdfObject& in, SkPdfWindowsLaunchActionDictionary** ou
t) { | |
1482 return map(*in.doc(), *in.podofo(), out); | |
1483 } | |
1484 | |
1485 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfWindowsLaunchActionDictionary** out) { | |
1486 if (!isWindowsLaunchActionDictionary(podofoDoc, podofoObj)) return false; | |
1487 | |
1488 | |
1489 *out = new SkPdfWindowsLaunchActionDictionary(&podofoDoc, &podofoObj); | |
1490 return true; | |
1491 } | |
1492 | |
1493 static bool map(const SkPdfObject& in, SkPdfThreadActionDictionary** out) { | |
1494 return map(*in.doc(), *in.podofo(), out); | |
1495 } | |
1496 | |
1497 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfThreadActionDictionary** out) { | |
1498 if (!isThreadActionDictionary(podofoDoc, podofoObj)) return false; | |
1499 | |
1500 | |
1501 *out = new SkPdfThreadActionDictionary(&podofoDoc, &podofoObj); | |
1502 return true; | |
1503 } | |
1504 | |
1505 static bool map(const SkPdfObject& in, SkPdfURIActionDictionary** out) { | |
1506 return map(*in.doc(), *in.podofo(), out); | |
1507 } | |
1508 | |
1509 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfURIActionDictionary** out) { | |
1510 if (!isURIActionDictionary(podofoDoc, podofoObj)) return false; | |
1511 | |
1512 | |
1513 *out = new SkPdfURIActionDictionary(&podofoDoc, &podofoObj); | |
1514 return true; | |
1515 } | |
1516 | |
1517 static bool map(const SkPdfObject& in, SkPdfURIDictionary** out) { | |
1518 return map(*in.doc(), *in.podofo(), out); | |
1519 } | |
1520 | |
1521 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfURIDictionary** out) { | |
1522 if (!isURIDictionary(podofoDoc, podofoObj)) return false; | |
1523 | |
1524 | |
1525 *out = new SkPdfURIDictionary(&podofoDoc, &podofoObj); | |
1526 return true; | |
1527 } | |
1528 | |
1529 static bool map(const SkPdfObject& in, SkPdfSoundActionDictionary** out) { | |
1530 return map(*in.doc(), *in.podofo(), out); | |
1531 } | |
1532 | |
1533 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfSoundActionDictionary** out) { | |
1534 if (!isSoundActionDictionary(podofoDoc, podofoObj)) return false; | |
1535 | |
1536 | |
1537 *out = new SkPdfSoundActionDictionary(&podofoDoc, &podofoObj); | |
1538 return true; | |
1539 } | |
1540 | |
1541 static bool map(const SkPdfObject& in, SkPdfMovieActionDictionary** out) { | |
1542 return map(*in.doc(), *in.podofo(), out); | |
1543 } | |
1544 | |
1545 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfMovieActionDictionary** out) { | |
1546 if (!isMovieActionDictionary(podofoDoc, podofoObj)) return false; | |
1547 | |
1548 | |
1549 *out = new SkPdfMovieActionDictionary(&podofoDoc, &podofoObj); | |
1550 return true; | |
1551 } | |
1552 | |
1553 static bool map(const SkPdfObject& in, SkPdfHideActionDictionary** out) { | |
1554 return map(*in.doc(), *in.podofo(), out); | |
1555 } | |
1556 | |
1557 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfHideActionDictionary** out) { | |
1558 if (!isHideActionDictionary(podofoDoc, podofoObj)) return false; | |
1559 | |
1560 | |
1561 *out = new SkPdfHideActionDictionary(&podofoDoc, &podofoObj); | |
1562 return true; | |
1563 } | |
1564 | |
1565 static bool map(const SkPdfObject& in, SkPdfNamedActionsDictionary** out) { | |
1566 return map(*in.doc(), *in.podofo(), out); | |
1567 } | |
1568 | |
1569 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfNamedActionsDictionary** out) { | |
1570 if (!isNamedActionsDictionary(podofoDoc, podofoObj)) return false; | |
1571 | |
1572 | |
1573 *out = new SkPdfNamedActionsDictionary(&podofoDoc, &podofoObj); | |
1574 return true; | |
1575 } | |
1576 | |
1577 static bool map(const SkPdfObject& in, SkPdfInteractiveFormDictionary** out) { | |
1578 return map(*in.doc(), *in.podofo(), out); | |
1579 } | |
1580 | |
1581 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfInteractiveFormDictionary** out) { | |
1582 if (!isInteractiveFormDictionary(podofoDoc, podofoObj)) return false; | |
1583 | |
1584 | |
1585 *out = new SkPdfInteractiveFormDictionary(&podofoDoc, &podofoObj); | |
1586 return true; | |
1587 } | |
1588 | |
1589 static bool map(const SkPdfObject& in, SkPdfFieldDictionary** out) { | |
1590 return map(*in.doc(), *in.podofo(), out); | |
1591 } | |
1592 | |
1593 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFieldDictionary** out) { | |
1594 if (!isFieldDictionary(podofoDoc, podofoObj)) return false; | |
1595 | |
1596 | |
1597 *out = new SkPdfFieldDictionary(&podofoDoc, &podofoObj); | |
1598 return true; | |
1599 } | |
1600 | |
1601 static bool map(const SkPdfObject& in, SkPdfVariableTextFieldDictionary** out)
{ | |
1602 return map(*in.doc(), *in.podofo(), out); | |
1603 } | |
1604 | |
1605 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfVariableTextFieldDictionary** out) { | |
1606 if (!isVariableTextFieldDictionary(podofoDoc, podofoObj)) return false; | |
1607 | |
1608 | |
1609 *out = new SkPdfVariableTextFieldDictionary(&podofoDoc, &podofoObj); | |
1610 return true; | |
1611 } | |
1612 | |
1613 static bool map(const SkPdfObject& in, SkPdfAppearanceCharacteristicsDictionar
y** out) { | |
1614 return map(*in.doc(), *in.podofo(), out); | |
1615 } | |
1616 | |
1617 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfAppearanceCharacteristicsDictionary** out) { | |
1618 if (!isAppearanceCharacteristicsDictionary(podofoDoc, podofoObj)) return fal
se; | |
1619 | |
1620 | |
1621 *out = new SkPdfAppearanceCharacteristicsDictionary(&podofoDoc, &podofoObj); | |
1622 return true; | |
1623 } | |
1624 | |
1625 static bool map(const SkPdfObject& in, SkPdfCheckboxFieldDictionary** out) { | |
1626 return map(*in.doc(), *in.podofo(), out); | |
1627 } | |
1628 | |
1629 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfCheckboxFieldDictionary** out) { | |
1630 if (!isCheckboxFieldDictionary(podofoDoc, podofoObj)) return false; | |
1631 | |
1632 | |
1633 *out = new SkPdfCheckboxFieldDictionary(&podofoDoc, &podofoObj); | |
1634 return true; | |
1635 } | |
1636 | |
1637 static bool map(const SkPdfObject& in, SkPdfRadioButtonFieldDictionary** out)
{ | |
1638 return map(*in.doc(), *in.podofo(), out); | |
1639 } | |
1640 | |
1641 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfRadioButtonFieldDictionary** out) { | |
1642 if (!isRadioButtonFieldDictionary(podofoDoc, podofoObj)) return false; | |
1643 | |
1644 | |
1645 *out = new SkPdfRadioButtonFieldDictionary(&podofoDoc, &podofoObj); | |
1646 return true; | |
1647 } | |
1648 | |
1649 static bool map(const SkPdfObject& in, SkPdfTextFieldDictionary** out) { | |
1650 return map(*in.doc(), *in.podofo(), out); | |
1651 } | |
1652 | |
1653 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfTextFieldDictionary** out) { | |
1654 if (!isTextFieldDictionary(podofoDoc, podofoObj)) return false; | |
1655 | |
1656 | |
1657 *out = new SkPdfTextFieldDictionary(&podofoDoc, &podofoObj); | |
1658 return true; | |
1659 } | |
1660 | |
1661 static bool map(const SkPdfObject& in, SkPdfChoiceFieldDictionary** out) { | |
1662 return map(*in.doc(), *in.podofo(), out); | |
1663 } | |
1664 | |
1665 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfChoiceFieldDictionary** out) { | |
1666 if (!isChoiceFieldDictionary(podofoDoc, podofoObj)) return false; | |
1667 | |
1668 | |
1669 *out = new SkPdfChoiceFieldDictionary(&podofoDoc, &podofoObj); | |
1670 return true; | |
1671 } | |
1672 | |
1673 static bool map(const SkPdfObject& in, SkPdfSignatureDictionary** out) { | |
1674 return map(*in.doc(), *in.podofo(), out); | |
1675 } | |
1676 | |
1677 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfSignatureDictionary** out) { | |
1678 if (!isSignatureDictionary(podofoDoc, podofoObj)) return false; | |
1679 | |
1680 | |
1681 *out = new SkPdfSignatureDictionary(&podofoDoc, &podofoObj); | |
1682 return true; | |
1683 } | |
1684 | |
1685 static bool map(const SkPdfObject& in, SkPdfSubmitFormActionDictionary** out)
{ | |
1686 return map(*in.doc(), *in.podofo(), out); | |
1687 } | |
1688 | |
1689 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfSubmitFormActionDictionary** out) { | |
1690 if (!isSubmitFormActionDictionary(podofoDoc, podofoObj)) return false; | |
1691 | |
1692 | |
1693 *out = new SkPdfSubmitFormActionDictionary(&podofoDoc, &podofoObj); | |
1694 return true; | |
1695 } | |
1696 | |
1697 static bool map(const SkPdfObject& in, SkPdfResetFormActionDictionary** out) { | |
1698 return map(*in.doc(), *in.podofo(), out); | |
1699 } | |
1700 | |
1701 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfResetFormActionDictionary** out) { | |
1702 if (!isResetFormActionDictionary(podofoDoc, podofoObj)) return false; | |
1703 | |
1704 | |
1705 *out = new SkPdfResetFormActionDictionary(&podofoDoc, &podofoObj); | |
1706 return true; | |
1707 } | |
1708 | |
1709 static bool map(const SkPdfObject& in, SkPdfImportDataActionDictionary** out)
{ | |
1710 return map(*in.doc(), *in.podofo(), out); | |
1711 } | |
1712 | |
1713 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfImportDataActionDictionary** out) { | |
1714 if (!isImportDataActionDictionary(podofoDoc, podofoObj)) return false; | |
1715 | |
1716 | |
1717 *out = new SkPdfImportDataActionDictionary(&podofoDoc, &podofoObj); | |
1718 return true; | |
1719 } | |
1720 | |
1721 static bool map(const SkPdfObject& in, SkPdfJavascriptActionDictionary** out)
{ | |
1722 return map(*in.doc(), *in.podofo(), out); | |
1723 } | |
1724 | |
1725 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfJavascriptActionDictionary** out) { | |
1726 if (!isJavascriptActionDictionary(podofoDoc, podofoObj)) return false; | |
1727 | |
1728 | |
1729 *out = new SkPdfJavascriptActionDictionary(&podofoDoc, &podofoObj); | |
1730 return true; | |
1731 } | |
1732 | |
1733 static bool map(const SkPdfObject& in, SkPdfFDFTrailerDictionary** out) { | |
1734 return map(*in.doc(), *in.podofo(), out); | |
1735 } | |
1736 | |
1737 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFDFTrailerDictionary** out) { | |
1738 if (!isFDFTrailerDictionary(podofoDoc, podofoObj)) return false; | |
1739 | |
1740 | |
1741 *out = new SkPdfFDFTrailerDictionary(&podofoDoc, &podofoObj); | |
1742 return true; | |
1743 } | |
1744 | |
1745 static bool map(const SkPdfObject& in, SkPdfFDFCatalogDictionary** out) { | |
1746 return map(*in.doc(), *in.podofo(), out); | |
1747 } | |
1748 | |
1749 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFDFCatalogDictionary** out) { | |
1750 if (!isFDFCatalogDictionary(podofoDoc, podofoObj)) return false; | |
1751 | |
1752 | |
1753 *out = new SkPdfFDFCatalogDictionary(&podofoDoc, &podofoObj); | |
1754 return true; | |
1755 } | |
1756 | |
1757 static bool map(const SkPdfObject& in, SkPdfFDFDictionary** out) { | |
1758 return map(*in.doc(), *in.podofo(), out); | |
1759 } | |
1760 | |
1761 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFDFDictionary** out) { | |
1762 if (!isFDFDictionary(podofoDoc, podofoObj)) return false; | |
1763 | |
1764 | |
1765 *out = new SkPdfFDFDictionary(&podofoDoc, &podofoObj); | |
1766 return true; | |
1767 } | |
1768 | |
1769 static bool map(const SkPdfObject& in, SkPdfEncryptedEmbeddedFileStreamDiction
ary** out) { | |
1770 return map(*in.doc(), *in.podofo(), out); | |
1771 } | |
1772 | |
1773 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfEncryptedEmbeddedFileStreamDictionary** out) { | |
1774 if (!isEncryptedEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return f
alse; | |
1775 | |
1776 | |
1777 *out = new SkPdfEncryptedEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj
); | |
1778 return true; | |
1779 } | |
1780 | |
1781 static bool map(const SkPdfObject& in, SkPdfJavascriptDictionary** out) { | |
1782 return map(*in.doc(), *in.podofo(), out); | |
1783 } | |
1784 | |
1785 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfJavascriptDictionary** out) { | |
1786 if (!isJavascriptDictionary(podofoDoc, podofoObj)) return false; | |
1787 | |
1788 | |
1789 *out = new SkPdfJavascriptDictionary(&podofoDoc, &podofoObj); | |
1790 return true; | |
1791 } | |
1792 | |
1793 static bool map(const SkPdfObject& in, SkPdfFDFFieldDictionary** out) { | |
1794 return map(*in.doc(), *in.podofo(), out); | |
1795 } | |
1796 | |
1797 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFDFFieldDictionary** out) { | |
1798 if (!isFDFFieldDictionary(podofoDoc, podofoObj)) return false; | |
1799 | |
1800 | |
1801 *out = new SkPdfFDFFieldDictionary(&podofoDoc, &podofoObj); | |
1802 return true; | |
1803 } | |
1804 | |
1805 static bool map(const SkPdfObject& in, SkPdfIconFitDictionary** out) { | |
1806 return map(*in.doc(), *in.podofo(), out); | |
1807 } | |
1808 | |
1809 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfIconFitDictionary** out) { | |
1810 if (!isIconFitDictionary(podofoDoc, podofoObj)) return false; | |
1811 | |
1812 | |
1813 *out = new SkPdfIconFitDictionary(&podofoDoc, &podofoObj); | |
1814 return true; | |
1815 } | |
1816 | |
1817 static bool map(const SkPdfObject& in, SkPdfFDFPageDictionary** out) { | |
1818 return map(*in.doc(), *in.podofo(), out); | |
1819 } | |
1820 | |
1821 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFDFPageDictionary** out) { | |
1822 if (!isFDFPageDictionary(podofoDoc, podofoObj)) return false; | |
1823 | |
1824 | |
1825 *out = new SkPdfFDFPageDictionary(&podofoDoc, &podofoObj); | |
1826 return true; | |
1827 } | |
1828 | |
1829 static bool map(const SkPdfObject& in, SkPdfFDFTemplateDictionary** out) { | |
1830 return map(*in.doc(), *in.podofo(), out); | |
1831 } | |
1832 | |
1833 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFDFTemplateDictionary** out) { | |
1834 if (!isFDFTemplateDictionary(podofoDoc, podofoObj)) return false; | |
1835 | |
1836 | |
1837 *out = new SkPdfFDFTemplateDictionary(&podofoDoc, &podofoObj); | |
1838 return true; | |
1839 } | |
1840 | |
1841 static bool map(const SkPdfObject& in, SkPdfFDFNamedPageReferenceDictionary**
out) { | |
1842 return map(*in.doc(), *in.podofo(), out); | |
1843 } | |
1844 | |
1845 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFDFNamedPageReferenceDictionary** out) { | |
1846 if (!isFDFNamedPageReferenceDictionary(podofoDoc, podofoObj)) return false; | |
1847 | |
1848 | |
1849 *out = new SkPdfFDFNamedPageReferenceDictionary(&podofoDoc, &podofoObj); | |
1850 return true; | |
1851 } | |
1852 | |
1853 static bool map(const SkPdfObject& in, SkPdfFDFFileAnnotationDictionary** out)
{ | |
1854 return map(*in.doc(), *in.podofo(), out); | |
1855 } | |
1856 | |
1857 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfFDFFileAnnotationDictionary** out) { | |
1858 if (!isFDFFileAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
1859 | |
1860 | |
1861 *out = new SkPdfFDFFileAnnotationDictionary(&podofoDoc, &podofoObj); | |
1862 return true; | |
1863 } | |
1864 | |
1865 static bool map(const SkPdfObject& in, SkPdfSoundObjectDictionary** out) { | |
1866 return map(*in.doc(), *in.podofo(), out); | |
1867 } | |
1868 | |
1869 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfSoundObjectDictionary** out) { | |
1870 if (!isSoundObjectDictionary(podofoDoc, podofoObj)) return false; | |
1871 | |
1872 | |
1873 *out = new SkPdfSoundObjectDictionary(&podofoDoc, &podofoObj); | |
1874 return true; | |
1875 } | |
1876 | |
1877 static bool map(const SkPdfObject& in, SkPdfMovieDictionary** out) { | |
1878 return map(*in.doc(), *in.podofo(), out); | |
1879 } | |
1880 | |
1881 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfMovieDictionary** out) { | |
1882 if (!isMovieDictionary(podofoDoc, podofoObj)) return false; | |
1883 | |
1884 | |
1885 *out = new SkPdfMovieDictionary(&podofoDoc, &podofoObj); | |
1886 return true; | |
1887 } | |
1888 | |
1889 static bool map(const SkPdfObject& in, SkPdfMovieActivationDictionary** out) { | |
1890 return map(*in.doc(), *in.podofo(), out); | |
1891 } | |
1892 | |
1893 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfMovieActivationDictionary** out) { | |
1894 if (!isMovieActivationDictionary(podofoDoc, podofoObj)) return false; | |
1895 | |
1896 | |
1897 *out = new SkPdfMovieActivationDictionary(&podofoDoc, &podofoObj); | |
1898 return true; | |
1899 } | |
1900 | |
1901 static bool map(const SkPdfObject& in, SkPdfDocumentInformationDictionary** ou
t) { | |
1902 return map(*in.doc(), *in.podofo(), out); | |
1903 } | |
1904 | |
1905 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfDocumentInformationDictionary** out) { | |
1906 if (!isDocumentInformationDictionary(podofoDoc, podofoObj)) return false; | |
1907 | |
1908 | |
1909 *out = new SkPdfDocumentInformationDictionary(&podofoDoc, &podofoObj); | |
1910 return true; | |
1911 } | |
1912 | |
1913 static bool map(const SkPdfObject& in, SkPdfMetadataStreamDictionary** out) { | |
1914 return map(*in.doc(), *in.podofo(), out); | |
1915 } | |
1916 | |
1917 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfMetadataStreamDictionary** out) { | |
1918 if (!isMetadataStreamDictionary(podofoDoc, podofoObj)) return false; | |
1919 | |
1920 | |
1921 *out = new SkPdfMetadataStreamDictionary(&podofoDoc, &podofoObj); | |
1922 return true; | |
1923 } | |
1924 | |
1925 static bool map(const SkPdfObject& in, SkPdfComponentsWithMetadataDictionary**
out) { | |
1926 return map(*in.doc(), *in.podofo(), out); | |
1927 } | |
1928 | |
1929 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfComponentsWithMetadataDictionary** out) { | |
1930 if (!isComponentsWithMetadataDictionary(podofoDoc, podofoObj)) return false; | |
1931 | |
1932 | |
1933 *out = new SkPdfComponentsWithMetadataDictionary(&podofoDoc, &podofoObj); | |
1934 return true; | |
1935 } | |
1936 | |
1937 static bool map(const SkPdfObject& in, SkPdfPagePieceDictionary** out) { | |
1938 return map(*in.doc(), *in.podofo(), out); | |
1939 } | |
1940 | |
1941 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfPagePieceDictionary** out) { | |
1942 if (!isPagePieceDictionary(podofoDoc, podofoObj)) return false; | |
1943 | |
1944 | |
1945 *out = new SkPdfPagePieceDictionary(&podofoDoc, &podofoObj); | |
1946 return true; | |
1947 } | |
1948 | |
1949 static bool map(const SkPdfObject& in, SkPdfApplicationDataDictionary** out) { | |
1950 return map(*in.doc(), *in.podofo(), out); | |
1951 } | |
1952 | |
1953 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfApplicationDataDictionary** out) { | |
1954 if (!isApplicationDataDictionary(podofoDoc, podofoObj)) return false; | |
1955 | |
1956 | |
1957 *out = new SkPdfApplicationDataDictionary(&podofoDoc, &podofoObj); | |
1958 return true; | |
1959 } | |
1960 | |
1961 static bool map(const SkPdfObject& in, SkPdfStructureTreeRootDictionary** out)
{ | |
1962 return map(*in.doc(), *in.podofo(), out); | |
1963 } | |
1964 | |
1965 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfStructureTreeRootDictionary** out) { | |
1966 if (!isStructureTreeRootDictionary(podofoDoc, podofoObj)) return false; | |
1967 | |
1968 | |
1969 *out = new SkPdfStructureTreeRootDictionary(&podofoDoc, &podofoObj); | |
1970 return true; | |
1971 } | |
1972 | |
1973 static bool map(const SkPdfObject& in, SkPdfStructureElementDictionary** out)
{ | |
1974 return map(*in.doc(), *in.podofo(), out); | |
1975 } | |
1976 | |
1977 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfStructureElementDictionary** out) { | |
1978 if (!isStructureElementDictionary(podofoDoc, podofoObj)) return false; | |
1979 | |
1980 | |
1981 *out = new SkPdfStructureElementDictionary(&podofoDoc, &podofoObj); | |
1982 return true; | |
1983 } | |
1984 | |
1985 static bool map(const SkPdfObject& in, SkPdfMarkedContentReferenceDictionary**
out) { | |
1986 return map(*in.doc(), *in.podofo(), out); | |
1987 } | |
1988 | |
1989 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfMarkedContentReferenceDictionary** out) { | |
1990 if (!isMarkedContentReferenceDictionary(podofoDoc, podofoObj)) return false; | |
1991 | |
1992 | |
1993 *out = new SkPdfMarkedContentReferenceDictionary(&podofoDoc, &podofoObj); | |
1994 return true; | |
1995 } | |
1996 | |
1997 static bool map(const SkPdfObject& in, SkPdfObjectReferenceDictionary** out) { | |
1998 return map(*in.doc(), *in.podofo(), out); | |
1999 } | |
2000 | |
2001 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfObjectReferenceDictionary** out) { | |
2002 if (!isObjectReferenceDictionary(podofoDoc, podofoObj)) return false; | |
2003 | |
2004 | |
2005 *out = new SkPdfObjectReferenceDictionary(&podofoDoc, &podofoObj); | |
2006 return true; | |
2007 } | |
2008 | |
2009 static bool map(const SkPdfObject& in, SkPdfStructureElementAccessDictionary**
out) { | |
2010 return map(*in.doc(), *in.podofo(), out); | |
2011 } | |
2012 | |
2013 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfStructureElementAccessDictionary** out) { | |
2014 if (!isStructureElementAccessDictionary(podofoDoc, podofoObj)) return false; | |
2015 | |
2016 | |
2017 *out = new SkPdfStructureElementAccessDictionary(&podofoDoc, &podofoObj); | |
2018 return true; | |
2019 } | |
2020 | |
2021 static bool map(const SkPdfObject& in, SkPdfAttributeObjectDictionary** out) { | |
2022 return map(*in.doc(), *in.podofo(), out); | |
2023 } | |
2024 | |
2025 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfAttributeObjectDictionary** out) { | |
2026 if (!isAttributeObjectDictionary(podofoDoc, podofoObj)) return false; | |
2027 | |
2028 | |
2029 *out = new SkPdfAttributeObjectDictionary(&podofoDoc, &podofoObj); | |
2030 return true; | |
2031 } | |
2032 | |
2033 static bool map(const SkPdfObject& in, SkPdfMarkInformationDictionary** out) { | |
2034 return map(*in.doc(), *in.podofo(), out); | |
2035 } | |
2036 | |
2037 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfMarkInformationDictionary** out) { | |
2038 if (!isMarkInformationDictionary(podofoDoc, podofoObj)) return false; | |
2039 | |
2040 | |
2041 *out = new SkPdfMarkInformationDictionary(&podofoDoc, &podofoObj); | |
2042 return true; | |
2043 } | |
2044 | |
2045 static bool map(const SkPdfObject& in, SkPdfArtifactsDictionary** out) { | |
2046 return map(*in.doc(), *in.podofo(), out); | |
2047 } | |
2048 | |
2049 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfArtifactsDictionary** out) { | |
2050 if (!isArtifactsDictionary(podofoDoc, podofoObj)) return false; | |
2051 | |
2052 | |
2053 *out = new SkPdfArtifactsDictionary(&podofoDoc, &podofoObj); | |
2054 return true; | |
2055 } | |
2056 | |
2057 static bool map(const SkPdfObject& in, SkPdfStandardStructureDictionary** out)
{ | |
2058 return map(*in.doc(), *in.podofo(), out); | |
2059 } | |
2060 | |
2061 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfStandardStructureDictionary** out) { | |
2062 if (!isStandardStructureDictionary(podofoDoc, podofoObj)) return false; | |
2063 | |
2064 | |
2065 *out = new SkPdfStandardStructureDictionary(&podofoDoc, &podofoObj); | |
2066 return true; | |
2067 } | |
2068 | |
2069 static bool map(const SkPdfObject& in, SkPdfBlockLevelStructureElementsDiction
ary** out) { | |
2070 return map(*in.doc(), *in.podofo(), out); | |
2071 } | |
2072 | |
2073 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfBlockLevelStructureElementsDictionary** out) { | |
2074 if (!isBlockLevelStructureElementsDictionary(podofoDoc, podofoObj)) return f
alse; | |
2075 | |
2076 | |
2077 *out = new SkPdfBlockLevelStructureElementsDictionary(&podofoDoc, &podofoObj
); | |
2078 return true; | |
2079 } | |
2080 | |
2081 static bool map(const SkPdfObject& in, SkPdfInlineLevelStructureElementsDictio
nary** out) { | |
2082 return map(*in.doc(), *in.podofo(), out); | |
2083 } | |
2084 | |
2085 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfInlineLevelStructureElementsDictionary** out) { | |
2086 if (!isInlineLevelStructureElementsDictionary(podofoDoc, podofoObj)) return
false; | |
2087 | |
2088 | |
2089 *out = new SkPdfInlineLevelStructureElementsDictionary(&podofoDoc, &podofoOb
j); | |
2090 return true; | |
2091 } | |
2092 | |
2093 static bool map(const SkPdfObject& in, SkPdfListAttributeDictionary** out) { | |
2094 return map(*in.doc(), *in.podofo(), out); | |
2095 } | |
2096 | |
2097 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfListAttributeDictionary** out) { | |
2098 if (!isListAttributeDictionary(podofoDoc, podofoObj)) return false; | |
2099 | |
2100 | |
2101 *out = new SkPdfListAttributeDictionary(&podofoDoc, &podofoObj); | |
2102 return true; | |
2103 } | |
2104 | |
2105 static bool map(const SkPdfObject& in, SkPdfTableAttributesDictionary** out) { | |
2106 return map(*in.doc(), *in.podofo(), out); | |
2107 } | |
2108 | |
2109 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfTableAttributesDictionary** out) { | |
2110 if (!isTableAttributesDictionary(podofoDoc, podofoObj)) return false; | |
2111 | |
2112 | |
2113 *out = new SkPdfTableAttributesDictionary(&podofoDoc, &podofoObj); | |
2114 return true; | |
2115 } | |
2116 | |
2117 static bool map(const SkPdfObject& in, SkPdfWebCaptureInformationDictionary**
out) { | |
2118 return map(*in.doc(), *in.podofo(), out); | |
2119 } | |
2120 | |
2121 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfWebCaptureInformationDictionary** out) { | |
2122 if (!isWebCaptureInformationDictionary(podofoDoc, podofoObj)) return false; | |
2123 | |
2124 | |
2125 *out = new SkPdfWebCaptureInformationDictionary(&podofoDoc, &podofoObj); | |
2126 return true; | |
2127 } | |
2128 | |
2129 static bool map(const SkPdfObject& in, SkPdfWebCaptureDictionary** out) { | |
2130 return map(*in.doc(), *in.podofo(), out); | |
2131 } | |
2132 | |
2133 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfWebCaptureDictionary** out) { | |
2134 if (!isWebCaptureDictionary(podofoDoc, podofoObj)) return false; | |
2135 | |
2136 | |
2137 *out = new SkPdfWebCaptureDictionary(&podofoDoc, &podofoObj); | |
2138 return true; | |
2139 } | |
2140 | |
2141 static bool map(const SkPdfObject& in, SkPdfWebCapturePageSetDictionary** out)
{ | |
2142 return map(*in.doc(), *in.podofo(), out); | |
2143 } | |
2144 | |
2145 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfWebCapturePageSetDictionary** out) { | |
2146 if (!isWebCapturePageSetDictionary(podofoDoc, podofoObj)) return false; | |
2147 | |
2148 | |
2149 *out = new SkPdfWebCapturePageSetDictionary(&podofoDoc, &podofoObj); | |
2150 return true; | |
2151 } | |
2152 | |
2153 static bool map(const SkPdfObject& in, SkPdfWebCaptureImageSetDictionary** out
) { | |
2154 return map(*in.doc(), *in.podofo(), out); | |
2155 } | |
2156 | |
2157 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfWebCaptureImageSetDictionary** out) { | |
2158 if (!isWebCaptureImageSetDictionary(podofoDoc, podofoObj)) return false; | |
2159 | |
2160 | |
2161 *out = new SkPdfWebCaptureImageSetDictionary(&podofoDoc, &podofoObj); | |
2162 return true; | |
2163 } | |
2164 | |
2165 static bool map(const SkPdfObject& in, SkPdfSourceInformationDictionary** out)
{ | |
2166 return map(*in.doc(), *in.podofo(), out); | |
2167 } | |
2168 | |
2169 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfSourceInformationDictionary** out) { | |
2170 if (!isSourceInformationDictionary(podofoDoc, podofoObj)) return false; | |
2171 | |
2172 | |
2173 *out = new SkPdfSourceInformationDictionary(&podofoDoc, &podofoObj); | |
2174 return true; | |
2175 } | |
2176 | |
2177 static bool map(const SkPdfObject& in, SkPdfURLAliasDictionary** out) { | |
2178 return map(*in.doc(), *in.podofo(), out); | |
2179 } | |
2180 | |
2181 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfURLAliasDictionary** out) { | |
2182 if (!isURLAliasDictionary(podofoDoc, podofoObj)) return false; | |
2183 | |
2184 | |
2185 *out = new SkPdfURLAliasDictionary(&podofoDoc, &podofoObj); | |
2186 return true; | |
2187 } | |
2188 | |
2189 static bool map(const SkPdfObject& in, SkPdfWebCaptureCommandDictionary** out)
{ | |
2190 return map(*in.doc(), *in.podofo(), out); | |
2191 } | |
2192 | |
2193 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfWebCaptureCommandDictionary** out) { | |
2194 if (!isWebCaptureCommandDictionary(podofoDoc, podofoObj)) return false; | |
2195 | |
2196 | |
2197 *out = new SkPdfWebCaptureCommandDictionary(&podofoDoc, &podofoObj); | |
2198 return true; | |
2199 } | |
2200 | |
2201 static bool map(const SkPdfObject& in, SkPdfWebCaptureCommandSettingsDictionar
y** out) { | |
2202 return map(*in.doc(), *in.podofo(), out); | |
2203 } | |
2204 | |
2205 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfWebCaptureCommandSettingsDictionary** out) { | |
2206 if (!isWebCaptureCommandSettingsDictionary(podofoDoc, podofoObj)) return fal
se; | |
2207 | |
2208 | |
2209 *out = new SkPdfWebCaptureCommandSettingsDictionary(&podofoDoc, &podofoObj); | |
2210 return true; | |
2211 } | |
2212 | |
2213 static bool map(const SkPdfObject& in, SkPdfBoxColorInformationDictionary** ou
t) { | |
2214 return map(*in.doc(), *in.podofo(), out); | |
2215 } | |
2216 | |
2217 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfBoxColorInformationDictionary** out) { | |
2218 if (!isBoxColorInformationDictionary(podofoDoc, podofoObj)) return false; | |
2219 | |
2220 | |
2221 *out = new SkPdfBoxColorInformationDictionary(&podofoDoc, &podofoObj); | |
2222 return true; | |
2223 } | |
2224 | |
2225 static bool map(const SkPdfObject& in, SkPdfBoxStyleDictionary** out) { | |
2226 return map(*in.doc(), *in.podofo(), out); | |
2227 } | |
2228 | |
2229 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfBoxStyleDictionary** out) { | |
2230 if (!isBoxStyleDictionary(podofoDoc, podofoObj)) return false; | |
2231 | |
2232 | |
2233 *out = new SkPdfBoxStyleDictionary(&podofoDoc, &podofoObj); | |
2234 return true; | |
2235 } | |
2236 | |
2237 static bool map(const SkPdfObject& in, SkPdfPrinterMarkAnnotationDictionary**
out) { | |
2238 return map(*in.doc(), *in.podofo(), out); | |
2239 } | |
2240 | |
2241 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfPrinterMarkAnnotationDictionary** out) { | |
2242 if (!isPrinterMarkAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
2243 | |
2244 | |
2245 *out = new SkPdfPrinterMarkAnnotationDictionary(&podofoDoc, &podofoObj); | |
2246 return true; | |
2247 } | |
2248 | |
2249 static bool map(const SkPdfObject& in, SkPdfPrinterMarkFormDictionary** out) { | |
2250 return map(*in.doc(), *in.podofo(), out); | |
2251 } | |
2252 | |
2253 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfPrinterMarkFormDictionary** out) { | |
2254 if (!isPrinterMarkFormDictionary(podofoDoc, podofoObj)) return false; | |
2255 | |
2256 | |
2257 *out = new SkPdfPrinterMarkFormDictionary(&podofoDoc, &podofoObj); | |
2258 return true; | |
2259 } | |
2260 | |
2261 static bool map(const SkPdfObject& in, SkPdfSeparationDictionary** out) { | |
2262 return map(*in.doc(), *in.podofo(), out); | |
2263 } | |
2264 | |
2265 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfSeparationDictionary** out) { | |
2266 if (!isSeparationDictionary(podofoDoc, podofoObj)) return false; | |
2267 | |
2268 | |
2269 *out = new SkPdfSeparationDictionary(&podofoDoc, &podofoObj); | |
2270 return true; | |
2271 } | |
2272 | |
2273 static bool map(const SkPdfObject& in, SkPdfPDF_XOutputIntentDictionary** out)
{ | |
2274 return map(*in.doc(), *in.podofo(), out); | |
2275 } | |
2276 | |
2277 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfPDF_XOutputIntentDictionary** out) { | |
2278 if (!isPDF_XOutputIntentDictionary(podofoDoc, podofoObj)) return false; | |
2279 | |
2280 | |
2281 *out = new SkPdfPDF_XOutputIntentDictionary(&podofoDoc, &podofoObj); | |
2282 return true; | |
2283 } | |
2284 | |
2285 static bool map(const SkPdfObject& in, SkPdfTrapNetworkAnnotationDictionary**
out) { | |
2286 return map(*in.doc(), *in.podofo(), out); | |
2287 } | |
2288 | |
2289 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfTrapNetworkAnnotationDictionary** out) { | |
2290 if (!isTrapNetworkAnnotationDictionary(podofoDoc, podofoObj)) return false; | |
2291 | |
2292 | |
2293 *out = new SkPdfTrapNetworkAnnotationDictionary(&podofoDoc, &podofoObj); | |
2294 return true; | |
2295 } | |
2296 | |
2297 static bool map(const SkPdfObject& in, SkPdfTrapNetworkAppearanceStreamDiction
ary** out) { | |
2298 return map(*in.doc(), *in.podofo(), out); | |
2299 } | |
2300 | |
2301 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfTrapNetworkAppearanceStreamDictionary** out) { | |
2302 if (!isTrapNetworkAppearanceStreamDictionary(podofoDoc, podofoObj)) return f
alse; | |
2303 | |
2304 | |
2305 *out = new SkPdfTrapNetworkAppearanceStreamDictionary(&podofoDoc, &podofoObj
); | |
2306 return true; | |
2307 } | |
2308 | |
2309 static bool map(const SkPdfObject& in, SkPdfOpiVersionDictionary** out) { | |
2310 return map(*in.doc(), *in.podofo(), out); | |
2311 } | |
2312 | |
2313 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfOpiVersionDictionary** out) { | |
2314 if (!isOpiVersionDictionary(podofoDoc, podofoObj)) return false; | |
2315 | |
2316 | |
2317 *out = new SkPdfOpiVersionDictionary(&podofoDoc, &podofoObj); | |
2318 return true; | |
2319 } | |
2320 | |
2321 static bool map(const SkPdfObject& in, SkPdfMultiMasterFontDictionary** out) { | |
2322 return map(*in.doc(), *in.podofo(), out); | |
2323 } | |
2324 | |
2325 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfMultiMasterFontDictionary** out) { | |
2326 if (!isMultiMasterFontDictionary(podofoDoc, podofoObj)) return false; | |
2327 | |
2328 | |
2329 *out = new SkPdfMultiMasterFontDictionary(&podofoDoc, &podofoObj); | |
2330 return true; | |
2331 } | |
2332 | |
2333 static bool isObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoO
bj) { | |
2334 return true; | |
2335 } | |
2336 | |
2337 static bool isNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj
) { | |
2338 return podofoObj.GetDataType() == ePdfDataType_Null; | |
2339 } | |
2340 | |
2341 static bool isBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofo
Obj) { | |
2342 return podofoObj.GetDataType() == ePdfDataType_Bool; | |
2343 } | |
2344 | |
2345 static bool isInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofo
Obj) { | |
2346 return podofoObj.GetDataType() == ePdfDataType_Number || podofoObj.GetDataTy
pe() == ePdfDataType_Real; | |
2347 } | |
2348 | |
2349 static bool isNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoO
bj) { | |
2350 return podofoObj.GetDataType() == ePdfDataType_Number || podofoObj.GetDataTy
pe() == ePdfDataType_Real; | |
2351 } | |
2352 | |
2353 static bool isName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj
) { | |
2354 return podofoObj.GetDataType() == ePdfDataType_Name; | |
2355 } | |
2356 | |
2357 static bool isReference(const PdfMemDocument& podofoDoc, const PdfObject& podo
foObj) { | |
2358 return podofoObj.GetDataType() == ePdfDataType_Reference; | |
2359 } | |
2360 | |
2361 static bool isArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoOb
j) { | |
2362 return podofoObj.GetDataType() == ePdfDataType_Array; | |
2363 } | |
2364 | |
2365 static bool isString(const PdfMemDocument& podofoDoc, const PdfObject& podofoO
bj) { | |
2366 return podofoObj.GetDataType() == ePdfDataType_String || podofoObj.GetDataTy
pe() == ePdfDataType_HexString; | |
2367 } | |
2368 | |
2369 static bool isHexString(const PdfMemDocument& podofoDoc, const PdfObject& podo
foObj) { | |
2370 return podofoObj.GetDataType() == ePdfDataType_HexString; | |
2371 } | |
2372 | |
2373 static bool isDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod
ofoObj) { | |
2374 return podofoObj.GetDataType() == ePdfDataType_Dictionary; | |
2375 } | |
2376 | |
2377 static bool isStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoO
bj) { | |
2378 return true; | |
2379 } | |
2380 | |
2381 static bool isXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObje
ct& podofoObj) { | |
2382 return true; | |
2383 } | |
2384 | |
2385 static bool isFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject&
podofoObj) { | |
2386 return true; | |
2387 } | |
2388 | |
2389 static bool isTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2390 std::string Subtype; | |
2391 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", ""
, &Subtype)) return false; | |
2392 if ((Subtype != "TrueType")) return false; | |
2393 | |
2394 return true; | |
2395 } | |
2396 | |
2397 static bool isStreamCommonDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2398 return true; | |
2399 } | |
2400 | |
2401 static bool isLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& p
odofoDoc, const PdfObject& podofoObj) { | |
2402 return true; | |
2403 } | |
2404 | |
2405 static bool isCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc,
const PdfObject& podofoObj) { | |
2406 return true; | |
2407 } | |
2408 | |
2409 static bool isJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2410 return true; | |
2411 } | |
2412 | |
2413 static bool isDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2414 return true; | |
2415 } | |
2416 | |
2417 static bool isFileTrailerDictionary(const PdfMemDocument& podofoDoc, const Pdf
Object& podofoObj) { | |
2418 return true; | |
2419 } | |
2420 | |
2421 static bool isEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, cons
t PdfObject& podofoObj) { | |
2422 return true; | |
2423 } | |
2424 | |
2425 static bool isStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDo
c, const PdfObject& podofoObj) { | |
2426 return true; | |
2427 } | |
2428 | |
2429 static bool isCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObje
ct& podofoObj) { | |
2430 return true; | |
2431 } | |
2432 | |
2433 static bool isPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2434 return true; | |
2435 } | |
2436 | |
2437 static bool isPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfO
bject& podofoObj) { | |
2438 return true; | |
2439 } | |
2440 | |
2441 static bool isNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject&
podofoObj) { | |
2442 return true; | |
2443 } | |
2444 | |
2445 static bool isResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObj
ect& podofoObj) { | |
2446 return true; | |
2447 } | |
2448 | |
2449 static bool isNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2450 return true; | |
2451 } | |
2452 | |
2453 static bool isNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2454 return true; | |
2455 } | |
2456 | |
2457 static bool isFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2458 return true; | |
2459 } | |
2460 | |
2461 static bool isType0FunctionDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2462 return true; | |
2463 } | |
2464 | |
2465 static bool isType2FunctionDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2466 return true; | |
2467 } | |
2468 | |
2469 static bool isType3FunctionDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2470 return true; | |
2471 } | |
2472 | |
2473 static bool isFileSpecificationDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2474 return true; | |
2475 } | |
2476 | |
2477 static bool isEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, co
nst PdfObject& podofoObj) { | |
2478 return true; | |
2479 } | |
2480 | |
2481 static bool isEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc,
const PdfObject& podofoObj) { | |
2482 return true; | |
2483 } | |
2484 | |
2485 static bool isMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc,
const PdfObject& podofoObj) { | |
2486 return true; | |
2487 } | |
2488 | |
2489 static bool isGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2490 return true; | |
2491 } | |
2492 | |
2493 static bool isCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2494 return true; | |
2495 } | |
2496 | |
2497 static bool isCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, cons
t PdfObject& podofoObj) { | |
2498 return true; | |
2499 } | |
2500 | |
2501 static bool isLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2502 return true; | |
2503 } | |
2504 | |
2505 static bool isIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, cons
t PdfObject& podofoObj) { | |
2506 return true; | |
2507 } | |
2508 | |
2509 static bool isDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2510 return true; | |
2511 } | |
2512 | |
2513 static bool isType1PatternDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2514 return true; | |
2515 } | |
2516 | |
2517 static bool isType2PatternDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2518 return true; | |
2519 } | |
2520 | |
2521 static bool isShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObje
ct& podofoObj) { | |
2522 return true; | |
2523 } | |
2524 | |
2525 static bool isType1ShadingDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2526 return true; | |
2527 } | |
2528 | |
2529 static bool isType2ShadingDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2530 return true; | |
2531 } | |
2532 | |
2533 static bool isType3ShadingDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2534 return true; | |
2535 } | |
2536 | |
2537 static bool isType4ShadingDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2538 return true; | |
2539 } | |
2540 | |
2541 static bool isType5ShadingDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2542 return true; | |
2543 } | |
2544 | |
2545 static bool isType6ShadingDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2546 return true; | |
2547 } | |
2548 | |
2549 static bool isImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject
& podofoObj) { | |
2550 std::string Subtype; | |
2551 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", ""
, &Subtype)) return false; | |
2552 if ((Subtype != "Image")) return false; | |
2553 | |
2554 return true; | |
2555 } | |
2556 | |
2557 static bool isAlternateImageDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2558 return true; | |
2559 } | |
2560 | |
2561 static bool isType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfOb
ject& podofoObj) { | |
2562 std::string Subtype; | |
2563 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", ""
, &Subtype)) return false; | |
2564 if ((Subtype != "Form")) return false; | |
2565 | |
2566 return true; | |
2567 } | |
2568 | |
2569 static bool isGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2570 return true; | |
2571 } | |
2572 | |
2573 static bool isReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfOb
ject& podofoObj) { | |
2574 return true; | |
2575 } | |
2576 | |
2577 static bool isPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfOb
ject& podofoObj) { | |
2578 return true; | |
2579 } | |
2580 | |
2581 static bool isType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfOb
ject& podofoObj) { | |
2582 std::string Subtype; | |
2583 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", ""
, &Subtype)) return false; | |
2584 if ((Subtype != "MMType1") && (Subtype != "TrueType") && (Subtype != "Type1"
)) return false; | |
2585 | |
2586 return true; | |
2587 } | |
2588 | |
2589 static bool isType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfOb
ject& podofoObj) { | |
2590 std::string Subtype; | |
2591 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", ""
, &Subtype)) return false; | |
2592 if ((Subtype != "Type3")) return false; | |
2593 | |
2594 return true; | |
2595 } | |
2596 | |
2597 static bool isEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObj
ect& podofoObj) { | |
2598 return true; | |
2599 } | |
2600 | |
2601 static bool isCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2602 return true; | |
2603 } | |
2604 | |
2605 static bool isCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObje
ct& podofoObj) { | |
2606 std::string Subtype; | |
2607 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", ""
, &Subtype)) return false; | |
2608 if ((Subtype != "CIDFontType0") && (Subtype != "CIDFontType2")) return false
; | |
2609 | |
2610 return true; | |
2611 } | |
2612 | |
2613 static bool isCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject&
podofoObj) { | |
2614 return true; | |
2615 } | |
2616 | |
2617 static bool isType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfOb
ject& podofoObj) { | |
2618 std::string Subtype; | |
2619 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", ""
, &Subtype)) return false; | |
2620 if ((Subtype != "Type3") && (Subtype != "Type0")) return false; | |
2621 | |
2622 return true; | |
2623 } | |
2624 | |
2625 static bool isFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2626 return true; | |
2627 } | |
2628 | |
2629 static bool isCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2630 return true; | |
2631 } | |
2632 | |
2633 static bool isEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, co
nst PdfObject& podofoObj) { | |
2634 return true; | |
2635 } | |
2636 | |
2637 static bool isType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2638 return true; | |
2639 } | |
2640 | |
2641 static bool isType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2642 return true; | |
2643 } | |
2644 | |
2645 static bool isType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2646 return true; | |
2647 } | |
2648 | |
2649 static bool isType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2650 return true; | |
2651 } | |
2652 | |
2653 static bool isType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2654 return true; | |
2655 } | |
2656 | |
2657 static bool isSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObj
ect& podofoObj) { | |
2658 return true; | |
2659 } | |
2660 | |
2661 static bool isSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2662 return true; | |
2663 } | |
2664 | |
2665 static bool isTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2666 return true; | |
2667 } | |
2668 | |
2669 static bool isViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2670 return true; | |
2671 } | |
2672 | |
2673 static bool isOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObje
ct& podofoObj) { | |
2674 return true; | |
2675 } | |
2676 | |
2677 static bool isOutlineItemDictionary(const PdfMemDocument& podofoDoc, const Pdf
Object& podofoObj) { | |
2678 return true; | |
2679 } | |
2680 | |
2681 static bool isPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfOb
ject& podofoObj) { | |
2682 return true; | |
2683 } | |
2684 | |
2685 static bool isThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObjec
t& podofoObj) { | |
2686 return true; | |
2687 } | |
2688 | |
2689 static bool isBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject&
podofoObj) { | |
2690 return true; | |
2691 } | |
2692 | |
2693 static bool isTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfO
bject& podofoObj) { | |
2694 return true; | |
2695 } | |
2696 | |
2697 static bool isAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfO
bject& podofoObj) { | |
2698 return true; | |
2699 } | |
2700 | |
2701 static bool isBorderStyleDictionary(const PdfMemDocument& podofoDoc, const Pdf
Object& podofoObj) { | |
2702 return true; | |
2703 } | |
2704 | |
2705 static bool isAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfO
bject& podofoObj) { | |
2706 return true; | |
2707 } | |
2708 | |
2709 static bool isTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2710 return true; | |
2711 } | |
2712 | |
2713 static bool isALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2714 return true; | |
2715 } | |
2716 | |
2717 static bool isFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, co
nst PdfObject& podofoObj) { | |
2718 return true; | |
2719 } | |
2720 | |
2721 static bool isLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2722 return true; | |
2723 } | |
2724 | |
2725 static bool isSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2726 return true; | |
2727 } | |
2728 | |
2729 static bool isMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2730 return true; | |
2731 } | |
2732 | |
2733 static bool isRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc,
const PdfObject& podofoObj) { | |
2734 return true; | |
2735 } | |
2736 | |
2737 static bool isInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2738 return true; | |
2739 } | |
2740 | |
2741 static bool isPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2742 return true; | |
2743 } | |
2744 | |
2745 static bool isFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoD
oc, const PdfObject& podofoObj) { | |
2746 return true; | |
2747 } | |
2748 | |
2749 static bool isSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2750 return true; | |
2751 } | |
2752 | |
2753 static bool isMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2754 return true; | |
2755 } | |
2756 | |
2757 static bool isWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, cons
t PdfObject& podofoObj) { | |
2758 return true; | |
2759 } | |
2760 | |
2761 static bool isActionDictionary(const PdfMemDocument& podofoDoc, const PdfObjec
t& podofoObj) { | |
2762 return true; | |
2763 } | |
2764 | |
2765 static bool isAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2766 return true; | |
2767 } | |
2768 | |
2769 static bool isPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2770 return true; | |
2771 } | |
2772 | |
2773 static bool isFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, cons
t PdfObject& podofoObj) { | |
2774 return true; | |
2775 } | |
2776 | |
2777 static bool isDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc
, const PdfObject& podofoObj) { | |
2778 return true; | |
2779 } | |
2780 | |
2781 static bool isGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfO
bject& podofoObj) { | |
2782 return true; | |
2783 } | |
2784 | |
2785 static bool isRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, cons
t PdfObject& podofoObj) { | |
2786 return true; | |
2787 } | |
2788 | |
2789 static bool isLaunchActionDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2790 return true; | |
2791 } | |
2792 | |
2793 static bool isWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, c
onst PdfObject& podofoObj) { | |
2794 return true; | |
2795 } | |
2796 | |
2797 static bool isThreadActionDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2798 return true; | |
2799 } | |
2800 | |
2801 static bool isURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfOb
ject& podofoObj) { | |
2802 return true; | |
2803 } | |
2804 | |
2805 static bool isURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject&
podofoObj) { | |
2806 return true; | |
2807 } | |
2808 | |
2809 static bool isSoundActionDictionary(const PdfMemDocument& podofoDoc, const Pdf
Object& podofoObj) { | |
2810 return true; | |
2811 } | |
2812 | |
2813 static bool isMovieActionDictionary(const PdfMemDocument& podofoDoc, const Pdf
Object& podofoObj) { | |
2814 return true; | |
2815 } | |
2816 | |
2817 static bool isHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfO
bject& podofoObj) { | |
2818 return true; | |
2819 } | |
2820 | |
2821 static bool isNamedActionsDictionary(const PdfMemDocument& podofoDoc, const Pd
fObject& podofoObj) { | |
2822 return true; | |
2823 } | |
2824 | |
2825 static bool isInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2826 return true; | |
2827 } | |
2828 | |
2829 static bool isFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject
& podofoObj) { | |
2830 return true; | |
2831 } | |
2832 | |
2833 static bool isVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2834 return true; | |
2835 } | |
2836 | |
2837 static bool isAppearanceCharacteristicsDictionary(const PdfMemDocument& podofo
Doc, const PdfObject& podofoObj) { | |
2838 return true; | |
2839 } | |
2840 | |
2841 static bool isCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2842 return true; | |
2843 } | |
2844 | |
2845 static bool isRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, cons
t PdfObject& podofoObj) { | |
2846 return true; | |
2847 } | |
2848 | |
2849 static bool isTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfOb
ject& podofoObj) { | |
2850 return true; | |
2851 } | |
2852 | |
2853 static bool isChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const Pdf
Object& podofoObj) { | |
2854 return true; | |
2855 } | |
2856 | |
2857 static bool isSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfOb
ject& podofoObj) { | |
2858 return true; | |
2859 } | |
2860 | |
2861 static bool isSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, cons
t PdfObject& podofoObj) { | |
2862 return true; | |
2863 } | |
2864 | |
2865 static bool isResetFormActionDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2866 return true; | |
2867 } | |
2868 | |
2869 static bool isImportDataActionDictionary(const PdfMemDocument& podofoDoc, cons
t PdfObject& podofoObj) { | |
2870 return true; | |
2871 } | |
2872 | |
2873 static bool isJavascriptActionDictionary(const PdfMemDocument& podofoDoc, cons
t PdfObject& podofoObj) { | |
2874 return true; | |
2875 } | |
2876 | |
2877 static bool isFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfO
bject& podofoObj) { | |
2878 return true; | |
2879 } | |
2880 | |
2881 static bool isFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfO
bject& podofoObj) { | |
2882 return true; | |
2883 } | |
2884 | |
2885 static bool isFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject&
podofoObj) { | |
2886 return true; | |
2887 } | |
2888 | |
2889 static bool isEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podo
foDoc, const PdfObject& podofoObj) { | |
2890 return true; | |
2891 } | |
2892 | |
2893 static bool isJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfO
bject& podofoObj) { | |
2894 return true; | |
2895 } | |
2896 | |
2897 static bool isFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObj
ect& podofoObj) { | |
2898 return true; | |
2899 } | |
2900 | |
2901 static bool isIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObje
ct& podofoObj) { | |
2902 return true; | |
2903 } | |
2904 | |
2905 static bool isFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObje
ct& podofoObj) { | |
2906 return true; | |
2907 } | |
2908 | |
2909 static bool isFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const Pdf
Object& podofoObj) { | |
2910 return true; | |
2911 } | |
2912 | |
2913 static bool isFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc,
const PdfObject& podofoObj) { | |
2914 return true; | |
2915 } | |
2916 | |
2917 static bool isFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2918 return true; | |
2919 } | |
2920 | |
2921 static bool isSoundObjectDictionary(const PdfMemDocument& podofoDoc, const Pdf
Object& podofoObj) { | |
2922 return true; | |
2923 } | |
2924 | |
2925 static bool isMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject
& podofoObj) { | |
2926 return true; | |
2927 } | |
2928 | |
2929 static bool isMovieActivationDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2930 return true; | |
2931 } | |
2932 | |
2933 static bool isDocumentInformationDictionary(const PdfMemDocument& podofoDoc, c
onst PdfObject& podofoObj) { | |
2934 return true; | |
2935 } | |
2936 | |
2937 static bool isMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2938 return true; | |
2939 } | |
2940 | |
2941 static bool isComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc
, const PdfObject& podofoObj) { | |
2942 return true; | |
2943 } | |
2944 | |
2945 static bool isPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfOb
ject& podofoObj) { | |
2946 return true; | |
2947 } | |
2948 | |
2949 static bool isApplicationDataDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2950 return true; | |
2951 } | |
2952 | |
2953 static bool isStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2954 return true; | |
2955 } | |
2956 | |
2957 static bool isStructureElementDictionary(const PdfMemDocument& podofoDoc, cons
t PdfObject& podofoObj) { | |
2958 return true; | |
2959 } | |
2960 | |
2961 static bool isMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc
, const PdfObject& podofoObj) { | |
2962 return true; | |
2963 } | |
2964 | |
2965 static bool isObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2966 return true; | |
2967 } | |
2968 | |
2969 static bool isStructureElementAccessDictionary(const PdfMemDocument& podofoDoc
, const PdfObject& podofoObj) { | |
2970 return true; | |
2971 } | |
2972 | |
2973 static bool isAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2974 return true; | |
2975 } | |
2976 | |
2977 static bool isMarkInformationDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
2978 return true; | |
2979 } | |
2980 | |
2981 static bool isArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfOb
ject& podofoObj) { | |
2982 return true; | |
2983 } | |
2984 | |
2985 static bool isStandardStructureDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
2986 return true; | |
2987 } | |
2988 | |
2989 static bool isBlockLevelStructureElementsDictionary(const PdfMemDocument& podo
foDoc, const PdfObject& podofoObj) { | |
2990 return true; | |
2991 } | |
2992 | |
2993 static bool isInlineLevelStructureElementsDictionary(const PdfMemDocument& pod
ofoDoc, const PdfObject& podofoObj) { | |
2994 return true; | |
2995 } | |
2996 | |
2997 static bool isListAttributeDictionary(const PdfMemDocument& podofoDoc, const P
dfObject& podofoObj) { | |
2998 return true; | |
2999 } | |
3000 | |
3001 static bool isTableAttributesDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
3002 return true; | |
3003 } | |
3004 | |
3005 static bool isWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc,
const PdfObject& podofoObj) { | |
3006 return true; | |
3007 } | |
3008 | |
3009 static bool isWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfO
bject& podofoObj) { | |
3010 return true; | |
3011 } | |
3012 | |
3013 static bool isWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
3014 return true; | |
3015 } | |
3016 | |
3017 static bool isWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, co
nst PdfObject& podofoObj) { | |
3018 return true; | |
3019 } | |
3020 | |
3021 static bool isSourceInformationDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
3022 return true; | |
3023 } | |
3024 | |
3025 static bool isURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObj
ect& podofoObj) { | |
3026 return true; | |
3027 } | |
3028 | |
3029 static bool isWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
3030 return true; | |
3031 } | |
3032 | |
3033 static bool isWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofo
Doc, const PdfObject& podofoObj) { | |
3034 return true; | |
3035 } | |
3036 | |
3037 static bool isBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, c
onst PdfObject& podofoObj) { | |
3038 return true; | |
3039 } | |
3040 | |
3041 static bool isBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObj
ect& podofoObj) { | |
3042 return true; | |
3043 } | |
3044 | |
3045 static bool isPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc,
const PdfObject& podofoObj) { | |
3046 return true; | |
3047 } | |
3048 | |
3049 static bool isPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
3050 return true; | |
3051 } | |
3052 | |
3053 static bool isSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfO
bject& podofoObj) { | |
3054 return true; | |
3055 } | |
3056 | |
3057 static bool isPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, con
st PdfObject& podofoObj) { | |
3058 return true; | |
3059 } | |
3060 | |
3061 static bool isTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc,
const PdfObject& podofoObj) { | |
3062 return true; | |
3063 } | |
3064 | |
3065 static bool isTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podo
foDoc, const PdfObject& podofoObj) { | |
3066 return true; | |
3067 } | |
3068 | |
3069 static bool isOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfO
bject& podofoObj) { | |
3070 return true; | |
3071 } | |
3072 | |
3073 static bool isMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const
PdfObject& podofoObj) { | |
3074 std::string Subtype; | |
3075 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", ""
, &Subtype)) return false; | |
3076 if ((Subtype != "MMType1")) return false; | |
3077 | |
3078 return true; | |
3079 } | |
3080 | |
3081 }; | |
3082 | |
3083 #endif // __DEFINED__SkPdfPodofoMapper | |
OLD | NEW |