1 /* PDFObject interface */
2
3 JNIEXPORT void JNICALL
FUN(PDFObject_finalize)4 FUN(PDFObject_finalize)(JNIEnv *env, jobject self)
5 {
6 fz_context *ctx = get_context(env);
7 pdf_obj *obj = from_PDFObject_safe(env, self);
8 if (!ctx || !obj) return;
9 (*env)->SetLongField(env, self, fid_PDFObject_pointer, 0);
10 pdf_drop_obj(ctx, obj);
11 }
12
13 JNIEXPORT jint JNICALL
FUN(PDFObject_toIndirect)14 FUN(PDFObject_toIndirect)(JNIEnv *env, jobject self)
15 {
16 fz_context *ctx = get_context(env);
17 pdf_obj *obj = from_PDFObject(env, self);
18 int num = 0;
19
20 if (!ctx || !obj) return 0;
21
22 fz_try(ctx)
23 num = pdf_to_num(ctx, obj);
24 fz_catch(ctx)
25 jni_rethrow(env, ctx);
26
27 return num;
28 }
29
30 JNIEXPORT jboolean JNICALL
FUN(PDFObject_isIndirect)31 FUN(PDFObject_isIndirect)(JNIEnv *env, jobject self)
32 {
33 fz_context *ctx = get_context(env);
34 pdf_obj *obj = from_PDFObject(env, self);
35 int b = 0;
36
37 if (!ctx || !obj) return JNI_FALSE;
38
39 fz_try(ctx)
40 b = pdf_is_indirect(ctx, obj);
41 fz_catch(ctx)
42 jni_rethrow(env, ctx);
43
44 return b ? JNI_TRUE : JNI_FALSE;
45 }
46
47 JNIEXPORT jboolean JNICALL
FUN(PDFObject_isNull)48 FUN(PDFObject_isNull)(JNIEnv *env, jobject self)
49 {
50 fz_context *ctx = get_context(env);
51 pdf_obj *obj = from_PDFObject(env, self);
52 int b = 0;
53
54 if (!ctx || !obj) return JNI_FALSE;
55
56 fz_try(ctx)
57 b = pdf_is_null(ctx, obj);
58 fz_catch(ctx)
59 jni_rethrow(env, ctx);
60
61 return b ? JNI_TRUE : JNI_FALSE;
62 }
63
64 JNIEXPORT jboolean JNICALL
FUN(PDFObject_isBoolean)65 FUN(PDFObject_isBoolean)(JNIEnv *env, jobject self)
66 {
67 fz_context *ctx = get_context(env);
68 pdf_obj *obj = from_PDFObject(env, self);
69 int b = 0;
70
71 if (!ctx || !obj) return JNI_FALSE;
72
73 fz_try(ctx)
74 b = pdf_is_bool(ctx, obj);
75 fz_catch(ctx)
76 jni_rethrow(env, ctx);
77
78 return b ? JNI_TRUE : JNI_FALSE;
79 }
80
81 JNIEXPORT jboolean JNICALL
FUN(PDFObject_isInteger)82 FUN(PDFObject_isInteger)(JNIEnv *env, jobject self)
83 {
84 fz_context *ctx = get_context(env);
85 pdf_obj *obj = from_PDFObject(env, self);
86 int b = 0;
87
88 if (!ctx || !obj) return JNI_FALSE;
89
90 fz_try(ctx)
91 b = pdf_is_int(ctx, obj);
92 fz_catch(ctx)
93 jni_rethrow(env, ctx);
94
95 return b ? JNI_TRUE : JNI_FALSE;
96 }
97
98 JNIEXPORT jboolean JNICALL
FUN(PDFObject_isReal)99 FUN(PDFObject_isReal)(JNIEnv *env, jobject self)
100 {
101 fz_context *ctx = get_context(env);
102 pdf_obj *obj = from_PDFObject(env, self);
103 int b = 0;
104
105 if (!ctx || !obj) return JNI_FALSE;
106
107 fz_try(ctx)
108 b = pdf_is_real(ctx, obj);
109 fz_catch(ctx)
110 jni_rethrow(env, ctx);
111
112 return b ? JNI_TRUE : JNI_FALSE;
113 }
114
115 JNIEXPORT jboolean JNICALL
FUN(PDFObject_isNumber)116 FUN(PDFObject_isNumber)(JNIEnv *env, jobject self)
117 {
118 fz_context *ctx = get_context(env);
119 pdf_obj *obj = from_PDFObject(env, self);
120 int b = 0;
121
122 if (!ctx || !obj) return JNI_FALSE;
123
124 fz_try(ctx)
125 b = pdf_is_number(ctx, obj);
126 fz_catch(ctx)
127 jni_rethrow(env, ctx);
128
129 return b ? JNI_TRUE : JNI_FALSE;
130 }
131
132 JNIEXPORT jboolean JNICALL
FUN(PDFObject_isString)133 FUN(PDFObject_isString)(JNIEnv *env, jobject self)
134 {
135 fz_context *ctx = get_context(env);
136 pdf_obj *obj = from_PDFObject(env, self);
137 int b = 0;
138
139 if (!ctx || !obj) return JNI_FALSE;
140
141 fz_try(ctx)
142 b = pdf_is_string(ctx, obj);
143 fz_catch(ctx)
144 jni_rethrow(env, ctx);
145
146 return b ? JNI_TRUE : JNI_FALSE;
147 }
148
149 JNIEXPORT jboolean JNICALL
FUN(PDFObject_isName)150 FUN(PDFObject_isName)(JNIEnv *env, jobject self)
151 {
152 fz_context *ctx = get_context(env);
153 pdf_obj *obj = from_PDFObject(env, self);
154 int b = 0;
155
156 if (!ctx || !obj) return JNI_FALSE;
157
158 fz_try(ctx)
159 b = pdf_is_name(ctx, obj);
160 fz_catch(ctx)
161 jni_rethrow(env, ctx);
162
163 return b ? JNI_TRUE : JNI_FALSE;
164 }
165
166 JNIEXPORT jboolean JNICALL
FUN(PDFObject_isArray)167 FUN(PDFObject_isArray)(JNIEnv *env, jobject self)
168 {
169 fz_context *ctx = get_context(env);
170 pdf_obj *obj = from_PDFObject(env, self);
171 int b = 0;
172
173 if (!ctx || !obj) return JNI_FALSE;
174
175 fz_try(ctx)
176 b = pdf_is_array(ctx, obj);
177 fz_catch(ctx)
178 jni_rethrow(env, ctx);
179
180 return b ? JNI_TRUE : JNI_FALSE;
181 }
182
183 JNIEXPORT jboolean JNICALL
FUN(PDFObject_isDictionary)184 FUN(PDFObject_isDictionary)(JNIEnv *env, jobject self)
185 {
186 fz_context *ctx = get_context(env);
187 pdf_obj *obj = from_PDFObject(env, self);
188 int b = 0;
189
190 if (!ctx || !obj) return JNI_FALSE;
191
192 fz_try(ctx)
193 b = pdf_is_dict(ctx, obj);
194 fz_catch(ctx)
195 jni_rethrow(env, ctx);
196
197 return b ? JNI_TRUE : JNI_FALSE;
198 }
199
200 JNIEXPORT jboolean JNICALL
FUN(PDFObject_isStream)201 FUN(PDFObject_isStream)(JNIEnv *env, jobject self)
202 {
203 fz_context *ctx = get_context(env);
204 pdf_obj *obj = from_PDFObject(env, self);
205 int b = 0;
206
207 if (!ctx || !obj) return JNI_FALSE;
208
209 fz_try(ctx)
210 b = pdf_is_stream(ctx, obj);
211 fz_catch(ctx)
212 jni_rethrow(env, ctx);
213
214 return b ? JNI_TRUE : JNI_FALSE;
215 }
216
217 JNIEXPORT jbyteArray JNICALL
FUN(PDFObject_readStream)218 FUN(PDFObject_readStream)(JNIEnv *env, jobject self)
219 {
220 fz_context *ctx = get_context(env);
221 pdf_obj *obj = from_PDFObject(env, self);
222 fz_buffer *buf = NULL;
223 jbyteArray arr = NULL;
224
225 if (!ctx || !obj) return NULL;
226
227 fz_var(buf);
228 fz_try(ctx)
229 {
230 unsigned char *data;
231 size_t len;
232
233 buf = pdf_load_stream(ctx, obj);
234 len = fz_buffer_storage(ctx, buf, &data);
235
236 arr = (*env)->NewByteArray(env, (jsize)len);
237 if ((*env)->ExceptionCheck(env))
238 fz_throw_java(ctx, env);
239 if (!arr)
240 fz_throw(ctx, FZ_ERROR_GENERIC, "can not create byte array");
241
242 (*env)->SetByteArrayRegion(env, arr, 0, (jsize)len, (signed char *) data);
243 if ((*env)->ExceptionCheck(env))
244 fz_throw_java(ctx, env);
245 }
246 fz_always(ctx)
247 fz_drop_buffer(ctx, buf);
248 fz_catch(ctx)
249 jni_rethrow(env, ctx);
250
251 return arr;
252 }
253
254 JNIEXPORT jbyteArray JNICALL
FUN(PDFObject_readRawStream)255 FUN(PDFObject_readRawStream)(JNIEnv *env, jobject self)
256 {
257 fz_context *ctx = get_context(env);
258 pdf_obj *obj = from_PDFObject(env, self);
259 fz_buffer *buf = NULL;
260 jbyteArray arr = NULL;
261
262 if (!ctx || !obj) return NULL;
263
264 fz_var(buf);
265 fz_try(ctx)
266 {
267 unsigned char *data;
268 size_t len;
269
270 buf = pdf_load_raw_stream(ctx, obj);
271 len = fz_buffer_storage(ctx, buf, &data);
272
273 arr = (*env)->NewByteArray(env, (jsize)len);
274 if ((*env)->ExceptionCheck(env))
275 fz_throw_java(ctx, env);
276 if (!arr)
277 fz_throw(ctx, FZ_ERROR_GENERIC, "cannot create byte array");
278
279 (*env)->SetByteArrayRegion(env, arr, 0, (jsize)len, (signed char *) &data[0]);
280 if ((*env)->ExceptionCheck(env))
281 fz_throw_java(ctx, env);
282 }
283 fz_always(ctx)
284 fz_drop_buffer(ctx, buf);
285 fz_catch(ctx)
286 jni_rethrow(env, ctx);
287
288 return arr;
289 }
290
291 JNIEXPORT void JNICALL
FUN(PDFObject_writeObject)292 FUN(PDFObject_writeObject)(JNIEnv *env, jobject self, jobject jobj)
293 {
294 fz_context *ctx = get_context(env);
295 pdf_obj *ref = from_PDFObject(env, self);
296 pdf_document *pdf = pdf_get_bound_document(ctx, ref);
297 pdf_obj *obj = from_PDFObject(env, jobj);
298
299 if (!ctx || !obj) return;
300 if (!pdf) jni_throw_arg_void(env, "object not bound to document");
301 if (!obj) jni_throw_arg_void(env, "object must not be null");
302
303 fz_try(ctx)
304 pdf_update_object(ctx, pdf, pdf_to_num(ctx, ref), obj);
305 fz_catch(ctx)
306 jni_rethrow_void(env, ctx);
307 }
308
309 JNIEXPORT void JNICALL
FUN(PDFObject_writeStreamBuffer)310 FUN(PDFObject_writeStreamBuffer)(JNIEnv *env, jobject self, jobject jbuf)
311 {
312 fz_context *ctx = get_context(env);
313 pdf_obj *obj = from_PDFObject(env, self);
314 pdf_document *pdf = pdf_get_bound_document(ctx, obj);
315 fz_buffer *buf = from_Buffer(env, jbuf);
316
317 if (!ctx || !obj) return;
318 if (!pdf) jni_throw_arg_void(env, "object not bound to document");
319 if (!buf) jni_throw_arg_void(env, "buffer must not be null");
320
321 fz_try(ctx)
322 pdf_update_stream(ctx, pdf, obj, buf, 0);
323 fz_catch(ctx)
324 jni_rethrow_void(env, ctx);
325 }
326
327 JNIEXPORT void JNICALL
FUN(PDFObject_writeStreamString)328 FUN(PDFObject_writeStreamString)(JNIEnv *env, jobject self, jstring jstr)
329 {
330 fz_context *ctx = get_context(env);
331 pdf_obj *obj = from_PDFObject(env, self);
332 pdf_document *pdf = pdf_get_bound_document(ctx, obj);
333 const char *str = NULL;
334 fz_buffer *buf = NULL;
335
336 if (!ctx || !obj) return;
337 if (!pdf) jni_throw_arg_void(env, "object not bound to document");
338 if (!jstr) jni_throw_arg_void(env, "string must not be null");
339
340 str = (*env)->GetStringUTFChars(env, jstr, NULL);
341 if (!str) return;
342
343 fz_var(buf);
344
345 fz_try(ctx)
346 {
347 buf = fz_new_buffer_from_copied_data(ctx, (const unsigned char *)str, strlen(str));
348 pdf_update_stream(ctx, pdf, obj, buf, 0);
349 }
350 fz_always(ctx)
351 {
352 fz_drop_buffer(ctx, buf);
353 (*env)->ReleaseStringUTFChars(env, jstr, str);
354 }
355 fz_catch(ctx)
356 jni_rethrow_void(env, ctx);
357 }
358
359 JNIEXPORT void JNICALL
FUN(PDFObject_writeRawStreamBuffer)360 FUN(PDFObject_writeRawStreamBuffer)(JNIEnv *env, jobject self, jobject jbuf)
361 {
362 fz_context *ctx = get_context(env);
363 pdf_obj *obj = from_PDFObject(env, self);
364 pdf_document *pdf = pdf_get_bound_document(ctx, obj);
365 fz_buffer *buf = from_Buffer(env, jbuf);
366
367 if (!ctx || !obj) return;
368 if (!pdf) jni_throw_arg_void(env, "object not bound to document");
369 if (!buf) jni_throw_arg_void(env, "buffer must not be null");
370
371 fz_try(ctx)
372 pdf_update_stream(ctx, pdf, obj, buf, 1);
373 fz_catch(ctx)
374 jni_rethrow_void(env, ctx);
375 }
376
377 JNIEXPORT void JNICALL
FUN(PDFObject_writeRawStreamString)378 FUN(PDFObject_writeRawStreamString)(JNIEnv *env, jobject self, jstring jstr)
379 {
380 fz_context *ctx = get_context(env);
381 pdf_obj *obj = from_PDFObject(env, self);
382 pdf_document *pdf = pdf_get_bound_document(ctx, obj);
383 const char *str = NULL;
384 fz_buffer *buf = NULL;
385
386 if (!ctx || !obj) return;
387 if (!pdf) jni_throw_arg_void(env, "object not bound to document");
388 if (!jstr) jni_throw_arg_void(env, "string must not be null");
389
390 str = (*env)->GetStringUTFChars(env, jstr, NULL);
391 if (!str) return;
392
393 fz_var(buf);
394
395 fz_try(ctx)
396 {
397 buf = fz_new_buffer_from_copied_data(ctx, (const unsigned char *)str, strlen(str));
398 pdf_update_stream(ctx, pdf, obj, buf, 1);
399 }
400 fz_always(ctx)
401 {
402 fz_drop_buffer(ctx, buf);
403 (*env)->ReleaseStringUTFChars(env, jstr, str);
404 }
405 fz_catch(ctx)
406 jni_rethrow_void(env, ctx);
407 }
408
409 JNIEXPORT jobject JNICALL
FUN(PDFObject_resolve)410 FUN(PDFObject_resolve)(JNIEnv *env, jobject self)
411 {
412 fz_context *ctx = get_context(env);
413 pdf_obj *obj = from_PDFObject(env, self);
414 pdf_obj *ind = NULL;
415 jobject jobj;
416
417 if (!ctx || !obj) return NULL;
418
419 fz_try(ctx)
420 ind = pdf_resolve_indirect(ctx, obj);
421 fz_catch(ctx)
422 jni_rethrow(env, ctx);
423
424 pdf_keep_obj(ctx, ind);
425 jobj = (*env)->NewObject(env, cls_PDFObject, mid_PDFObject_init, jlong_cast(ind), self);
426 if (!jobj)
427 pdf_drop_obj(ctx, ind);
428 return jobj;
429 }
430
431 JNIEXPORT jobject JNICALL
FUN(PDFObject_getArray)432 FUN(PDFObject_getArray)(JNIEnv *env, jobject self, jint index)
433 {
434 fz_context *ctx = get_context(env);
435 pdf_obj *arr = from_PDFObject(env, self);
436 pdf_obj *val = NULL;
437
438 if (!ctx || !arr) return NULL;
439
440 fz_try(ctx)
441 val = pdf_array_get(ctx, arr, index);
442 fz_catch(ctx)
443 jni_rethrow(env, ctx);
444
445 return to_PDFObject_safe(ctx, env, self, val);
446 }
447
448 JNIEXPORT jobject JNICALL
FUN(PDFObject_getDictionary)449 FUN(PDFObject_getDictionary)(JNIEnv *env, jobject self, jstring jname)
450 {
451 fz_context *ctx = get_context(env);
452 pdf_obj *dict = from_PDFObject(env, self);
453 const char *name = NULL;
454 pdf_obj *val = NULL;
455
456 if (!ctx || !dict) return NULL;
457 if (!jname) jni_throw_arg(env, "name must not be null");
458
459 name = (*env)->GetStringUTFChars(env, jname, NULL);
460 if (!name) jni_throw_run(env, "cannot get name to lookup");
461
462 fz_try(ctx)
463 val = pdf_dict_gets(ctx, dict, name);
464 fz_always(ctx)
465 (*env)->ReleaseStringUTFChars(env, jname, name);
466 fz_catch(ctx)
467 jni_rethrow(env, ctx);
468
469 return to_PDFObject_safe(ctx, env, self, val);
470 }
471
472 JNIEXPORT jobject JNICALL
FUN(PDFObject_getDictionaryKey)473 FUN(PDFObject_getDictionaryKey)(JNIEnv *env, jobject self, jint index)
474 {
475 fz_context *ctx = get_context(env);
476 pdf_obj *dict = from_PDFObject(env, self);
477 pdf_obj *key = NULL;
478
479 if (!ctx || !dict) return NULL;
480
481 fz_try(ctx)
482 key = pdf_dict_get_key(ctx, dict, index);
483 fz_catch(ctx)
484 jni_rethrow(env, ctx);
485
486 return to_PDFObject_safe(ctx, env, self, key);
487 }
488
489 JNIEXPORT void JNICALL
FUN(PDFObject_putArrayBoolean)490 FUN(PDFObject_putArrayBoolean)(JNIEnv *env, jobject self, jint index, jboolean b)
491 {
492 fz_context *ctx = get_context(env);
493 pdf_obj *arr = from_PDFObject(env, self);
494
495 if (!ctx || !arr) return;
496
497 fz_try(ctx)
498 pdf_array_put(ctx, arr, index, b ? PDF_TRUE : PDF_FALSE);
499 fz_catch(ctx)
500 jni_rethrow_void(env, ctx);
501 }
502
503 JNIEXPORT void JNICALL
FUN(PDFObject_putArrayInteger)504 FUN(PDFObject_putArrayInteger)(JNIEnv *env, jobject self, jint index, jint i)
505 {
506 fz_context *ctx = get_context(env);
507 pdf_obj *arr = from_PDFObject(env, self);
508
509 if (!ctx || !arr) return;
510
511 fz_try(ctx)
512 pdf_array_put_drop(ctx, arr, index, pdf_new_int(ctx, i));
513 fz_catch(ctx)
514 jni_rethrow_void(env, ctx);
515 }
516
517 JNIEXPORT void JNICALL
FUN(PDFObject_putArrayFloat)518 FUN(PDFObject_putArrayFloat)(JNIEnv *env, jobject self, jint index, jfloat f)
519 {
520 fz_context *ctx = get_context(env);
521 pdf_obj *arr = from_PDFObject(env, self);
522
523 if (!ctx || !arr) return;
524
525 fz_try(ctx)
526 pdf_array_put_drop(ctx, arr, index, pdf_new_real(ctx, f));
527 fz_catch(ctx)
528 jni_rethrow_void(env, ctx);
529 }
530
531 JNIEXPORT void JNICALL
FUN(PDFObject_putArrayString)532 FUN(PDFObject_putArrayString)(JNIEnv *env, jobject self, jint index, jstring jstr)
533 {
534 fz_context *ctx = get_context(env);
535 pdf_obj *arr = from_PDFObject(env, self);
536 const char *str = NULL;
537
538 if (!ctx || !arr) return;
539 if (jstr)
540 {
541 str = (*env)->GetStringUTFChars(env, jstr, NULL);
542 if (!str) return;
543 }
544
545 fz_try(ctx)
546 {
547 if (str)
548 pdf_array_put_drop(ctx, arr, index, pdf_new_string(ctx, str, strlen(str)));
549 else
550 pdf_array_put(ctx, arr, index, PDF_NULL);
551 }
552 fz_always(ctx)
553 {
554 if (str)
555 (*env)->ReleaseStringUTFChars(env, jstr, str);
556 }
557 fz_catch(ctx)
558 jni_rethrow_void(env, ctx);
559 }
560
561 JNIEXPORT void JNICALL
FUN(PDFObject_putArrayPDFObject)562 FUN(PDFObject_putArrayPDFObject)(JNIEnv *env, jobject self, jint index, jobject jobj)
563 {
564 fz_context *ctx = get_context(env);
565 pdf_obj *arr = from_PDFObject(env, self);
566 pdf_obj *obj = from_PDFObject(env, jobj);
567
568 if (!ctx || !arr) return;
569
570 fz_try(ctx)
571 pdf_array_put(ctx, arr, index, obj);
572 fz_catch(ctx)
573 jni_rethrow_void(env, ctx);
574 }
575
576 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryStringBoolean)577 FUN(PDFObject_putDictionaryStringBoolean)(JNIEnv *env, jobject self, jstring jname, jboolean b)
578 {
579 fz_context *ctx = get_context(env);
580 pdf_obj *dict = from_PDFObject(env, self);
581 const char *name = NULL;
582 pdf_obj *key = NULL;
583
584 if (!ctx || !dict) return;
585 if (jname)
586 {
587 name = (*env)->GetStringUTFChars(env, jname, NULL);
588 if (!name) return;
589 }
590
591 fz_var(key);
592
593 fz_try(ctx)
594 {
595 key = name ? pdf_new_name(ctx, name) : NULL;
596 pdf_dict_put(ctx, dict, key, b ? PDF_TRUE : PDF_FALSE);
597 }
598 fz_always(ctx)
599 {
600 pdf_drop_obj(ctx, key);
601 if (name)
602 (*env)->ReleaseStringUTFChars(env, jname, name);
603 }
604 fz_catch(ctx)
605 jni_rethrow_void(env, ctx);
606 }
607
608 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryStringInteger)609 FUN(PDFObject_putDictionaryStringInteger)(JNIEnv *env, jobject self, jstring jname, jint i)
610 {
611 fz_context *ctx = get_context(env);
612 pdf_obj *dict = from_PDFObject(env, self);
613 const char *name = NULL;
614 pdf_obj *key = NULL;
615
616 if (!ctx || !dict) return;
617 if (jname)
618 {
619 name = (*env)->GetStringUTFChars(env, jname, NULL);
620 if (!name) return;
621 }
622
623 fz_var(key);
624
625 fz_try(ctx)
626 {
627 key = name ? pdf_new_name(ctx, name) : NULL;
628 pdf_dict_put_int(ctx, dict, key, i);
629 }
630 fz_always(ctx)
631 {
632 pdf_drop_obj(ctx, key);
633 if (name)
634 (*env)->ReleaseStringUTFChars(env, jname, name);
635 }
636 fz_catch(ctx)
637 jni_rethrow_void(env, ctx);
638 }
639
640 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryStringFloat)641 FUN(PDFObject_putDictionaryStringFloat)(JNIEnv *env, jobject self, jstring jname, jfloat f)
642 {
643 fz_context *ctx = get_context(env);
644 pdf_obj *dict = from_PDFObject(env, self);
645 const char *name = NULL;
646 pdf_obj *key = NULL;
647
648 if (!ctx || !dict) return;
649 if (jname)
650 {
651 name = (*env)->GetStringUTFChars(env, jname, NULL);
652 if (!name) return;
653 }
654
655 fz_var(key);
656
657 fz_try(ctx)
658 {
659 key = name ? pdf_new_name(ctx, name) : NULL;
660 pdf_dict_put_real(ctx, dict, key, f);
661 }
662 fz_always(ctx)
663 {
664 pdf_drop_obj(ctx, key);
665 if (name)
666 (*env)->ReleaseStringUTFChars(env, jname, name);
667 }
668 fz_catch(ctx)
669 jni_rethrow_void(env, ctx);
670 }
671
672 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryStringString)673 FUN(PDFObject_putDictionaryStringString)(JNIEnv *env, jobject self, jstring jname, jstring jstr)
674 {
675 fz_context *ctx = get_context(env);
676 pdf_obj *dict = from_PDFObject(env, self);
677 const char *name = NULL;
678 const char *str = NULL;
679 pdf_obj *key = NULL;
680
681 if (!ctx || !dict) return;
682 if (jname)
683 {
684 name = (*env)->GetStringUTFChars(env, jname, NULL);
685 if (!name) return;
686 }
687 if (jstr)
688 {
689 str = (*env)->GetStringUTFChars(env, jstr, NULL);
690 if (!str)
691 {
692 (*env)->ReleaseStringUTFChars(env, jname, str);
693 return;
694 }
695 }
696
697 fz_var(key);
698
699 fz_try(ctx)
700 {
701 key = name ? pdf_new_name(ctx, name) : NULL;
702 if (str)
703 pdf_dict_put_string(ctx, dict, key, str, strlen(str));
704 else
705 pdf_dict_put(ctx, dict, key, PDF_NULL);
706 }
707 fz_always(ctx)
708 {
709 pdf_drop_obj(ctx, key);
710 if (str)
711 (*env)->ReleaseStringUTFChars(env, jstr, str);
712 if (name)
713 (*env)->ReleaseStringUTFChars(env, jname, name);
714 }
715 fz_catch(ctx)
716 jni_rethrow_void(env, ctx);
717 }
718
719 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryStringPDFObject)720 FUN(PDFObject_putDictionaryStringPDFObject)(JNIEnv *env, jobject self, jstring jname, jobject jobj)
721 {
722 fz_context *ctx = get_context(env);
723 pdf_obj *dict = from_PDFObject(env, self);
724 pdf_obj *val = from_PDFObject(env, jobj);
725 const char *name = NULL;
726 pdf_obj *key = NULL;
727
728 if (!ctx || !dict) return;
729 if (jname)
730 {
731 name = (*env)->GetStringUTFChars(env, jname, NULL);
732 if (!name) return;
733 }
734
735 fz_var(key);
736
737 fz_try(ctx)
738 {
739 key = name ? pdf_new_name(ctx, name) : NULL;
740 pdf_dict_put(ctx, dict, key, val);
741 }
742 fz_always(ctx)
743 {
744 pdf_drop_obj(ctx, key);
745 if (name)
746 (*env)->ReleaseStringUTFChars(env, jname, name);
747 }
748 fz_catch(ctx)
749 jni_rethrow_void(env, ctx);
750 }
751
752 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryPDFObjectBoolean)753 FUN(PDFObject_putDictionaryPDFObjectBoolean)(JNIEnv *env, jobject self, jobject jname, jboolean b)
754 {
755 fz_context *ctx = get_context(env);
756 pdf_obj *dict = from_PDFObject(env, self);
757 pdf_obj *name = from_PDFObject(env, jname);
758
759 if (!ctx || !dict) return;
760
761 fz_try(ctx)
762 pdf_dict_put(ctx, dict, name, b ? PDF_TRUE : PDF_FALSE);
763 fz_catch(ctx)
764 jni_rethrow_void(env, ctx);
765 }
766
767 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryPDFObjectInteger)768 FUN(PDFObject_putDictionaryPDFObjectInteger)(JNIEnv *env, jobject self, jobject jname, jint i)
769 {
770 fz_context *ctx = get_context(env);
771 pdf_obj *dict = from_PDFObject(env, self);
772 pdf_obj *name = from_PDFObject(env, jname);
773
774 if (!ctx || !dict) return;
775
776 fz_try(ctx)
777 pdf_dict_put_int(ctx, dict, name, i);
778 fz_catch(ctx)
779 jni_rethrow_void(env, ctx);
780 }
781
782 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryPDFObjectFloat)783 FUN(PDFObject_putDictionaryPDFObjectFloat)(JNIEnv *env, jobject self, jobject jname, jfloat f)
784 {
785 fz_context *ctx = get_context(env);
786 pdf_obj *dict = from_PDFObject(env, self);
787 pdf_obj *name = from_PDFObject(env, jname);
788
789 if (!ctx || !dict) return;
790
791 fz_try(ctx)
792 pdf_dict_put_real(ctx, dict, name, f);
793 fz_catch(ctx)
794 jni_rethrow_void(env, ctx);
795 }
796
797 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryPDFObjectString)798 FUN(PDFObject_putDictionaryPDFObjectString)(JNIEnv *env, jobject self, jobject jname, jstring jstr)
799 {
800 fz_context *ctx = get_context(env);
801 pdf_obj *dict = from_PDFObject(env, self);
802 pdf_obj *name = from_PDFObject(env, jname);
803 const char *str = NULL;
804
805 if (!ctx || !dict) return;
806 if (jstr)
807 {
808 str = (*env)->GetStringUTFChars(env, jstr, NULL);
809 if (!str) return;
810 }
811
812 fz_try(ctx)
813 {
814 if (str)
815 pdf_dict_put_string(ctx, dict, name, str, strlen(str));
816 else
817 pdf_dict_put(ctx, dict, name, PDF_NULL);
818 }
819 fz_always(ctx)
820 {
821 if (str)
822 (*env)->ReleaseStringUTFChars(env, jstr, str);
823 }
824 fz_catch(ctx)
825 jni_rethrow_void(env, ctx);
826 }
827
828 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryPDFObjectPDFObject)829 FUN(PDFObject_putDictionaryPDFObjectPDFObject)(JNIEnv *env, jobject self, jobject jname, jobject jobj)
830 {
831 fz_context *ctx = get_context(env);
832 pdf_obj *dict = from_PDFObject(env, self);
833 pdf_obj *name = from_PDFObject(env, jname);
834 pdf_obj *obj = from_PDFObject(env, jobj);
835
836 if (!ctx || !dict) return;
837
838 fz_try(ctx)
839 pdf_dict_put(ctx, dict, name, obj);
840 fz_catch(ctx)
841 jni_rethrow_void(env, ctx);
842 }
843
844 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryPDFObjectRect)845 FUN(PDFObject_putDictionaryPDFObjectRect)(JNIEnv *env, jobject self, jobject jname, jobject jrect)
846 {
847 fz_context *ctx = get_context(env);
848 pdf_obj *dict = from_PDFObject(env, self);
849 pdf_obj *name = from_PDFObject(env, jname);
850 fz_rect rect = from_Rect(env, jrect);
851
852 if (!ctx || !dict) return;
853
854 fz_try(ctx)
855 pdf_dict_put_rect(ctx, dict, name, rect);
856 fz_catch(ctx)
857 jni_rethrow_void(env, ctx);
858 }
859
860 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryPDFObjectMatrix)861 FUN(PDFObject_putDictionaryPDFObjectMatrix)(JNIEnv *env, jobject self, jobject jname, jobject jmatrix)
862 {
863 fz_context *ctx = get_context(env);
864 pdf_obj *dict = from_PDFObject(env, self);
865 pdf_obj *name = from_PDFObject(env, jname);
866 fz_matrix matrix = from_Matrix(env, jmatrix);
867
868 if (!ctx || !dict) return;
869
870 fz_try(ctx)
871 pdf_dict_put_matrix(ctx, dict, name, matrix);
872 fz_catch(ctx)
873 jni_rethrow_void(env, ctx);
874 }
875
876 JNIEXPORT void JNICALL
FUN(PDFObject_putDictionaryPDFObjectDate)877 FUN(PDFObject_putDictionaryPDFObjectDate)(JNIEnv *env, jobject self, jobject jname, jlong secs)
878 {
879 fz_context *ctx = get_context(env);
880 pdf_obj *dict = from_PDFObject(env, self);
881 pdf_obj *name = from_PDFObject(env, jname);
882
883 if (!ctx || !dict) return;
884
885 fz_try(ctx)
886 pdf_dict_put_date(ctx, dict, name, secs);
887 fz_catch(ctx)
888 jni_rethrow_void(env, ctx);
889 }
890
891 JNIEXPORT void JNICALL
FUN(PDFObject_deleteArray)892 FUN(PDFObject_deleteArray)(JNIEnv *env, jobject self, jint index)
893 {
894 fz_context *ctx = get_context(env);
895 pdf_obj *arr = from_PDFObject(env, self);
896
897 if (!ctx || !arr) return;
898
899 fz_try(ctx)
900 pdf_array_delete(ctx, arr, index);
901 fz_catch(ctx)
902 jni_rethrow_void(env, ctx);
903 }
904
905 JNIEXPORT void JNICALL
FUN(PDFObject_deleteDictionaryString)906 FUN(PDFObject_deleteDictionaryString)(JNIEnv *env, jobject self, jstring jname)
907 {
908 fz_context *ctx = get_context(env);
909 pdf_obj *dict = from_PDFObject(env, self);
910 const char *name = NULL;
911
912 if (!ctx || !dict) return;
913 if (jname)
914 {
915 name = (*env)->GetStringUTFChars(env, jname, NULL);
916 if (!name) return;
917 }
918
919 fz_try(ctx)
920 {
921 pdf_dict_dels(ctx, dict, name);
922 }
923 fz_always(ctx)
924 {
925 if (name)
926 (*env)->ReleaseStringUTFChars(env, jname, name);
927 }
928 fz_catch(ctx)
929 jni_rethrow_void(env, ctx);
930 }
931
932 JNIEXPORT void JNICALL
FUN(PDFObject_deleteDictionaryPDFObject)933 FUN(PDFObject_deleteDictionaryPDFObject)(JNIEnv *env, jobject self, jobject jname)
934 {
935 fz_context *ctx = get_context(env);
936 pdf_obj *dict = from_PDFObject(env, self);
937 pdf_obj *name = from_PDFObject(env, jname);
938
939 if (!ctx || !dict) return;
940
941 fz_try(ctx)
942 pdf_dict_del(ctx, dict, name);
943 fz_catch(ctx)
944 jni_rethrow_void(env, ctx);
945 }
946
947 JNIEXPORT jboolean JNICALL
FUN(PDFObject_asBoolean)948 FUN(PDFObject_asBoolean)(JNIEnv *env, jobject self)
949 {
950 fz_context *ctx = get_context(env);
951 pdf_obj *obj = from_PDFObject(env, self);
952 int b = 0;
953
954 if (!ctx || !obj) return JNI_FALSE;
955
956 fz_try(ctx)
957 b = pdf_to_bool(ctx, obj);
958 fz_catch(ctx)
959 jni_rethrow(env, ctx);
960
961 return b ? JNI_TRUE : JNI_FALSE;
962 }
963
964 JNIEXPORT jint JNICALL
FUN(PDFObject_asInteger)965 FUN(PDFObject_asInteger)(JNIEnv *env, jobject self)
966 {
967 fz_context *ctx = get_context(env);
968 pdf_obj *obj = from_PDFObject(env, self);
969 int i = 0;
970
971 if (!ctx || !obj) return 0;
972
973 fz_try(ctx)
974 i = pdf_to_int(ctx, obj);
975 fz_catch(ctx)
976 jni_rethrow(env, ctx);
977
978 return i;
979 }
980
981 JNIEXPORT jfloat JNICALL
FUN(PDFObject_asFloat)982 FUN(PDFObject_asFloat)(JNIEnv *env, jobject self)
983 {
984 fz_context *ctx = get_context(env);
985 pdf_obj *obj = from_PDFObject(env, self);
986 float f = 0;
987
988 if (!ctx || !obj) return 0;
989
990 fz_try(ctx)
991 f = pdf_to_real(ctx, obj);
992 fz_catch(ctx)
993 jni_rethrow(env, ctx);
994
995 return f;
996 }
997
998 JNIEXPORT jint JNICALL
FUN(PDFObject_asIndirect)999 FUN(PDFObject_asIndirect)(JNIEnv *env, jobject self)
1000 {
1001 fz_context *ctx = get_context(env);
1002 pdf_obj *obj = from_PDFObject(env, self);
1003 int ind = 0;
1004
1005 if (!ctx || !obj) return 0;
1006
1007 fz_try(ctx)
1008 ind = pdf_to_num(ctx, obj);
1009 fz_catch(ctx)
1010 jni_rethrow(env, ctx);
1011
1012 return ind;
1013 }
1014
1015 JNIEXPORT jstring JNICALL
FUN(PDFObject_asString)1016 FUN(PDFObject_asString)(JNIEnv *env, jobject self)
1017 {
1018 fz_context *ctx = get_context(env);
1019 pdf_obj *obj = from_PDFObject(env, self);
1020 const char *str = NULL;
1021
1022 if (!ctx || !obj) return NULL;
1023
1024 fz_try(ctx)
1025 str = pdf_to_text_string(ctx, obj);
1026 fz_catch(ctx)
1027 jni_rethrow(env, ctx);
1028
1029 return (*env)->NewStringUTF(env, str);
1030 }
1031
1032 JNIEXPORT jobject JNICALL
FUN(PDFObject_asByteString)1033 FUN(PDFObject_asByteString)(JNIEnv *env, jobject self)
1034 {
1035 fz_context *ctx = get_context(env);
1036 pdf_obj *obj = from_PDFObject(env, self);
1037 const char *str = NULL;
1038 jobject jbs = NULL;
1039 jbyte *bs = NULL;
1040 size_t len;
1041
1042 if (!ctx || !obj) return NULL;
1043
1044 fz_try(ctx)
1045 {
1046 str = pdf_to_str_buf(ctx, obj);
1047 len = pdf_to_str_len(ctx, obj);
1048 }
1049 fz_catch(ctx)
1050 jni_rethrow(env, ctx);
1051
1052 jbs = (*env)->NewByteArray(env, len);
1053 if ((*env)->ExceptionCheck(env)) return NULL;
1054 if (!jbs) jni_throw_run(env, "cannot create byte array");
1055 bs = (*env)->GetByteArrayElements(env, jbs, NULL);
1056 if (!bs) return NULL;
1057
1058 memcpy(bs, str, len);
1059
1060 (*env)->ReleaseByteArrayElements(env, jbs, bs, 0);
1061
1062 return jbs;
1063 }
1064
1065 JNIEXPORT jstring JNICALL
FUN(PDFObject_asName)1066 FUN(PDFObject_asName)(JNIEnv *env, jobject self)
1067 {
1068 fz_context *ctx = get_context(env);
1069 pdf_obj *obj = from_PDFObject(env, self);
1070 const char *str = NULL;
1071
1072 if (!ctx || !obj) return NULL;
1073
1074 fz_try(ctx)
1075 str = pdf_to_name(ctx, obj);
1076 fz_catch(ctx)
1077 jni_rethrow(env, ctx);
1078
1079 return (*env)->NewStringUTF(env, str);
1080 }
1081
1082 JNIEXPORT jint JNICALL
FUN(PDFObject_size)1083 FUN(PDFObject_size)(JNIEnv *env, jobject self)
1084 {
1085 fz_context *ctx = get_context(env);
1086 pdf_obj *obj = from_PDFObject(env, self);
1087 int len;
1088
1089 if (!ctx || !obj) return 0;
1090
1091 fz_try(ctx)
1092 {
1093 if (pdf_is_array(ctx, obj))
1094 len = pdf_array_len(ctx, obj);
1095 else if (pdf_is_dict(ctx, obj))
1096 len = pdf_dict_len(ctx, obj);
1097 else
1098 len = 0;
1099 }
1100 fz_catch(ctx)
1101 jni_rethrow(env, ctx);
1102
1103 return len;
1104 }
1105
1106 JNIEXPORT void JNICALL
FUN(PDFObject_pushBoolean)1107 FUN(PDFObject_pushBoolean)(JNIEnv *env, jobject self, jboolean b)
1108 {
1109 fz_context *ctx = get_context(env);
1110 pdf_obj *arr = from_PDFObject(env, self);
1111
1112 if (!ctx || !arr) return;
1113
1114 fz_try(ctx)
1115 pdf_array_push_bool(ctx, arr, b);
1116 fz_catch(ctx)
1117 jni_rethrow_void(env, ctx);
1118 }
1119
1120 JNIEXPORT void JNICALL
FUN(PDFObject_pushInteger)1121 FUN(PDFObject_pushInteger)(JNIEnv *env, jobject self, jint i)
1122 {
1123 fz_context *ctx = get_context(env);
1124 pdf_obj *arr = from_PDFObject(env, self);
1125
1126 if (!ctx || !arr) return;
1127
1128 fz_try(ctx)
1129 pdf_array_push_int(ctx, arr, i);
1130 fz_catch(ctx)
1131 jni_rethrow_void(env, ctx);
1132 }
1133
1134 JNIEXPORT void JNICALL
FUN(PDFObject_pushFloat)1135 FUN(PDFObject_pushFloat)(JNIEnv *env, jobject self, jfloat f)
1136 {
1137 fz_context *ctx = get_context(env);
1138 pdf_obj *arr = from_PDFObject(env, self);
1139
1140 if (!ctx || !arr) return;
1141
1142 fz_try(ctx)
1143 pdf_array_push_real(ctx, arr, f);
1144 fz_catch(ctx)
1145 jni_rethrow_void(env, ctx);
1146 }
1147
1148 JNIEXPORT void JNICALL
FUN(PDFObject_pushString)1149 FUN(PDFObject_pushString)(JNIEnv *env, jobject self, jstring jstr)
1150 {
1151 fz_context *ctx = get_context(env);
1152 pdf_obj *arr = from_PDFObject(env, self);
1153 const char *str = NULL;
1154
1155 if (!ctx || !arr) return;
1156 if (jstr)
1157 {
1158 str = (*env)->GetStringUTFChars(env, jstr, NULL);
1159 if (!str) return;
1160 }
1161
1162 fz_try(ctx)
1163 {
1164 if (str)
1165 pdf_array_push_string(ctx, arr, str, strlen(str));
1166 else
1167 pdf_array_push(ctx, arr, PDF_NULL);
1168 }
1169 fz_always(ctx)
1170 {
1171 if (str)
1172 (*env)->ReleaseStringUTFChars(env, jstr, str);
1173 }
1174 fz_catch(ctx)
1175 jni_rethrow_void(env, ctx);
1176 }
1177
1178 JNIEXPORT void JNICALL
FUN(PDFObject_pushPDFObject)1179 FUN(PDFObject_pushPDFObject)(JNIEnv *env, jobject self, jobject jitem)
1180 {
1181 fz_context *ctx = get_context(env);
1182 pdf_obj *arr = from_PDFObject(env, self);
1183 pdf_obj *item = from_PDFObject(env, jitem);
1184
1185 if (!ctx || !arr) return;
1186
1187 fz_try(ctx)
1188 pdf_array_push(ctx, arr, item);
1189 fz_always(ctx)
1190 pdf_drop_obj(ctx, item);
1191 fz_catch(ctx)
1192 jni_rethrow_void(env, ctx);
1193 }
1194
1195 JNIEXPORT jstring JNICALL
FUN(PDFObject_toString)1196 FUN(PDFObject_toString)(JNIEnv *env, jobject self, jboolean tight, jboolean ascii)
1197 {
1198 fz_context *ctx = get_context(env);
1199 pdf_obj *obj = from_PDFObject_safe(env, self);
1200 jstring string = NULL;
1201 char *s = NULL;
1202 size_t n = 0;
1203
1204 if (!ctx || !obj) return NULL;
1205
1206 fz_var(s);
1207
1208 fz_try(ctx)
1209 {
1210 s = pdf_sprint_obj(ctx, NULL, 0, &n, obj, tight, ascii);
1211 string = (*env)->NewStringUTF(env, s);
1212 }
1213 fz_always(ctx)
1214 fz_free(ctx, s);
1215 fz_catch(ctx)
1216 jni_rethrow(env, ctx);
1217
1218 return string;
1219 }
1220