Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/platform/java/jni/pdfobject.c @ 2:b50eed0cc0ef upstream

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