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 if (map(podofoDoc, podofoObj, (SkPdfType3FontDictionary**)out)) return true; |
| 900 |
| 901 *out = new SkPdfType1FontDictionary(&podofoDoc, &podofoObj); |
| 902 return true; |
| 903 } |
| 904 |
| 905 static bool map(const SkPdfObject& in, SkPdfType3FontDictionary** out) { |
| 906 return map(*in.doc(), *in.podofo(), out); |
| 907 } |
| 908 |
| 909 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType3FontDictionary** out) { |
| 910 if (!isType3FontDictionary(podofoDoc, podofoObj)) return false; |
| 911 |
| 912 |
| 913 *out = new SkPdfType3FontDictionary(&podofoDoc, &podofoObj); |
| 914 return true; |
| 915 } |
| 916 |
| 917 static bool map(const SkPdfObject& in, SkPdfEncodingDictionary** out) { |
| 918 return map(*in.doc(), *in.podofo(), out); |
| 919 } |
| 920 |
| 921 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfEncodingDictionary** out) { |
| 922 if (!isEncodingDictionary(podofoDoc, podofoObj)) return false; |
| 923 |
| 924 |
| 925 *out = new SkPdfEncodingDictionary(&podofoDoc, &podofoObj); |
| 926 return true; |
| 927 } |
| 928 |
| 929 static bool map(const SkPdfObject& in, SkPdfCIDSystemInfoDictionary** out) { |
| 930 return map(*in.doc(), *in.podofo(), out); |
| 931 } |
| 932 |
| 933 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfCIDSystemInfoDictionary** out) { |
| 934 if (!isCIDSystemInfoDictionary(podofoDoc, podofoObj)) return false; |
| 935 |
| 936 |
| 937 *out = new SkPdfCIDSystemInfoDictionary(&podofoDoc, &podofoObj); |
| 938 return true; |
| 939 } |
| 940 |
| 941 static bool map(const SkPdfObject& in, SkPdfCIDFontDictionary** out) { |
| 942 return map(*in.doc(), *in.podofo(), out); |
| 943 } |
| 944 |
| 945 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfCIDFontDictionary** out) { |
| 946 if (!isCIDFontDictionary(podofoDoc, podofoObj)) return false; |
| 947 |
| 948 |
| 949 *out = new SkPdfCIDFontDictionary(&podofoDoc, &podofoObj); |
| 950 return true; |
| 951 } |
| 952 |
| 953 static bool map(const SkPdfObject& in, SkPdfCMapDictionary** out) { |
| 954 return map(*in.doc(), *in.podofo(), out); |
| 955 } |
| 956 |
| 957 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfCMapDictionary** out) { |
| 958 if (!isCMapDictionary(podofoDoc, podofoObj)) return false; |
| 959 |
| 960 |
| 961 *out = new SkPdfCMapDictionary(&podofoDoc, &podofoObj); |
| 962 return true; |
| 963 } |
| 964 |
| 965 static bool map(const SkPdfObject& in, SkPdfType0FontDictionary** out) { |
| 966 return map(*in.doc(), *in.podofo(), out); |
| 967 } |
| 968 |
| 969 static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S
kPdfType0FontDictionary** out) { |
| 970 if (!isType0FontDictionary(podofoDoc, podofoObj)) return false; |
| 971 |
| 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 != "Type3"
) && (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 != "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 |