1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 | #include "PDFReaderDriver.h"
|
21 | #include "PDFPageInputDriver.h"
|
22 | #include "PDFDictionaryDriver.h"
|
23 | #include "PDFObjectDriver.h"
|
24 | #include "PDFObjectParserDriver.h"
|
25 | #include "RefCountPtr.h"
|
26 | #include "PDFDictionary.h"
|
27 | #include "PDFArrayDriver.h"
|
28 | #include "PDFArray.h"
|
29 | #include "PDFPageInput.h"
|
30 | #include "PDFStreamInputDriver.h"
|
31 | #include "ByteReaderDriver.h"
|
32 | #include "ByteReaderWithPositionDriver.h"
|
33 | #include "ObjectByteReaderWithPosition.h"
|
34 | #include "ConstructorsHolder.h"
|
35 |
|
36 | using namespace v8;
|
37 |
|
38 |
|
39 |
|
40 | PDFReaderDriver::PDFReaderDriver()
|
41 | {
|
42 | mStartedWithStream = false;
|
43 | mPDFReader = NULL;
|
44 | mReadStreamProxy = NULL;
|
45 | mOwnsParser = false;
|
46 | }
|
47 |
|
48 | PDFReaderDriver::~PDFReaderDriver()
|
49 | {
|
50 | delete mReadStreamProxy;
|
51 | if(mOwnsParser)
|
52 | delete mPDFReader;
|
53 | }
|
54 |
|
55 | DEF_SUBORDINATE_INIT(PDFReaderDriver::Init)
|
56 | {
|
57 | CREATE_ISOLATE_CONTEXT;
|
58 |
|
59 | Local<FunctionTemplate> t = NEW_FUNCTION_TEMPLATE_EXTERNAL(New);
|
60 |
|
61 | t->SetClassName(NEW_STRING("PDFReader"));
|
62 | t->InstanceTemplate()->SetInternalFieldCount(1);
|
63 |
|
64 | SET_PROTOTYPE_METHOD(t, "getPDFLevel", GetPDFLevel);
|
65 | SET_PROTOTYPE_METHOD(t, "getPagesCount", GetPagesCount);
|
66 | SET_PROTOTYPE_METHOD(t, "getTrailer", GetTrailer);
|
67 | SET_PROTOTYPE_METHOD(t, "queryDictionaryObject", QueryDictionaryObject);
|
68 | SET_PROTOTYPE_METHOD(t, "queryArrayObject", QueryArrayObject);
|
69 | SET_PROTOTYPE_METHOD(t, "parseNewObject", ParseNewObject);
|
70 | SET_PROTOTYPE_METHOD(t, "getPageObjectID", GetPageObjectID);
|
71 | SET_PROTOTYPE_METHOD(t, "parsePageDictionary", ParsePageDictionary);
|
72 | SET_PROTOTYPE_METHOD(t, "parsePage", ParsePage);
|
73 | SET_PROTOTYPE_METHOD(t, "getObjectsCount", GetObjectsCount);
|
74 | SET_PROTOTYPE_METHOD(t, "isEncrypted", IsEncrypted);
|
75 | SET_PROTOTYPE_METHOD(t, "getXrefSize", GetXrefSize);
|
76 | SET_PROTOTYPE_METHOD(t, "getXrefEntry", GetXrefEntry);
|
77 | SET_PROTOTYPE_METHOD(t, "getXrefPosition", GetXrefPosition);
|
78 | SET_PROTOTYPE_METHOD(t, "startReadingFromStream", StartReadingFromStream);
|
79 | SET_PROTOTYPE_METHOD(t, "startReadingFromStreamForPlainCopying", StartReadingFromStreamForPlainCopying);
|
80 | SET_PROTOTYPE_METHOD(t, "startReadingObjectsFromStream", StartReadingObjectsFromStream);
|
81 | SET_PROTOTYPE_METHOD(t, "startReadingObjectsFromStreams", StartReadingObjectsFromStreams);
|
82 | SET_PROTOTYPE_METHOD(t, "getParserStream", GetParserStream);
|
83 |
|
84 |
|
85 | EXPOSE_EXTERNAL_FOR_INIT(ConstructorsHolder, holder)
|
86 | SET_CONSTRUCTOR(holder->PDFReader_constructor, t);
|
87 | SET_CONSTRUCTOR_TEMPLATE(holder->PDFReader_constructor_template, t);
|
88 | }
|
89 |
|
90 | METHOD_RETURN_TYPE PDFReaderDriver::New(const ARGS_TYPE& args)
|
91 | {
|
92 | CREATE_ISOLATE_CONTEXT;
|
93 | CREATE_ESCAPABLE_SCOPE;
|
94 | EXPOSE_EXTERNAL_ARGS(ConstructorsHolder, externalHolder)
|
95 |
|
96 | PDFReaderDriver* reader = new PDFReaderDriver();
|
97 |
|
98 | reader->holder = externalHolder;
|
99 | reader->Wrap(args.This());
|
100 |
|
101 | SET_FUNCTION_RETURN_VALUE(args.This())
|
102 | }
|
103 |
|
104 | METHOD_RETURN_TYPE PDFReaderDriver::GetPDFLevel(const ARGS_TYPE& args)
|
105 | {
|
106 | CREATE_ISOLATE_CONTEXT;
|
107 | CREATE_ESCAPABLE_SCOPE;
|
108 |
|
109 | SET_FUNCTION_RETURN_VALUE(NEW_NUMBER(ObjectWrap::Unwrap<PDFReaderDriver>(args.This())->mPDFReader->GetPDFLevel()))
|
110 | }
|
111 |
|
112 | METHOD_RETURN_TYPE PDFReaderDriver::GetPagesCount(const ARGS_TYPE& args)
|
113 | {
|
114 | CREATE_ISOLATE_CONTEXT;
|
115 | CREATE_ESCAPABLE_SCOPE;
|
116 |
|
117 | SET_FUNCTION_RETURN_VALUE(NEW_NUMBER(ObjectWrap::Unwrap<PDFReaderDriver>(args.This())->mPDFReader->GetPagesCount()))
|
118 | }
|
119 |
|
120 |
|
121 | METHOD_RETURN_TYPE PDFReaderDriver::QueryDictionaryObject(const ARGS_TYPE& args)
|
122 | {
|
123 | CREATE_ISOLATE_CONTEXT;
|
124 | CREATE_ESCAPABLE_SCOPE;
|
125 |
|
126 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
127 |
|
128 | if(args.Length() != 2 ||
|
129 | !reader->holder->IsPDFDictionaryInstance(args[0]) ||
|
130 | !args[1]->IsString())
|
131 | {
|
132 | THROW_EXCEPTION("Wrong arguments. Provide a dictionary and a string");
|
133 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
134 | }
|
135 |
|
136 |
|
137 | PDFDictionaryDriver* dictionary = ObjectWrap::Unwrap<PDFDictionaryDriver>(args[0]->TO_OBJECT());
|
138 |
|
139 | RefCountPtr<PDFObject> object = reader->mPDFReader->QueryDictionaryObject(dictionary->TheObject.GetPtr(),*UTF_8_VALUE(args[1]->TO_STRING()));
|
140 | if(!object)
|
141 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
142 |
|
143 | SET_FUNCTION_RETURN_VALUE(reader->holder->GetInstanceFor(object.GetPtr()))
|
144 | }
|
145 |
|
146 | METHOD_RETURN_TYPE PDFReaderDriver::QueryArrayObject(const ARGS_TYPE& args)
|
147 | {
|
148 | CREATE_ISOLATE_CONTEXT;
|
149 | CREATE_ESCAPABLE_SCOPE;
|
150 |
|
151 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
152 |
|
153 | if(args.Length() != 2 ||
|
154 | !reader->holder->IsPDFArrayInstance(args[0]) ||
|
155 | !args[1]->IsNumber())
|
156 | {
|
157 | THROW_EXCEPTION("Wrong arguments. Provide an array and an index");
|
158 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
159 | }
|
160 |
|
161 | PDFArrayDriver* driver = ObjectWrap::Unwrap<PDFArrayDriver>(args[0]->TO_OBJECT());
|
162 |
|
163 | RefCountPtr<PDFObject> object = reader->mPDFReader->QueryArrayObject(driver->TheObject.GetPtr(),TO_UINT32(args[1])->Value());
|
164 | if(!object)
|
165 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
166 |
|
167 | SET_FUNCTION_RETURN_VALUE(reader->holder->GetInstanceFor(object.GetPtr()))
|
168 | }
|
169 |
|
170 | METHOD_RETURN_TYPE PDFReaderDriver::GetTrailer(const ARGS_TYPE& args)
|
171 | {
|
172 | CREATE_ISOLATE_CONTEXT;
|
173 | CREATE_ESCAPABLE_SCOPE;
|
174 |
|
175 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
176 |
|
177 | PDFDictionary* trailer = reader->mPDFReader->GetTrailer();
|
178 |
|
179 | if(!trailer)
|
180 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
181 |
|
182 | SET_FUNCTION_RETURN_VALUE(reader->holder->GetInstanceFor(trailer))
|
183 | }
|
184 |
|
185 | PDFHummus::EStatusCode PDFReaderDriver::StartPDFParsing(v8::Local<v8::Object> inStreamObject,const PDFParsingOptions& inParsingOptions)
|
186 | {
|
187 | if(!mPDFReader && !mOwnsParser)
|
188 | {
|
189 | mPDFReader = new PDFParser();
|
190 | mOwnsParser = true;
|
191 | }
|
192 | if(mReadStreamProxy)
|
193 | {
|
194 | delete mReadStreamProxy;
|
195 | mReadStreamProxy = NULL;
|
196 | }
|
197 |
|
198 | mStartedWithStream = true;
|
199 | mReadStreamProxy = new ObjectByteReaderWithPosition(inStreamObject);
|
200 | mPDFReader->ResetParser();
|
201 | return mPDFReader->StartPDFParsing(mReadStreamProxy,inParsingOptions);
|
202 | }
|
203 |
|
204 | PDFHummus::EStatusCode PDFReaderDriver::StartPDFParsing(const std::string& inParsedFilePath,const PDFParsingOptions& inParsingOptions)
|
205 | {
|
206 | if(!mPDFReader && !mOwnsParser)
|
207 | {
|
208 | mPDFReader = new PDFParser();
|
209 | mOwnsParser = true;
|
210 | }
|
211 | if(mReadStreamProxy)
|
212 | {
|
213 | delete mReadStreamProxy;
|
214 | mReadStreamProxy = NULL;
|
215 | }
|
216 |
|
217 |
|
218 | mStartedWithStream = false;
|
219 | mPDFReader->ResetParser();
|
220 | if(mPDFFile.OpenFile(inParsedFilePath) != PDFHummus::eSuccess)
|
221 | return PDFHummus::eFailure;
|
222 | return mPDFReader->StartPDFParsing(mPDFFile.GetInputStream(),inParsingOptions);
|
223 | }
|
224 |
|
225 | void PDFReaderDriver::SetFromOwnedParser(PDFParser* inParser)
|
226 | {
|
227 | if(mOwnsParser)
|
228 | {
|
229 | delete mPDFReader;
|
230 | mOwnsParser = false;
|
231 | delete mReadStreamProxy;
|
232 | mStartedWithStream = false;
|
233 | mPDFFile.CloseFile();
|
234 | }
|
235 | mPDFReader = inParser;
|
236 | }
|
237 |
|
238 | PDFParser* PDFReaderDriver::GetParser()
|
239 | {
|
240 | return mPDFReader;
|
241 | }
|
242 |
|
243 | METHOD_RETURN_TYPE PDFReaderDriver::ParseNewObject(const ARGS_TYPE& args)
|
244 | {
|
245 | CREATE_ISOLATE_CONTEXT;
|
246 | CREATE_ESCAPABLE_SCOPE;
|
247 |
|
248 | if(args.Length() != 1 ||
|
249 | !args[0]->IsNumber())
|
250 | {
|
251 | THROW_EXCEPTION("Wrong arguments. Provide an Object ID");
|
252 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
253 | }
|
254 |
|
255 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
256 |
|
257 | RefCountPtr<PDFObject> newObject = reader->mPDFReader->ParseNewObject(TO_UINT32(args[0])->Value());
|
258 |
|
259 | if(!newObject)
|
260 | {
|
261 | THROW_EXCEPTION("Unable to read object. Most probably object ID is wrong (or some file read issue...but i'd first check that ID. if i were you)");
|
262 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
263 | }
|
264 |
|
265 | SET_FUNCTION_RETURN_VALUE(reader->holder->GetInstanceFor(newObject.GetPtr()))
|
266 | }
|
267 |
|
268 | METHOD_RETURN_TYPE PDFReaderDriver::GetPageObjectID(const ARGS_TYPE& args)
|
269 | {
|
270 | CREATE_ISOLATE_CONTEXT;
|
271 | CREATE_ESCAPABLE_SCOPE;
|
272 |
|
273 | if(args.Length() != 1 ||
|
274 | !args[0]->IsNumber())
|
275 | {
|
276 | THROW_EXCEPTION("Wrong arguments. Provide a page index");
|
277 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
278 | }
|
279 |
|
280 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
281 |
|
282 | SET_FUNCTION_RETURN_VALUE(NEW_NUMBER(reader->mPDFReader->GetPageObjectID(TO_UINT32(args[0])->Value())))
|
283 | }
|
284 |
|
285 |
|
286 | METHOD_RETURN_TYPE PDFReaderDriver::ParsePageDictionary(const ARGS_TYPE& args)
|
287 | {
|
288 | CREATE_ISOLATE_CONTEXT;
|
289 | CREATE_ESCAPABLE_SCOPE;
|
290 |
|
291 | if(args.Length() != 1 ||
|
292 | !args[0]->IsNumber())
|
293 | {
|
294 | THROW_EXCEPTION("Wrong arguments. Provide a page index");
|
295 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
296 | }
|
297 |
|
298 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
299 |
|
300 | RefCountPtr<PDFDictionary> newObject = reader->mPDFReader->ParsePage(TO_UINT32(args[0])->Value());
|
301 |
|
302 | if(!newObject)
|
303 | {
|
304 | THROW_EXCEPTION("Unable to read page, parhaps page index is wrong");
|
305 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
306 | }
|
307 | else {
|
308 | SET_FUNCTION_RETURN_VALUE(reader->holder->GetInstanceFor(newObject.GetPtr()))
|
309 | }
|
310 | }
|
311 |
|
312 | METHOD_RETURN_TYPE PDFReaderDriver::ParsePage(const ARGS_TYPE& args)
|
313 | {
|
314 | CREATE_ISOLATE_CONTEXT;
|
315 | CREATE_ESCAPABLE_SCOPE;
|
316 |
|
317 | if(args.Length() != 1 ||
|
318 | !args[0]->IsNumber())
|
319 | {
|
320 | THROW_EXCEPTION("Wrong arguments. Provide a page index");
|
321 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
322 | }
|
323 |
|
324 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
325 |
|
326 | RefCountPtr<PDFDictionary> newObject = reader->mPDFReader->ParsePage(TO_UINT32(args[0])->Value());
|
327 |
|
328 | if(!newObject)
|
329 | {
|
330 | THROW_EXCEPTION("Unable to read page, page index is wrong or page is null");
|
331 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
332 | }
|
333 | else {
|
334 | Local<Value> newInstance = reader->holder->GetNewPDFPageInput(args);
|
335 | ObjectWrap::Unwrap<PDFPageInputDriver>(newInstance->TO_OBJECT())->PageInput = new PDFPageInput(reader->mPDFReader,newObject);
|
336 | ObjectWrap::Unwrap<PDFPageInputDriver>(newInstance->TO_OBJECT())->PageInputDictionary = newObject.GetPtr();
|
337 | SET_FUNCTION_RETURN_VALUE(newInstance)
|
338 | }
|
339 | }
|
340 |
|
341 | METHOD_RETURN_TYPE PDFReaderDriver::GetObjectsCount(const ARGS_TYPE& args)
|
342 | {
|
343 | CREATE_ISOLATE_CONTEXT;
|
344 | CREATE_ESCAPABLE_SCOPE;
|
345 |
|
346 |
|
347 | SET_FUNCTION_RETURN_VALUE(NEW_NUMBER(ObjectWrap::Unwrap<PDFReaderDriver>(args.This())->mPDFReader->GetObjectsCount()))
|
348 | }
|
349 |
|
350 | METHOD_RETURN_TYPE PDFReaderDriver::IsEncrypted(const ARGS_TYPE& args)
|
351 | {
|
352 | CREATE_ISOLATE_CONTEXT;
|
353 | CREATE_ESCAPABLE_SCOPE;
|
354 |
|
355 |
|
356 | SET_FUNCTION_RETURN_VALUE(NEW_BOOLEAN(ObjectWrap::Unwrap<PDFReaderDriver>(args.This())->mPDFReader->IsEncrypted()))
|
357 | }
|
358 |
|
359 | METHOD_RETURN_TYPE PDFReaderDriver::GetXrefSize(const ARGS_TYPE& args)
|
360 | {
|
361 | CREATE_ISOLATE_CONTEXT;
|
362 | CREATE_ESCAPABLE_SCOPE;
|
363 |
|
364 |
|
365 | SET_FUNCTION_RETURN_VALUE(NEW_NUMBER(ObjectWrap::Unwrap<PDFReaderDriver>(args.This())->mPDFReader->GetXrefSize()))
|
366 | }
|
367 |
|
368 | METHOD_RETURN_TYPE PDFReaderDriver::GetXrefEntry(const ARGS_TYPE& args)
|
369 | {
|
370 | CREATE_ISOLATE_CONTEXT;
|
371 | CREATE_ESCAPABLE_SCOPE;
|
372 |
|
373 | if(args.Length() != 1 ||
|
374 | !args[0]->IsNumber())
|
375 | {
|
376 | THROW_EXCEPTION("Wrong arguments. Provide an Object ID");
|
377 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
378 | }
|
379 |
|
380 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
381 |
|
382 | XrefEntryInput* xrefEntry = reader->mPDFReader->GetXrefEntry(TO_UINT32(args[0])->Value());
|
383 | if(!xrefEntry)
|
384 | {
|
385 | THROW_EXCEPTION("Unable to read object xref entry, page index is wrong or page is null");
|
386 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
387 | }
|
388 |
|
389 | Local<Object> anObject = NEW_OBJECT;
|
390 |
|
391 | anObject->Set(GET_CURRENT_CONTEXT, NEW_SYMBOL("objectPosition"),NEW_NUMBER(xrefEntry->mObjectPosition));
|
392 | anObject->Set(GET_CURRENT_CONTEXT, NEW_SYMBOL("revision"),NEW_NUMBER(xrefEntry->mRivision));
|
393 | anObject->Set(GET_CURRENT_CONTEXT, NEW_SYMBOL("type"),NEW_NUMBER(xrefEntry->mType));
|
394 |
|
395 | SET_FUNCTION_RETURN_VALUE(anObject)
|
396 | }
|
397 |
|
398 |
|
399 | METHOD_RETURN_TYPE PDFReaderDriver::GetXrefPosition(const ARGS_TYPE& args)
|
400 | {
|
401 | CREATE_ISOLATE_CONTEXT;
|
402 | CREATE_ESCAPABLE_SCOPE;
|
403 |
|
404 |
|
405 | SET_FUNCTION_RETURN_VALUE(NEW_NUMBER(ObjectWrap::Unwrap<PDFReaderDriver>(args.This())->mPDFReader->GetXrefPosition()))
|
406 | }
|
407 |
|
408 | METHOD_RETURN_TYPE PDFReaderDriver::StartReadingFromStream(const ARGS_TYPE& args)
|
409 | {
|
410 | CREATE_ISOLATE_CONTEXT;
|
411 | CREATE_ESCAPABLE_SCOPE;
|
412 |
|
413 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
414 |
|
415 | if(args.Length() != 1 ||
|
416 | !reader->holder->IsPDFStreamInputInstance(args[0]))
|
417 | {
|
418 | THROW_EXCEPTION("Wrong arguments. provide a PDF stream input");
|
419 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
420 | }
|
421 |
|
422 | PDFStreamInputDriver* streamInput = ObjectWrap::Unwrap<PDFStreamInputDriver>(args[0]->TO_OBJECT());
|
423 |
|
424 | IByteReader* byteReader = reader->mPDFReader->StartReadingFromStream(streamInput->TheObject.GetPtr());
|
425 |
|
426 | Local<Value> driver = reader->holder->GetNewByteReader(args);
|
427 | ObjectWrap::Unwrap<ByteReaderDriver>(driver->TO_OBJECT())->SetStream(byteReader,true);
|
428 |
|
429 | SET_FUNCTION_RETURN_VALUE(driver)
|
430 | }
|
431 |
|
432 | METHOD_RETURN_TYPE PDFReaderDriver::StartReadingFromStreamForPlainCopying(const ARGS_TYPE& args) {
|
433 | CREATE_ISOLATE_CONTEXT;
|
434 | CREATE_ESCAPABLE_SCOPE;
|
435 |
|
436 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
437 |
|
438 | if(args.Length() != 1 ||
|
439 | !reader->holder->IsPDFStreamInputInstance(args[0]))
|
440 | {
|
441 | THROW_EXCEPTION("Wrong arguments. provide a PDF stream input");
|
442 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
443 | }
|
444 |
|
445 | PDFStreamInputDriver* streamInput = ObjectWrap::Unwrap<PDFStreamInputDriver>(args[0]->TO_OBJECT());
|
446 |
|
447 | IByteReader* byteReader = reader->mPDFReader->StartReadingFromStreamForPlainCopying(streamInput->TheObject.GetPtr());
|
448 |
|
449 | Local<Value> driver = reader->holder->GetNewByteReader(args);
|
450 | ObjectWrap::Unwrap<ByteReaderDriver>(driver->TO_OBJECT())->SetStream(byteReader,true);
|
451 |
|
452 | SET_FUNCTION_RETURN_VALUE(driver)
|
453 | }
|
454 |
|
455 | METHOD_RETURN_TYPE PDFReaderDriver::StartReadingObjectsFromStream(const ARGS_TYPE& args) {
|
456 | CREATE_ISOLATE_CONTEXT;
|
457 | CREATE_ESCAPABLE_SCOPE;
|
458 |
|
459 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
460 |
|
461 | if(args.Length() != 1 ||
|
462 | !reader->holder->IsPDFStreamInputInstance(args[0]))
|
463 | {
|
464 | THROW_EXCEPTION("Wrong arguments. provide a PDF stream input");
|
465 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
466 | }
|
467 |
|
468 | PDFStreamInputDriver* streamInput = ObjectWrap::Unwrap<PDFStreamInputDriver>(args[0]->TO_OBJECT());
|
469 |
|
470 | PDFObjectParser* objectReader = reader->mPDFReader->StartReadingObjectsFromStream(streamInput->TheObject.GetPtr());
|
471 |
|
472 | Local<Value> driver = reader->holder->GetNewPDFObjectParser(args);
|
473 | ObjectWrap::Unwrap<PDFObjectParserDriver>(driver->TO_OBJECT())->PDFObjectParserInstance= objectReader;
|
474 |
|
475 | SET_FUNCTION_RETURN_VALUE(driver)
|
476 | }
|
477 |
|
478 | METHOD_RETURN_TYPE PDFReaderDriver::StartReadingObjectsFromStreams(const ARGS_TYPE& args) {
|
479 | CREATE_ISOLATE_CONTEXT;
|
480 | CREATE_ESCAPABLE_SCOPE;
|
481 |
|
482 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
483 |
|
484 | if(args.Length() != 1 ||
|
485 | !reader->holder->IsPDFArrayInstance(args[0]))
|
486 | {
|
487 | THROW_EXCEPTION("Wrong arguments. provide a PDF array");
|
488 | SET_FUNCTION_RETURN_VALUE(UNDEFINED)
|
489 | }
|
490 |
|
491 | PDFArrayDriver* arrayInput = ObjectWrap::Unwrap<PDFArrayDriver>(args[0]->TO_OBJECT());
|
492 |
|
493 | PDFObjectParser* objectReader = reader->mPDFReader->StartReadingObjectsFromStreams(arrayInput->TheObject.GetPtr());
|
494 |
|
495 | Local<Value> driver = reader->holder->GetNewPDFObjectParser(args);
|
496 | ObjectWrap::Unwrap<PDFObjectParserDriver>(driver->TO_OBJECT())->PDFObjectParserInstance= objectReader;
|
497 |
|
498 | SET_FUNCTION_RETURN_VALUE(driver)
|
499 | }
|
500 |
|
501 | METHOD_RETURN_TYPE PDFReaderDriver::GetParserStream(const ARGS_TYPE& args)
|
502 | {
|
503 | CREATE_ISOLATE_CONTEXT;
|
504 | CREATE_ESCAPABLE_SCOPE;
|
505 |
|
506 | PDFReaderDriver* reader = ObjectWrap::Unwrap<PDFReaderDriver>(args.This());
|
507 |
|
508 | Local<Value> driver = reader->holder->GetNewByteReaderWithPosition(args);
|
509 | ObjectWrap::Unwrap<ByteReaderWithPositionDriver>(driver->TO_OBJECT())->SetStream(reader->mPDFReader->GetParserStream(),false);
|
510 |
|
511 | SET_FUNCTION_RETURN_VALUE(driver)
|
512 | }
|
513 |
|