experimental/PdfViewer/SkPdfPodofoMapper_autogen.h - Issue 17748002: Basic support for Type3 Fonts in Pdf + various refactorings

Side by Side Diff: experimental/PdfViewer/SkPdfPodofoMapper_autogen.h

Issue 17748002: Basic support for Type3 Fonts in Pdf + various refactorings (Closed) Base URL: http://skia.googlecode.com/svn/trunk/

Patch Set: Created 7 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

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

« no previous file with comments | « experimental/PdfViewer/SkPdfParser.h ('k') | experimental/PdfViewer/SkPdfPopUpAnnotationDictionary_autogen.h » ('j') | no next file with comments »