Debian Codegraph @

platform/wasm/lib/mupdf.c

raw
1 // Copyright (C) 2004-2025 Artifex Software, Inc.
2 //
3 // This file is part of MuPDF WASM Library.
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 // TODO: Story
24 // TODO: DOM
25
26 // TODO: PDFWidget
27
28 // TODO: WASMDevice with callbacks
29 // TODO: PDFPage.process with callbacks
30
31 #include "emscripten.h"
32 #include "mupdf/fitz.h"
33 #include "mupdf/pdf.h"
34 #include "mupdf/ucdn.h"
35 #include <string.h>
36 #include <math.h>
37
38 static fz_context *ctx;
39
40 static fz_matrix out_matrix;
41 static fz_point out_point;
42 static fz_rect out_rect;
43 static fz_quad out_quad;
44 static fz_link_dest out_link_dest;
45 static pdf_layer_config_ui out_layer_config_ui;
46
47 typedef int boolean;
48
49 #define EXPORT EMSCRIPTEN_KEEPALIVE
50
51 #define TRY(CODE) { fz_try(ctx) CODE fz_catch(ctx) wasm_rethrow(ctx); }
52
53 // Simple wrappers for one-line functions...
54 #define POINTER(F, ...) void* p; TRY({ p = (void*)F(ctx, ## __VA_ARGS__); }) return p;
55 #define INTEGER(F, ...) int p; TRY({ p = F(ctx, ## __VA_ARGS__); }) return p;
56 #define BOOLEAN(F, ...) boolean p; TRY({ p = F(ctx, ## __VA_ARGS__); }) return p;
57 #define NUMBER(F, ...) float p; TRY({ p = F(ctx, ## __VA_ARGS__); }) return p;
58 #define MATRIX(F, ...) TRY({ out_matrix = F(ctx, ## __VA_ARGS__); }) return &out_matrix;
59 #define POINT(F, ...) TRY({ out_point = F(ctx, ## __VA_ARGS__); }) return &out_point;
60 #define RECT(F, ...) TRY({ out_rect = F(ctx, ## __VA_ARGS__); }) return &out_rect;
61 #define QUAD(F, ...) TRY({ out_quad = F(ctx, ## __VA_ARGS__); }) return &out_quad;
62 #define VOID(F, ...) TRY({ F(ctx, ## __VA_ARGS__); })
63
64 __attribute__((noinline)) void
65 wasm_rethrow(fz_context *ctx)
66 {
67 int code;
68 const char *message = fz_convert_error(ctx, &code);
69 if (code == FZ_ERROR_TRYLATER)
70 EM_ASM({ throw "TRYLATER"; }, message);
71 else if (code == FZ_ERROR_ABORT)
72 EM_ASM({ throw "ABORT"; }, message);
73 else
74 EM_ASM({ throw new Error(UTF8ToString($0)); }, message);
75 }
76
77 static fz_font *load_wasm_font_file(const char *name, const char *script, int bold, int italic)
78 {
79 fz_font *font = EM_ASM_PTR({ return globalThis.$libmupdf_load_font_file($0, $1, $2, $3) }, name, script, bold, italic);
80 if (font)
81 return fz_keep_font(ctx, font);
82 return NULL;
83 }
84
85 static fz_font *load_wasm_font(fz_context *ctx, const char *name, int bold, int italic, int needs_exact_metrics)
86 {
87 return load_wasm_font_file(name, "undefined", bold, italic);
88 }
89
90 static fz_font *load_wasm_cjk_font(fz_context *ctx, const char *name, int ordering, int serif)
91 {
92 switch (ordering)
93 {
94 case FZ_ADOBE_CNS: return load_wasm_font_file(name, "TC", 0, 0);
95 case FZ_ADOBE_GB: return load_wasm_font_file(name, "SC", 0, 0);
96 case FZ_ADOBE_JAPAN: return load_wasm_font_file(name, "JP", 0, 0);
97 case FZ_ADOBE_KOREA: return load_wasm_font_file(name, "KR", 0, 0);
98 }
99 return NULL;
100 }
101
102 static fz_font *load_wasm_fallback_font(fz_context *ctx, int script, int language, int serif, int bold, int italic)
103 {
104 return load_wasm_font_file("undefined", fz_lookup_script_name(ctx, script, language), bold, italic);
105 }
106
107 EXPORT
108 void wasm_init_context(void)
109 {
110 ctx = fz_new_context(NULL, NULL, 100<<20);
111 if (!ctx)
112 EM_ASM({ throw new Error("Cannot create MuPDF context!"); });
113 fz_register_document_handlers(ctx);
114 fz_install_load_system_font_funcs(ctx,
115 load_wasm_font,
116 load_wasm_cjk_font,
117 load_wasm_fallback_font);
118 }
119
120 EXPORT
121 void * wasm_malloc(size_t size)
122 {
123 POINTER(fz_malloc, size)
124 }
125
126 EXPORT
127 void wasm_free(void *p)
128 {
129 fz_free(ctx, p);
130 }
131
132 EXPORT
133 void wasm_enable_icc(void)
134 {
135 VOID(fz_enable_icc)
136 }
137
138 EXPORT
139 void wasm_disable_icc(void)
140 {
141 VOID(fz_disable_icc)
142 }
143
144 EXPORT
145 void wasm_set_user_css(char *text)
146 {
147 VOID(fz_set_user_css, text)
148 }
149
150 EXPORT
151 void wasm_empty_store(void)
152 {
153 VOID(fz_empty_store)
154 }
155
156 EXPORT
157 boolean wasm_shrink_store(int percent)
158 {
159 BOOLEAN(fz_shrink_store, percent)
160 }
161
162 EXPORT
163 void wasm_Memento_checkAllMemory(void)
164 {
165 #ifdef MEMENTO
166 Memento_checkAllMemory();
167 #else
168 fprintf(stderr, "memento is not available in release build\n");
169 #endif
170 }
171
172 EXPORT
173 void wasm_Memento_listBlocks(void)
174 {
175 #ifdef MEMENTO
176 Memento_listBlocks();
177 #else
178 fprintf(stderr, "memento is not available in release build\n");
179 #endif
180 }
181
182 // --- REFERENCE COUNTING ---
183
184 #define KEEP_(T,WNAME,FNAME) EXPORT T * WNAME(T *p) { return FNAME(ctx, p); }
185 #define DROP_(T,WNAME,FNAME) EXPORT void WNAME(T *p) { FNAME(ctx, p); }
186
187 #define KEEP(NAME) KEEP_(fz_ ## NAME, wasm_keep_ ## NAME, fz_keep_ ## NAME)
188 #define DROP(NAME) DROP_(fz_ ## NAME, wasm_drop_ ## NAME, fz_drop_ ## NAME)
189
190 #define REFS(NAME) \
191 KEEP(NAME) \
192 DROP(NAME)
193
194 #define PDF_REFS(NAME) \
195 KEEP_(pdf_ ## NAME, wasm_pdf_keep_ ## NAME, pdf_keep_ ## NAME) \
196 DROP_(pdf_ ## NAME, wasm_pdf_drop_ ## NAME, pdf_drop_ ## NAME)
197
198 REFS(buffer)
199 REFS(stream)
200
201 REFS(colorspace)
202 REFS(pixmap)
203 REFS(font)
204 REFS(stroke_state)
205 REFS(image)
206 REFS(shade)
207 REFS(path)
208 REFS(text)
209 REFS(device)
210 REFS(display_list)
211 DROP(stext_page)
212 DROP(document_writer)
213 DROP(outline_iterator)
214
215 REFS(document)
216 REFS(page)
217 REFS(link)
218 REFS(outline)
219
220 PDF_REFS(annot)
221 PDF_REFS(obj)
222 PDF_REFS(graft_map)
223
224 // --- PLAIN STRUCT ACCESSORS ---
225
226 #define GETP(S,T,F) EXPORT T* wasm_ ## S ## _get_ ## F(fz_ ## S *p) { return &p->F; }
227 #define GETU(S,T,F,U) EXPORT T wasm_ ## S ## _get_ ## F(fz_ ## S *p) { return p->U; }
228 #define GETUP(S,T,F,U) EXPORT T* wasm_ ## S ## _get_ ## F(fz_ ## S *p) { return &p->U; }
229 #define GET(S,T,F) EXPORT T wasm_ ## S ## _get_ ## F(fz_ ## S *p) { return p->F; }
230 #define GET_ALIAS(S,T,F,FF) EXPORT T wasm_ ## S ## _get_ ## F(fz_ ## S *p) { return p->FF; }
231 #define SET(S,T,F) EXPORT void wasm_ ## S ## _set_ ## F(fz_ ## S *p, T v) { p->F = v; }
232 #define GETSET(S,T,F) GET(S,T,F) SET(S,T,F)
233
234 #define PDF_GET(S,T,F) EXPORT T wasm_pdf_ ## S ## _get_ ## F(pdf_ ## S *p) { return p->F; }
235 #define PDF_SET(S,T,F) EXPORT void wasm_pdf_ ## S ## _set_ ## F(pdf_ ## S *p, T v) { p->F = v; }
236
237 GET(buffer, void*, data)
238 GET(buffer, int, len)
239
240 GET(colorspace, int, type)
241 GET(colorspace, int, n)
242 GET(colorspace, char*, name)
243
244 GET(pixmap, int, w)
245 GET(pixmap, int, h)
246 GET(pixmap, int, x)
247 GET(pixmap, int, y)
248 GET(pixmap, int, n)
249 GET(pixmap, int, stride)
250 GET(pixmap, int, alpha)
251 GET(pixmap, int, xres)
252 GET(pixmap, int, yres)
253 GET(pixmap, fz_colorspace*, colorspace)
254 GET(pixmap, unsigned char*, samples)
255
256 SET(pixmap, int, xres)
257 SET(pixmap, int, yres)
258
259 GET(font, char*, name)
260
261 GETSET(stroke_state, int, start_cap)
262 GETSET(stroke_state, int, dash_cap)
263 GETSET(stroke_state, int, end_cap)
264 GETSET(stroke_state, int, linejoin)
265 GETSET(stroke_state, float, linewidth)
266 GETSET(stroke_state, float, miterlimit)
267 GETSET(stroke_state, float, dash_phase)
268 GET(stroke_state, int, dash_len)
269
270 GET(image, int, w)
271 GET(image, int, h)
272 GET(image, int, n)
273 GET(image, int, bpc)
274 GET(image, int, xres)
275 GET(image, int, yres)
276 GET(image, boolean, imagemask)
277 GET(image, fz_colorspace*, colorspace)
278 GET(image, fz_image*, mask)
279
280 GET(outline, char*, title)
281 GET(outline, char*, uri)
282 GET(outline, fz_outline*, next)
283 GET(outline, fz_outline*, down)
284 GET(outline, boolean, is_open)
285
286 GET(outline_item, char*, title)
287 GET(outline_item, char*, uri)
288 GET(outline_item, boolean, is_open)
289
290 GETP(link, fz_rect, rect)
291 GET(link, char*, uri)
292 GET(link, fz_link*, next)
293
294 GETP(stext_page, fz_rect, mediabox)
295 GET(stext_page, fz_stext_block*, first_block)
296
297 GET(stext_block, fz_stext_block*, next)
298 GET(stext_block, int, type)
299 GETP(stext_block, fz_rect, bbox)
300 GETU(stext_block, fz_stext_line*, first_line, u.t.first_line)
301 GETUP(stext_block, fz_matrix, transform, u.i.transform)
302 GETU(stext_block, fz_image*, image, u.i.image)
303
304 GETU(stext_block, int, v_flags, u.v.flags)
305 GETU(stext_block, int, v_argb, u.v.argb)
306
307 GET(stext_line, fz_stext_line*, next)
308 GET(stext_line, int, wmode)
309 GETP(stext_line, fz_point, dir)
310 GETP(stext_line, fz_rect, bbox)
311 GET(stext_line, fz_stext_char*, first_char)
312
313 GET(stext_char, fz_stext_char*, next)
314 GET(stext_char, int, c)
315 GETP(stext_char, fz_point, origin)
316 GETP(stext_char, fz_quad, quad)
317 GET(stext_char, float, size)
318 GET(stext_char, fz_font*, font)
319 GET(stext_char, int, argb)
320
321 GET_ALIAS(link_dest, int, chapter, loc.chapter)
322 GET_ALIAS(link_dest, int, page, loc.page)
323 GET(link_dest, int, type)
324 GET(link_dest, float, x)
325 GET(link_dest, float, y)
326 GET(link_dest, float, w)
327 GET(link_dest, float, h)
328 GET(link_dest, float, zoom)
329
330 PDF_GET(layer_config_ui, const char*, text)
331 PDF_GET(layer_config_ui, int, depth)
332 PDF_GET(layer_config_ui, int, type)
333 PDF_GET(layer_config_ui, int, selected)
334 PDF_GET(layer_config_ui, int, locked)
335
336 PDF_GET(filespec_params, const char*, filename)
337 PDF_GET(filespec_params, const char*, mimetype)
338 PDF_GET(filespec_params, int, size)
339 PDF_GET(filespec_params, int, created)
340 PDF_GET(filespec_params, int, modified)
341
342 PDF_GET(page, pdf_obj*, obj)
343
344 // --- Buffer ---
345
346 EXPORT
347 fz_buffer * wasm_new_buffer(size_t capacity)
348 {
349 POINTER(fz_new_buffer, capacity)
350 }
351
352 EXPORT
353 fz_buffer * wasm_new_buffer_from_data(unsigned char *data, size_t size)
354 {
355 POINTER(fz_new_buffer_from_data, data, size)
356 }
357
358 EXPORT
359 void wasm_append_string(fz_buffer *buf, char *str)
360 {
361 VOID(fz_append_string, buf, str)
362 }
363
364 EXPORT
365 void wasm_append_byte(fz_buffer *buf, int c)
366 {
367 VOID(fz_append_byte, buf, c)
368 }
369
370 EXPORT
371 void wasm_append_buffer(fz_buffer *buf, fz_buffer *src)
372 {
373 VOID(fz_append_buffer, buf, src)
374 }
375
376 EXPORT
377 fz_buffer * wasm_slice_buffer(fz_buffer *buf, int start, int end)
378 {
379 POINTER(fz_slice_buffer, buf, start, end)
380 }
381
382 EXPORT
383 char * wasm_string_from_buffer(fz_buffer *buf)
384 {
385 POINTER(fz_string_from_buffer, buf)
386 }
387
388 // --- ColorSpace ---
389
390 EXPORT fz_colorspace * wasm_device_gray(void) { return fz_device_gray(ctx); }
391 EXPORT fz_colorspace * wasm_device_rgb(void) { return fz_device_rgb(ctx); }
392 EXPORT fz_colorspace * wasm_device_bgr(void) { return fz_device_bgr(ctx); }
393 EXPORT fz_colorspace * wasm_device_cmyk(void) { return fz_device_cmyk(ctx); }
394 EXPORT fz_colorspace * wasm_device_lab(void) { return fz_device_lab(ctx); }
395
396 EXPORT
397 fz_colorspace * wasm_new_icc_colorspace(char *name, fz_buffer *buffer)
398 {
399 POINTER(fz_new_icc_colorspace, FZ_COLORSPACE_NONE, 0, name, buffer)
400 }
401
402 // --- StrokeState ---
403
404 EXPORT
405 fz_stroke_state * wasm_new_stroke_state(int dash_len)
406 {
407 fz_stroke_state *p = NULL;
408 TRY({
409 p = fz_new_stroke_state_with_dash_len(ctx, dash_len);
410 })
411 return p;
412 }
413
414 EXPORT
415 float wasm_stroke_state_get_dash_item(fz_stroke_state *stroke, int i)
416 {
417 if (i >= 0 && i < stroke->dash_len)
418 return stroke->dash_list[i];
419 return 0;
420 }
421
422 EXPORT
423 void wasm_stroke_state_set_dash_item(fz_stroke_state *stroke, int i, float x)
424 {
425 if (i >= 0 && i < stroke->dash_len)
426 stroke->dash_list[i] = x;
427 }
428
429 // --- Font ---
430
431 EXPORT
432 fz_font * wasm_new_base14_font(char *name)
433 {
434 POINTER(fz_new_base14_font, name)
435 }
436
437 EXPORT
438 fz_font * wasm_new_cjk_font(int ordering)
439 {
440 POINTER(fz_new_cjk_font, ordering)
441 }
442
443 EXPORT
444 fz_font * wasm_new_font_from_buffer(char *name, fz_buffer *buf, int subfont)
445 {
446 POINTER(fz_new_font_from_buffer, name, buf, subfont, 0)
447 }
448
449 EXPORT
450 int wasm_encode_character(fz_font *font, int unicode)
451 {
452 INTEGER(fz_encode_character, font, unicode)
453 }
454
455 EXPORT
456 float wasm_advance_glyph(fz_font *font, int glyph, int wmode)
457 {
458 NUMBER(fz_advance_glyph, font, glyph, wmode)
459 }
460
461 EXPORT
462 int wasm_font_is_monospaced(fz_font *font)
463 {
464 INTEGER(fz_font_is_monospaced, font)
465 }
466
467 EXPORT
468 int wasm_font_is_serif(fz_font *font)
469 {
470 INTEGER(fz_font_is_serif, font)
471 }
472
473 EXPORT
474 int wasm_font_is_bold(fz_font *font)
475 {
476 INTEGER(fz_font_is_bold, font)
477 }
478
479 EXPORT
480 int wasm_font_is_italic(fz_font *font)
481 {
482 INTEGER(fz_font_is_italic, font)
483 }
484
485 // --- Image ---
486
487 EXPORT
488 fz_image * wasm_new_image_from_pixmap(fz_pixmap *pix, fz_image *mask)
489 {
490 POINTER(fz_new_image_from_pixmap, pix, mask)
491 }
492
493 EXPORT
494 fz_image * wasm_new_image_from_buffer(fz_buffer *buf)
495 {
496 POINTER(fz_new_image_from_buffer, buf)
497 }
498
499 // --- Pixmap ---
500
501 EXPORT
502 fz_pixmap * wasm_get_pixmap_from_image(fz_image *image)
503 {
504 POINTER(fz_get_pixmap_from_image, image, NULL, NULL, NULL, NULL)
505 }
506
507 EXPORT
508 fz_pixmap * wasm_new_pixmap_from_page(fz_page *page, fz_matrix *ctm, fz_colorspace *colorspace, boolean alpha)
509 {
510 POINTER(fz_new_pixmap_from_page, page, *ctm, colorspace, alpha)
511 }
512
513 EXPORT
514 fz_pixmap * wasm_new_pixmap_from_page_contents(fz_page *page, fz_matrix *ctm, fz_colorspace *colorspace, boolean alpha)
515 {
516 POINTER(fz_new_pixmap_from_page_contents, page, *ctm, colorspace, alpha)
517 }
518
519 EXPORT
520 fz_pixmap * wasm_pdf_new_pixmap_from_page_with_usage(pdf_page *page, fz_matrix *ctm, fz_colorspace *colorspace, boolean alpha, char *usage, int box)
521 {
522 POINTER(pdf_new_pixmap_from_page_with_usage, page, *ctm, colorspace, alpha, usage, box)
523 }
524
525 EXPORT
526 fz_pixmap * wasm_pdf_new_pixmap_from_page_contents_with_usage(pdf_page *page, fz_matrix *ctm, fz_colorspace *colorspace, boolean alpha, char *usage, int box)
527 {
528 POINTER(pdf_new_pixmap_from_page_contents_with_usage, page, *ctm, colorspace, alpha, usage, box)
529 }
530
531 EXPORT
532 fz_pixmap * wasm_new_pixmap_with_bbox(fz_colorspace *colorspace, fz_rect *bbox, boolean alpha)
533 {
534 POINTER(fz_new_pixmap_with_bbox, colorspace, fz_irect_from_rect(*bbox), NULL, alpha)
535 }
536
537 EXPORT
538 void wasm_clear_pixmap(fz_pixmap *pix)
539 {
540 VOID(fz_clear_pixmap, pix)
541 }
542
543 EXPORT
544 void wasm_clear_pixmap_with_value(fz_pixmap *pix, int value)
545 {
546 VOID(fz_clear_pixmap_with_value, pix, value)
547 }
548
549 EXPORT
550 void wasm_invert_pixmap(fz_pixmap *pix)
551 {
552 VOID(fz_invert_pixmap, pix)
553 }
554
555 EXPORT
556 void wasm_invert_pixmap_luminance(fz_pixmap *pix)
557 {
558 VOID(fz_invert_pixmap_luminance, pix)
559 }
560
561 EXPORT
562 void wasm_gamma_pixmap(fz_pixmap *pix, float gamma)
563 {
564 VOID(fz_gamma_pixmap, pix, gamma)
565 }
566
567 EXPORT
568 void wasm_tint_pixmap(fz_pixmap *pix, int black_hex_color, int white_hex_color)
569 {
570 VOID(fz_tint_pixmap, pix, black_hex_color, white_hex_color)
571 }
572
573 EXPORT
574 fz_buffer * wasm_new_buffer_from_pixmap_as_png(fz_pixmap *pix)
575 {
576 POINTER(fz_new_buffer_from_pixmap_as_png, pix, fz_default_color_params)
577 }
578
579 EXPORT
580 fz_buffer * wasm_new_buffer_from_pixmap_as_pam(fz_pixmap *pix)
581 {
582 POINTER(fz_new_buffer_from_pixmap_as_pam, pix, fz_default_color_params)
583 }
584
585 EXPORT
586 fz_buffer * wasm_new_buffer_from_pixmap_as_psd(fz_pixmap *pix)
587 {
588 POINTER(fz_new_buffer_from_pixmap_as_psd, pix, fz_default_color_params)
589 }
590
591 EXPORT
592 fz_buffer * wasm_new_buffer_from_pixmap_as_jpeg(fz_pixmap *pix, int quality, boolean invert_cmyk)
593 {
594 POINTER(fz_new_buffer_from_pixmap_as_jpeg, pix, fz_default_color_params, quality, invert_cmyk)
595 }
596
597 EXPORT
598 fz_pixmap * wasm_convert_pixmap(fz_pixmap *pixmap, fz_colorspace *colorspace, boolean keep_alpha)
599 {
600 POINTER(fz_convert_pixmap, pixmap, colorspace, NULL, NULL, fz_default_color_params, keep_alpha)
601 }
602
603 EXPORT
604 fz_pixmap * wasm_warp_pixmap(fz_pixmap *pixmap, fz_quad *q, float w, float h)
605 {
606 POINTER(fz_warp_pixmap, pixmap, *q, w, h)
607 }
608
609 // --- Shade ---
610
611 EXPORT
612 fz_rect * wasm_bound_shade(fz_shade *shade)
613 {
614 RECT(fz_bound_shade, shade, fz_identity)
615 }
616
617 // --- DisplayList ---
618
619 EXPORT
620 fz_display_list * wasm_new_display_list(fz_rect *mediabox)
621 {
622 POINTER(fz_new_display_list, *mediabox)
623 }
624
625 EXPORT
626 fz_rect * wasm_bound_display_list(fz_display_list *list)
627 {
628 RECT(fz_bound_display_list, list)
629 }
630
631 EXPORT
632 void wasm_run_display_list(fz_display_list *display_list, fz_device *dev, fz_matrix *ctm)
633 {
634 VOID(fz_run_display_list, display_list, dev, *ctm, fz_infinite_rect, NULL)
635 }
636
637 EXPORT
638 fz_pixmap * wasm_new_pixmap_from_display_list(fz_display_list *display_list, fz_matrix *ctm, fz_colorspace *colorspace, boolean alpha)
639 {
640 POINTER(fz_new_pixmap_from_display_list, display_list, *ctm, colorspace, alpha)
641 }
642
643 EXPORT
644 fz_stext_page * wasm_new_stext_page_from_display_list(fz_display_list *display_list, char *option_string)
645 {
646 fz_stext_page *stext = NULL;
647 fz_stext_options options;
648 TRY({
649 fz_parse_stext_options(ctx, &options, option_string);
650 stext = fz_new_stext_page_from_display_list(ctx, display_list, &options);
651 })
652 return stext;
653 }
654
655 EXPORT
656 int wasm_search_display_list(fz_display_list *display_list, char *needle, int *marks, fz_quad *hits, int hit_max)
657 {
658 INTEGER(fz_search_display_list, display_list, needle, marks, hits, hit_max)
659 }
660
661 // --- Path ---
662
663 EXPORT
664 fz_path * wasm_new_path(void)
665 {
666 POINTER(fz_new_path)
667 }
668
669 EXPORT
670 void wasm_moveto(fz_path *path, float x, float y)
671 {
672 VOID(fz_moveto, path, x, y)
673 }
674
675 EXPORT
676 void wasm_lineto(fz_path *path, float x, float y)
677 {
678 VOID(fz_lineto, path, x, y)
679 }
680
681 EXPORT
682 void wasm_curveto(fz_path *path, float x1, float y1, float x2, float y2, float x3, float y3)
683 {
684 VOID(fz_curveto, path, x1, y1, x2, y2, x3, y3)
685 }
686
687 EXPORT
688 void wasm_curvetov(fz_path *path, float x1, float y1, float x2, float y2)
689 {
690 VOID(fz_curvetov, path, x1, y1, x2, y2)
691 }
692
693 EXPORT
694 void wasm_curvetoy(fz_path *path, float x1, float y1, float x2, float y2)
695 {
696 VOID(fz_curvetoy, path, x1, y1, x2, y2)
697 }
698
699 EXPORT
700 void wasm_closepath(fz_path *path)
701 {
702 VOID(fz_closepath, path)
703 }
704
705 EXPORT
706 void wasm_rectto(fz_path *path, float x1, float y1, float x2, float y2)
707 {
708 VOID(fz_rectto, path, x1, y1, x2, y2)
709 }
710
711 EXPORT
712 void wasm_transform_path(fz_path *path, fz_matrix *ctm)
713 {
714 VOID(fz_transform_path, path, *ctm)
715 }
716
717 EXPORT
718 fz_rect * wasm_bound_path(fz_path *path, fz_stroke_state *stroke, fz_matrix *ctm)
719 {
720 RECT(fz_bound_path, path, stroke, *ctm)
721 }
722
723 // --- Text ---
724
725 EXPORT
726 fz_text * wasm_new_text(void)
727 {
728 POINTER(fz_new_text)
729 }
730
731 EXPORT
732 fz_rect * wasm_bound_text(fz_text *text, fz_stroke_state *stroke, fz_matrix *ctm)
733 {
734 RECT(fz_bound_text, text, stroke, *ctm)
735 }
736
737 EXPORT
738 void wasm_show_glyph(fz_text *text, fz_font *font, fz_matrix *trm, int gid, int ucs, int wmode)
739 {
740 VOID(fz_show_glyph, text, font, *trm, gid, ucs, wmode, 0, 0, FZ_LANG_UNSET)
741 }
742
743 EXPORT
744 fz_matrix *wasm_show_string(fz_text *text, fz_font *font, fz_matrix *trm, char *string, int wmode)
745 {
746 MATRIX(fz_show_string, text, font, *trm, string, wmode, 0, 0, FZ_LANG_UNSET)
747 }
748
749 // --- Device ---
750
751 EXPORT
752 fz_device * wasm_new_draw_device(fz_matrix *ctm, fz_pixmap *dest)
753 {
754 POINTER(fz_new_draw_device, *ctm, dest)
755 }
756
757 EXPORT
758 fz_device * wasm_new_display_list_device(fz_display_list *list)
759 {
760 POINTER(fz_new_list_device, list)
761 }
762
763 EXPORT
764 void wasm_close_device(fz_device *dev)
765 {
766 VOID(fz_close_device, dev)
767 }
768
769 EXPORT
770 void wasm_fill_path(fz_device *dev, fz_path *path, boolean evenOdd, fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha)
771 {
772 VOID(fz_fill_path, dev, path, evenOdd, *ctm, colorspace, color, alpha, fz_default_color_params)
773 }
774
775 EXPORT
776 void wasm_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha)
777 {
778 VOID(fz_stroke_path, dev, path, stroke, *ctm, colorspace, color, alpha, fz_default_color_params)
779 }
780
781 EXPORT
782 void wasm_clip_path(fz_device *dev, fz_path *path, boolean evenOdd, fz_matrix *ctm)
783 {
784 VOID(fz_clip_path, dev, path, evenOdd, *ctm, fz_infinite_rect)
785 }
786
787 EXPORT
788 void wasm_clip_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_matrix *ctm)
789 {
790 VOID(fz_clip_stroke_path, dev, path, stroke, *ctm, fz_infinite_rect)
791 }
792
793 EXPORT
794 void wasm_fill_text(fz_device *dev, fz_text *text, fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha)
795 {
796 VOID(fz_fill_text, dev, text, *ctm, colorspace, color, alpha, fz_default_color_params)
797 }
798
799 EXPORT
800 void wasm_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha)
801 {
802 VOID(fz_stroke_text, dev, text, stroke, *ctm, colorspace, color, alpha, fz_default_color_params)
803 }
804
805 EXPORT
806 void wasm_clip_text(fz_device *dev, fz_text *text, fz_matrix *ctm)
807 {
808 VOID(fz_clip_text, dev, text, *ctm, fz_infinite_rect)
809 }
810
811 EXPORT
812 void wasm_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix *ctm)
813 {
814 VOID(fz_clip_stroke_text, dev, text, stroke, *ctm, fz_infinite_rect)
815 }
816
817 EXPORT
818 void wasm_ignore_text(fz_device *dev, fz_text *text, fz_matrix *ctm)
819 {
820 VOID(fz_ignore_text, dev, text, *ctm)
821 }
822
823 EXPORT
824 void wasm_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix *ctm, float alpha)
825 {
826 VOID(fz_fill_shade, dev, shade, *ctm, alpha, fz_default_color_params)
827 }
828
829 EXPORT
830 void wasm_fill_image(fz_device *dev, fz_image *image, fz_matrix *ctm, float alpha)
831 {
832 VOID(fz_fill_image, dev, image, *ctm, alpha, fz_default_color_params)
833 }
834
835 EXPORT
836 void wasm_fill_image_mask(fz_device *dev, fz_image *image, fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha)
837 {
838 VOID(fz_fill_image_mask, dev, image, *ctm, colorspace, color, alpha, fz_default_color_params)
839 }
840
841 EXPORT
842 void wasm_clip_image_mask(fz_device *dev, fz_image *image, fz_matrix *ctm)
843 {
844 VOID(fz_clip_image_mask, dev, image, *ctm, fz_infinite_rect)
845 }
846
847 EXPORT
848 void wasm_pop_clip(fz_device *dev)
849 {
850 VOID(fz_pop_clip, dev)
851 }
852
853 EXPORT
854 void wasm_begin_mask(fz_device *dev, fz_rect *area, boolean luminosity, fz_colorspace *colorspace, float *color)
855 {
856 VOID(fz_begin_mask, dev, *area, luminosity, colorspace, color, fz_default_color_params)
857 }
858
859 EXPORT
860 void wasm_end_mask(fz_device *dev)
861 {
862 VOID(fz_end_mask, dev)
863 }
864
865 EXPORT
866 void wasm_begin_group(fz_device *dev, fz_rect *area, fz_colorspace *colorspace, boolean isolated, boolean knockout, int blendmode, float alpha)
867 {
868 VOID(fz_begin_group, dev, *area, colorspace, isolated, knockout, blendmode, alpha)
869 }
870
871 EXPORT
872 void wasm_end_group(fz_device *dev)
873 {
874 VOID(fz_end_group, dev)
875 }
876
877 EXPORT
878 int wasm_begin_tile(fz_device *dev, fz_rect *area, fz_rect *view, float xstep, float ystep, fz_matrix *ctm, int id, int doc_id)
879 {
880 INTEGER(fz_begin_tile_tid, dev, *area, *view, xstep, ystep, *ctm, id, doc_id)
881 }
882
883 EXPORT
884 void wasm_end_tile(fz_device *dev)
885 {
886 VOID(fz_end_tile, dev)
887 }
888
889 EXPORT
890 void wasm_begin_layer(fz_device *dev, char *name)
891 {
892 VOID(fz_begin_layer, dev, name)
893 }
894
895 EXPORT
896 void wasm_end_layer(fz_device *dev)
897 {
898 VOID(fz_end_layer, dev)
899 }
900
901 // --- DocumentWriter ---
902
903 EXPORT
904 fz_document_writer * wasm_new_document_writer_with_buffer(fz_buffer *buf, char *format, char *options)
905 {
906 POINTER(fz_new_document_writer_with_buffer, buf, format, options)
907 }
908
909 EXPORT
910 fz_device * wasm_begin_page(fz_document_writer *wri, fz_rect *mediabox)
911 {
912 POINTER(fz_begin_page, wri, *mediabox)
913 }
914
915 EXPORT
916 void wasm_end_page(fz_document_writer *wri)
917 {
918 VOID(fz_end_page, wri)
919 }
920
921 EXPORT
922 void wasm_close_document_writer(fz_document_writer *wri)
923 {
924 VOID(fz_close_document_writer, wri)
925 }
926
927 // --- StructuredText ---
928
929 EXPORT
930 unsigned char * wasm_print_stext_page_as_json(fz_stext_page *page, float scale)
931 {
932 unsigned char *data = NULL;
933 TRY ({
934 fz_buffer *buf = fz_new_buffer(ctx, 1024);
935 fz_output *out = fz_new_output_with_buffer(ctx, buf);
936 fz_print_stext_page_as_json(ctx, out, page, scale);
937 fz_close_output(ctx, out);
938 fz_drop_output(ctx, out);
939 fz_terminate_buffer(ctx, buf);
940 fz_buffer_extract(ctx, buf, &data);
941 fz_drop_buffer(ctx, buf);
942 })
943 return data;
944 }
945
946 EXPORT
947 int wasm_search_stext_page(fz_stext_page *text, char *needle, int *marks, fz_quad *hits, int hit_max)
948 {
949 INTEGER(fz_search_stext_page, text, needle, marks, hits, hit_max)
950 }
951
952 EXPORT
953 fz_quad * wasm_snap_selection(fz_stext_page *text, fz_point *a, fz_point *b, int mode)
954 {
955 QUAD(fz_snap_selection, text, a, b, mode);
956 }
957
958 EXPORT
959 char * wasm_copy_selection(fz_stext_page *text, fz_point *a, fz_point *b)
960 {
961 POINTER(fz_copy_selection, text, *a, *b, 0);
962 }
963
964 EXPORT
965 int wasm_highlight_selection(fz_stext_page *text, fz_point *a, fz_point *b, fz_quad *hits, int n)
966 {
967 INTEGER(fz_highlight_selection, text, *a, *b, hits, n);
968 }
969
970 EXPORT
971 unsigned char * wasm_print_stext_page_as_html(fz_stext_page *page, int id)
972 {
973 unsigned char *data = NULL;
974 TRY ({
975 fz_buffer *buf = fz_new_buffer(ctx, 0);
976 fz_output *out = fz_new_output_with_buffer(ctx, buf);
977 fz_print_stext_page_as_html(ctx, out, page, id);
978 fz_close_output(ctx, out);
979 fz_drop_output(ctx, out);
980 fz_terminate_buffer(ctx, buf);
981 fz_buffer_extract(ctx, buf, &data);
982 })
983 return data;
984 }
985
986 EXPORT
987 unsigned char * wasm_print_stext_page_as_text(fz_stext_page *page)
988 {
989 unsigned char *data = NULL;
990 TRY ({
991 fz_buffer *buf = fz_new_buffer(ctx, 1024);
992 fz_output *out = fz_new_output_with_buffer(ctx, buf);
993 fz_print_stext_page_as_text(ctx, out, page);
994 fz_close_output(ctx, out);
995 fz_drop_output(ctx, out);
996 fz_terminate_buffer(ctx, buf);
997 fz_buffer_extract(ctx, buf, &data);
998 })
999 return data;
1000 }
1001
1002 // --- Document ---
1003
1004 EXPORT
1005 fz_document * wasm_open_document_with_buffer(char *magic, fz_buffer *buffer)
1006 {
1007 POINTER(fz_open_document_with_buffer, magic, buffer)
1008 }
1009
1010 EXPORT
1011 fz_document * wasm_open_document_with_stream(char *magic, fz_stream *stream)
1012 {
1013 POINTER(fz_open_document_with_stream, magic, stream)
1014 }
1015
1016 EXPORT
1017 char * wasm_format_link_uri(fz_document *doc, int ch, int pg, int ty, float x, float y, float w, float h, float z)
1018 {
1019 fz_link_dest dest = { ch, pg, ty, x, y, w, h, z };
1020 POINTER(fz_format_link_uri, doc, dest)
1021 }
1022
1023 EXPORT
1024 int wasm_needs_password(fz_document *doc)
1025 {
1026 INTEGER(fz_needs_password, doc)
1027 }
1028
1029 EXPORT
1030 int wasm_authenticate_password(fz_document *doc, char *password)
1031 {
1032 INTEGER(fz_authenticate_password, doc, password)
1033 }
1034
1035 EXPORT
1036 int wasm_has_permission(fz_document *doc, int perm)
1037 {
1038 INTEGER(fz_has_permission, doc, perm)
1039 }
1040
1041 EXPORT
1042 int wasm_count_pages(fz_document *doc)
1043 {
1044 INTEGER(fz_count_pages, doc)
1045 }
1046
1047 EXPORT
1048 fz_page * wasm_load_page(fz_document *doc, int number)
1049 {
1050 POINTER(fz_load_page, doc, number)
1051 }
1052
1053 EXPORT
1054 char * wasm_lookup_metadata(fz_document *doc, char *key)
1055 {
1056 static char buf[500];
1057 char *result = NULL;
1058 TRY ({
1059 if (fz_lookup_metadata(ctx, doc, key, buf, sizeof buf) > 0)
1060 result = buf;
1061 })
1062 return result;
1063 }
1064
1065 EXPORT
1066 void wasm_set_metadata(fz_document *doc, char *key, char *value)
1067 {
1068 VOID(fz_set_metadata, doc, key, value)
1069 }
1070
1071 EXPORT
1072 int wasm_resolve_link(fz_document *doc, const char *uri)
1073 {
1074 INTEGER(fz_page_number_from_location, doc, fz_resolve_link(ctx, doc, uri, NULL, NULL))
1075 }
1076
1077 EXPORT
1078 fz_link_dest * wasm_resolve_link_dest(fz_document *doc, const char *uri)
1079 {
1080 TRY({
1081 out_link_dest = fz_resolve_link_dest(ctx, doc, uri);
1082 })
1083 return &out_link_dest;
1084 }
1085
1086 EXPORT
1087 fz_outline * wasm_load_outline(fz_document *doc)
1088 {
1089 POINTER(fz_load_outline, doc)
1090 }
1091
1092 EXPORT
1093 int wasm_outline_get_page(fz_document *doc, fz_outline *outline)
1094 {
1095 INTEGER(fz_page_number_from_location, doc, outline->page)
1096 }
1097
1098 EXPORT
1099 void wasm_layout_document(fz_document *doc, float w, float h, float em)
1100 {
1101 VOID(fz_layout_document, doc, w, h, em)
1102 }
1103
1104 EXPORT
1105 boolean wasm_is_document_reflowable(fz_document *doc)
1106 {
1107 BOOLEAN(fz_is_document_reflowable, doc)
1108 }
1109
1110 // --- Link ---
1111
1112 EXPORT
1113 void wasm_link_set_rect(fz_link *link, fz_rect *rect)
1114 {
1115 VOID(fz_set_link_rect, link, *rect);
1116 }
1117
1118 EXPORT
1119 void wasm_link_set_uri(fz_link *link, char *uri)
1120 {
1121 VOID(fz_set_link_uri, link, uri);
1122 }
1123
1124 // --- Page ---
1125
1126 EXPORT
1127 fz_rect * wasm_bound_page(fz_page *page, int box_type)
1128 {
1129 RECT(fz_bound_page_box, page, box_type)
1130 }
1131
1132 EXPORT
1133 fz_link * wasm_load_links(fz_page *page)
1134 {
1135 POINTER(fz_load_links, page)
1136 }
1137
1138 EXPORT
1139 fz_link * wasm_create_link(fz_page *page, fz_rect *bbox, char *uri)
1140 {
1141 POINTER(fz_create_link, page, *bbox, uri)
1142 }
1143
1144 EXPORT
1145 void wasm_delete_link(fz_page *page, fz_link *link)
1146 {
1147 VOID(fz_delete_link, page, link)
1148 }
1149
1150 EXPORT
1151 void wasm_run_page(fz_page *page, fz_device *dev, fz_matrix *ctm)
1152 {
1153 VOID(fz_run_page, page, dev, *ctm, NULL)
1154 }
1155
1156 EXPORT
1157 void wasm_run_page_contents(fz_page *page, fz_device *dev, fz_matrix *ctm)
1158 {
1159 VOID(fz_run_page_contents, page, dev, *ctm, NULL)
1160 }
1161
1162 EXPORT
1163 void wasm_run_page_annots(fz_page *page, fz_device *dev, fz_matrix *ctm)
1164 {
1165 VOID(fz_run_page_annots, page, dev, *ctm, NULL)
1166 }
1167
1168 EXPORT
1169 void wasm_run_page_widgets(fz_page *page, fz_device *dev, fz_matrix *ctm)
1170 {
1171 VOID(fz_run_page_widgets, page, dev, *ctm, NULL)
1172 }
1173
1174 EXPORT
1175 fz_stext_page * wasm_new_stext_page_from_page(fz_page *page, char *option_string)
1176 {
1177 fz_stext_page *stext = NULL;
1178 fz_stext_options options;
1179 TRY({
1180 fz_parse_stext_options(ctx, &options, option_string);
1181 stext = fz_new_stext_page_from_page(ctx, page, &options);
1182 })
1183 return stext;
1184 }
1185
1186 EXPORT
1187 fz_display_list * wasm_new_display_list_from_page(fz_page *page)
1188 {
1189 POINTER(fz_new_display_list_from_page, page)
1190 }
1191
1192 EXPORT
1193 fz_display_list * wasm_new_display_list_from_page_contents(fz_page *page)
1194 {
1195 POINTER(fz_new_display_list_from_page_contents, page)
1196 }
1197
1198 EXPORT
1199 char * wasm_page_label(fz_page *page)
1200 {
1201 static char buf[100];
1202 POINTER(fz_page_label, page, buf, sizeof buf)
1203 }
1204
1205 EXPORT
1206 int wasm_search_page(fz_page *page, char *needle, int *marks, fz_quad *hits, int hit_max)
1207 {
1208 INTEGER(fz_search_page, page, needle, marks, hits, hit_max)
1209 }
1210
1211
1212 // --- DocumentIterator ---
1213
1214 EXPORT
1215 fz_outline_iterator * wasm_new_outline_iterator(fz_document *doc)
1216 {
1217 POINTER(fz_new_outline_iterator, doc)
1218 }
1219
1220 EXPORT
1221 int wasm_outline_iterator_next(fz_outline_iterator *iter)
1222 {
1223 INTEGER(fz_outline_iterator_next, iter)
1224 }
1225
1226 EXPORT
1227 int wasm_outline_iterator_prev(fz_outline_iterator *iter)
1228 {
1229 INTEGER(fz_outline_iterator_prev, iter)
1230 }
1231
1232 EXPORT
1233 int wasm_outline_iterator_up(fz_outline_iterator *iter)
1234 {
1235 INTEGER(fz_outline_iterator_up, iter)
1236 }
1237
1238 EXPORT
1239 int wasm_outline_iterator_down(fz_outline_iterator *iter)
1240 {
1241 INTEGER(fz_outline_iterator_down, iter)
1242 }
1243
1244 EXPORT
1245 int wasm_outline_iterator_delete(fz_outline_iterator *iter)
1246 {
1247 INTEGER(fz_outline_iterator_delete, iter)
1248 }
1249
1250 EXPORT
1251 fz_outline_item * wasm_outline_iterator_item(fz_outline_iterator *iter)
1252 {
1253 POINTER(fz_outline_iterator_item, iter)
1254 }
1255
1256 EXPORT
1257 int wasm_outline_iterator_insert(fz_outline_iterator *iter, char *title, char *uri, boolean is_open)
1258 {
1259 fz_outline_item item = { title, uri, is_open };
1260 INTEGER(fz_outline_iterator_insert, iter, &item)
1261 }
1262
1263 EXPORT
1264 void wasm_outline_iterator_update(fz_outline_iterator *iter, char *title, char *uri, boolean is_open)
1265 {
1266 fz_outline_item item = { title, uri, is_open };
1267 VOID(fz_outline_iterator_update, iter, &item)
1268 }
1269
1270 // --- PDFDocument --
1271
1272 EXPORT
1273 pdf_document * wasm_pdf_document_from_fz_document(fz_document *document)
1274 {
1275 return pdf_document_from_fz_document(ctx, document);
1276 }
1277
1278 EXPORT
1279 pdf_page * wasm_pdf_page_from_fz_page(fz_page *page)
1280 {
1281 return pdf_page_from_fz_page(ctx, page);
1282 }
1283
1284 EXPORT
1285 pdf_document * wasm_pdf_create_document(void)
1286 {
1287 POINTER(pdf_create_document)
1288 }
1289
1290 EXPORT
1291 int wasm_pdf_version(pdf_document *doc)
1292 {
1293 INTEGER(pdf_version, doc)
1294 }
1295
1296 EXPORT
1297 int wasm_pdf_was_repaired(pdf_document *doc)
1298 {
1299 INTEGER(pdf_was_repaired, doc)
1300 }
1301
1302 EXPORT
1303 int wasm_pdf_has_unsaved_changes(pdf_document *doc)
1304 {
1305 INTEGER(pdf_has_unsaved_changes, doc)
1306 }
1307
1308 EXPORT
1309 int wasm_pdf_can_be_saved_incrementally(pdf_document *doc)
1310 {
1311 INTEGER(pdf_can_be_saved_incrementally, doc)
1312 }
1313
1314 EXPORT
1315 int wasm_pdf_count_versions(pdf_document *doc)
1316 {
1317 INTEGER(pdf_count_versions, doc)
1318 }
1319
1320 EXPORT
1321 int wasm_pdf_count_unsaved_versions(pdf_document *doc)
1322 {
1323 INTEGER(pdf_count_unsaved_versions, doc)
1324 }
1325
1326 EXPORT
1327 int wasm_pdf_validate_change_history(pdf_document *doc)
1328 {
1329 INTEGER(pdf_validate_change_history, doc)
1330 }
1331
1332 EXPORT
1333 void wasm_pdf_enable_journal(pdf_document *doc)
1334 {
1335 VOID(pdf_enable_journal, doc)
1336 }
1337
1338 EXPORT
1339 int wasm_pdf_undoredo_state_position(pdf_document *doc)
1340 {
1341 int position, count;
1342 TRY ({
1343 position = pdf_undoredo_state(ctx, doc, &count);
1344 })
1345 return position;
1346 }
1347
1348 EXPORT
1349 int wasm_pdf_undoredo_state_count(pdf_document *doc)
1350 {
1351 int position, count;
1352 TRY ({
1353 position = pdf_undoredo_state(ctx, doc, &count);
1354 })
1355 return count;
1356 }
1357
1358 EXPORT
1359 char * wasm_pdf_undoredo_step(pdf_document *doc, int step)
1360 {
1361 POINTER(pdf_undoredo_step, doc, step)
1362 }
1363
1364 EXPORT
1365 void wasm_pdf_begin_operation(pdf_document *doc, char *op)
1366 {
1367 VOID(pdf_begin_operation, doc, op)
1368 }
1369
1370 EXPORT
1371 void wasm_pdf_begin_implicit_operation(pdf_document *doc)
1372 {
1373 VOID(pdf_begin_implicit_operation, doc)
1374 }
1375
1376 EXPORT
1377 void wasm_pdf_end_operation(pdf_document *doc)
1378 {
1379 VOID(pdf_end_operation, doc)
1380 }
1381
1382 EXPORT
1383 void wasm_pdf_abandon_operation(pdf_document *doc)
1384 {
1385 VOID(pdf_abandon_operation, doc)
1386 }
1387
1388 EXPORT
1389 void wasm_pdf_undo(pdf_document *doc)
1390 {
1391 VOID(pdf_undo, doc)
1392 }
1393
1394 EXPORT
1395 void wasm_pdf_redo(pdf_document *doc)
1396 {
1397 VOID(pdf_redo, doc)
1398 }
1399
1400 EXPORT
1401 int wasm_pdf_can_undo(pdf_document *doc)
1402 {
1403 INTEGER(pdf_can_undo, doc)
1404 }
1405
1406 EXPORT
1407 int wasm_pdf_can_redo(pdf_document *doc)
1408 {
1409 INTEGER(pdf_can_redo, doc)
1410 }
1411
1412 EXPORT
1413 char * wasm_pdf_document_language(pdf_document *doc)
1414 {
1415 static char str[8];
1416 TRY ({
1417 fz_string_from_text_language(str, pdf_document_language(ctx, doc));
1418 })
1419 return str;
1420 }
1421
1422 EXPORT
1423 void wasm_pdf_set_document_language(pdf_document *doc, char *str)
1424 {
1425 VOID(pdf_set_document_language, doc, fz_text_language_from_string(str))
1426 }
1427
1428 EXPORT
1429 pdf_obj * wasm_pdf_trailer(pdf_document *doc)
1430 {
1431 POINTER(pdf_trailer, doc)
1432 }
1433
1434 EXPORT
1435 int wasm_pdf_xref_len(pdf_document *doc)
1436 {
1437 INTEGER(pdf_xref_len, doc)
1438 }
1439
1440 EXPORT
1441 pdf_obj * wasm_pdf_lookup_page_obj(pdf_document *doc, int index)
1442 {
1443 POINTER(pdf_lookup_page_obj, doc, index)
1444 }
1445
1446 EXPORT
1447 pdf_obj * wasm_pdf_add_object(pdf_document *doc, pdf_obj *obj)
1448 {
1449 POINTER(pdf_add_object, doc, obj)
1450 }
1451
1452 EXPORT
1453 int wasm_pdf_create_object(pdf_document *doc)
1454 {
1455 INTEGER(pdf_create_object, doc)
1456 }
1457
1458 EXPORT
1459 void wasm_pdf_delete_object(pdf_document *doc, int num)
1460 {
1461 VOID(pdf_delete_object, doc, num)
1462 }
1463
1464 EXPORT
1465 pdf_obj * wasm_pdf_add_stream(pdf_document *doc, fz_buffer *buf, pdf_obj *obj, int compress)
1466 {
1467 POINTER(pdf_add_stream, doc, buf, obj, compress)
1468 }
1469
1470 EXPORT
1471 pdf_obj * wasm_pdf_add_simple_font(pdf_document *doc, fz_font *font, int encoding)
1472 {
1473 POINTER(pdf_add_simple_font, doc, font, encoding)
1474 }
1475
1476 EXPORT
1477 pdf_obj * wasm_pdf_add_cjk_font(pdf_document *doc, fz_font *font, int ordering, int wmode, boolean serif)
1478 {
1479 POINTER(pdf_add_cjk_font, doc, font, ordering, wmode, serif)
1480 }
1481
1482 EXPORT
1483 pdf_obj * wasm_pdf_add_cid_font(pdf_document *doc, fz_font *font)
1484 {
1485 POINTER(pdf_add_cid_font, doc, font)
1486 }
1487
1488 EXPORT
1489 pdf_obj * wasm_pdf_add_image(pdf_document *doc, fz_image *image)
1490 {
1491 POINTER(pdf_add_image, doc, image)
1492 }
1493
1494 EXPORT
1495 fz_image * wasm_pdf_load_image(pdf_document *doc, pdf_obj *ref)
1496 {
1497 POINTER(pdf_load_image, doc, ref)
1498 }
1499
1500 EXPORT
1501 void wasm_pdf_set_page_tree_cache(pdf_document *doc, boolean enabled)
1502 {
1503 VOID(pdf_set_page_tree_cache, doc, enabled);
1504 }
1505
1506 EXPORT
1507 pdf_obj * wasm_pdf_add_page(pdf_document *doc, fz_rect *mediabox, int rotate, pdf_obj *resources, fz_buffer *contents)
1508 {
1509 POINTER(pdf_add_page, doc, *mediabox, rotate, resources, contents)
1510 }
1511
1512 EXPORT
1513 void wasm_pdf_insert_page(pdf_document *doc, int index, pdf_obj *obj)
1514 {
1515 VOID(pdf_insert_page, doc, index, obj)
1516 }
1517
1518 EXPORT
1519 void wasm_pdf_delete_page(pdf_document *doc, int index)
1520 {
1521 VOID(pdf_delete_page, doc, index)
1522 }
1523
1524 EXPORT
1525 void wasm_pdf_set_page_labels(pdf_document *doc, int index, int style, char *prefix, int start)
1526 {
1527 VOID(pdf_set_page_labels, doc, index, style, prefix, start)
1528 }
1529
1530 EXPORT
1531 void wasm_pdf_delete_page_labels(pdf_document *doc, int index)
1532 {
1533 VOID(pdf_delete_page_labels, doc, index)
1534 }
1535
1536 EXPORT
1537 int wasm_pdf_is_embedded_file(pdf_obj *ref)
1538 {
1539 INTEGER(pdf_is_embedded_file, ref)
1540 }
1541
1542 EXPORT
1543 pdf_filespec_params * wasm_pdf_get_filespec_params(pdf_obj *ref)
1544 {
1545 static pdf_filespec_params out;
1546 TRY ({
1547 pdf_get_filespec_params(ctx, ref, &out);
1548 })
1549 return &out;
1550 }
1551
1552 EXPORT
1553 pdf_obj * wasm_pdf_add_embedded_file(pdf_document *doc, char *filename, char *mimetype, fz_buffer *contents, int created, int modified, boolean checksum)
1554 {
1555 POINTER(pdf_add_embedded_file, doc, filename, mimetype, contents, created, modified, checksum)
1556 }
1557
1558 EXPORT
1559 fz_buffer * wasm_pdf_load_embedded_file_contents(pdf_obj *fs)
1560 {
1561 POINTER(pdf_load_embedded_file_contents, fs)
1562 }
1563
1564 EXPORT
1565 fz_buffer * wasm_pdf_write_document_buffer(pdf_document *doc, char *options)
1566 {
1567 fz_buffer *buffer;
1568 fz_output *output;
1569 pdf_write_options pwo;
1570 TRY ({
1571 buffer = fz_new_buffer(ctx, 32 << 10);
1572 output = fz_new_output_with_buffer(ctx, buffer);
1573 pdf_parse_write_options(ctx, &pwo, options);
1574 pdf_write_document(ctx, doc, output, &pwo);
1575 fz_close_output(ctx, output);
1576 fz_drop_output(ctx, output);
1577 })
1578 return buffer;
1579 }
1580
1581 EXPORT
1582 int wasm_pdf_js_supported(pdf_document *doc)
1583 {
1584 NUMBER(pdf_js_supported, doc)
1585 }
1586
1587 EXPORT
1588 void wasm_pdf_enable_js(pdf_document *doc)
1589 {
1590 VOID(pdf_enable_js, doc)
1591 }
1592
1593 EXPORT
1594 void wasm_pdf_disable_js(pdf_document *doc)
1595 {
1596 VOID(pdf_disable_js, doc)
1597 }
1598
1599 EXPORT
1600 void wasm_pdf_rearrange_pages(pdf_document *doc, int n, int *pages)
1601 {
1602 VOID(pdf_rearrange_pages, doc, n, pages, PDF_CLEAN_STRUCTURE_DROP)
1603 }
1604
1605 EXPORT
1606 void wasm_pdf_subset_fonts(pdf_document *doc)
1607 {
1608 VOID(pdf_subset_fonts, doc, 0, NULL);
1609 }
1610
1611 EXPORT
1612 void wasm_pdf_bake_document(pdf_document *doc, boolean bake_annots, boolean bake_widgets)
1613 {
1614 VOID(pdf_bake_document, doc, bake_annots, bake_widgets)
1615 }
1616
1617 EXPORT
1618 int wasm_pdf_count_layer_configs(pdf_document *doc)
1619 {
1620 INTEGER(pdf_count_layer_configs, doc)
1621 }
1622
1623 EXPORT
1624 const char * wasm_pdf_layer_config_creator(pdf_document *doc, int config)
1625 {
1626 POINTER(pdf_layer_config_creator, doc, config)
1627 }
1628
1629 EXPORT
1630 const char * wasm_pdf_layer_config_name(pdf_document *doc, int config)
1631 {
1632 POINTER(pdf_layer_config_name, doc, config)
1633 }
1634
1635 EXPORT
1636 void wasm_pdf_select_layer_config(pdf_document *doc, int config)
1637 {
1638 VOID(pdf_select_layer_config, doc, config)
1639 }
1640
1641 EXPORT
1642 int wasm_pdf_count_layer_config_uis(pdf_document *doc)
1643 {
1644 INTEGER(pdf_count_layer_config_ui, doc)
1645 }
1646
1647 EXPORT
1648 pdf_layer_config_ui *wasm_pdf_layer_config_ui_info(pdf_document *doc, int configui)
1649 {
1650 TRY ({
1651 pdf_layer_config_ui_info(ctx, doc, configui, &out_layer_config_ui);
1652 })
1653 return &out_layer_config_ui;
1654 }
1655
1656 EXPORT
1657 int wasm_pdf_count_layers(pdf_document *doc)
1658 {
1659 INTEGER(pdf_count_layers, doc)
1660 }
1661
1662 EXPORT
1663 const char * wasm_pdf_layer_name(pdf_document *doc, int layer)
1664 {
1665 POINTER(pdf_layer_name, doc, layer)
1666 }
1667
1668 EXPORT
1669 int wasm_pdf_layer_is_enabled(pdf_document *doc, int layer)
1670 {
1671 INTEGER(pdf_layer_is_enabled, doc, layer)
1672 }
1673
1674 EXPORT
1675 void wasm_pdf_enable_layer(pdf_document *doc, int layer, int state)
1676 {
1677 VOID(pdf_enable_layer, doc, layer, state)
1678 }
1679
1680 // --- PDFPage ---
1681
1682 EXPORT
1683 fz_matrix * wasm_pdf_page_transform(pdf_page *page)
1684 {
1685 TRY ({
1686 pdf_page_transform(ctx, page, NULL, &out_matrix);
1687 })
1688 return &out_matrix;
1689 }
1690
1691 EXPORT
1692 void wasm_pdf_set_page_box(pdf_page *page, int which, fz_rect *rect)
1693 {
1694 VOID(pdf_set_page_box, page, which, *rect)
1695 }
1696
1697 EXPORT
1698 pdf_annot * wasm_pdf_first_annot(pdf_page *page)
1699 {
1700 POINTER(pdf_first_annot, page)
1701 }
1702
1703 EXPORT
1704 pdf_annot * wasm_pdf_next_annot(pdf_annot *annot)
1705 {
1706 POINTER(pdf_next_annot, annot)
1707 }
1708
1709 EXPORT
1710 pdf_annot * wasm_pdf_first_widget(pdf_page *page)
1711 {
1712 POINTER(pdf_first_widget, page)
1713 }
1714
1715 EXPORT
1716 pdf_annot * wasm_pdf_next_widget(pdf_annot *annot)
1717 {
1718 POINTER(pdf_next_widget, annot)
1719 }
1720
1721 EXPORT
1722 pdf_annot * wasm_pdf_create_annot(pdf_page *page, int type)
1723 {
1724 POINTER(pdf_create_annot, page, type)
1725 }
1726
1727 EXPORT
1728 void wasm_pdf_delete_annot(pdf_page *page, pdf_annot *annot)
1729 {
1730 VOID(pdf_delete_annot, page, annot)
1731 }
1732
1733 EXPORT
1734 int wasm_pdf_update_page(pdf_page *page)
1735 {
1736 INTEGER(pdf_update_page, page)
1737 }
1738
1739 EXPORT
1740 void wasm_pdf_redact_page(pdf_page *page, int black_boxes, int image_method, int line_art_method, int text_method)
1741 {
1742 pdf_redact_options opts = { black_boxes, image_method, line_art_method, text_method };
1743 VOID(pdf_redact_page, page->doc, page, &opts)
1744 }
1745
1746 // --- PDFGraftMap ---
1747
1748 EXPORT
1749 pdf_graft_map * wasm_pdf_new_graft_map(pdf_document *doc)
1750 {
1751 POINTER(pdf_new_graft_map, doc)
1752 }
1753
1754 EXPORT
1755 pdf_obj * wasm_pdf_graft_mapped_object(pdf_graft_map *map, pdf_obj *obj)
1756 {
1757 POINTER(pdf_graft_mapped_object, map, obj)
1758 }
1759
1760 EXPORT
1761 pdf_obj * wasm_pdf_graft_object(pdf_document *dst, pdf_obj *obj)
1762 {
1763 POINTER(pdf_graft_object, dst, obj)
1764 }
1765
1766 EXPORT
1767 void wasm_pdf_graft_mapped_page(pdf_graft_map *map, int to, pdf_document *src, int from)
1768 {
1769 VOID(pdf_graft_mapped_page, map, to, src, from)
1770 }
1771
1772 EXPORT
1773 void wasm_pdf_graft_page(pdf_document *dst, int to, pdf_document *src, int from)
1774 {
1775 VOID(pdf_graft_page, dst, to, src, from)
1776 }
1777
1778 // --- PDFAnnotation ---
1779
1780 EXPORT
1781 fz_rect * wasm_pdf_bound_annot(pdf_annot *annot)
1782 {
1783 RECT(pdf_bound_annot, annot)
1784 }
1785
1786 EXPORT
1787 void wasm_pdf_run_annot(pdf_annot *annot, fz_device *dev, fz_matrix *ctm)
1788 {
1789 VOID(pdf_run_annot, annot, dev, *ctm, NULL)
1790 }
1791
1792 EXPORT
1793 fz_pixmap * wasm_pdf_new_pixmap_from_annot(pdf_annot *annot, fz_matrix *ctm, fz_colorspace *colorspace, boolean alpha)
1794 {
1795 POINTER(pdf_new_pixmap_from_annot, annot, *ctm, colorspace, NULL, alpha)
1796 }
1797
1798 EXPORT
1799 fz_display_list * wasm_pdf_new_display_list_from_annot(pdf_annot *annot)
1800 {
1801 POINTER(pdf_new_display_list_from_annot, annot)
1802 }
1803
1804 EXPORT
1805 int wasm_pdf_update_annot(pdf_annot *annot)
1806 {
1807 INTEGER(pdf_update_annot, annot)
1808 }
1809
1810 #define PDF_ANNOT_GET(T,R,N) EXPORT T wasm_pdf_annot_ ## N(pdf_annot *annot) { R(pdf_annot_ ## N, annot) }
1811 #define PDF_ANNOT_GET1(T,R,N) EXPORT T wasm_pdf_annot_ ## N(pdf_annot *annot, int idx) { R(pdf_annot_ ## N, annot, idx) }
1812 #define PDF_ANNOT_GET2(T,R,N) EXPORT T wasm_pdf_annot_ ## N(pdf_annot *annot, int a, int b) { R(pdf_annot_ ## N, annot, a, b) }
1813 #define PDF_ANNOT_SET(T,N) EXPORT void wasm_pdf_set_annot_ ## N(pdf_annot *annot, T v) { VOID(pdf_set_annot_ ## N, annot, v) }
1814 #define PDF_ANNOT_GETSET(T,R,N) PDF_ANNOT_GET(T,R,N) PDF_ANNOT_SET(T,N)
1815 #define PDF_ANNOT_HAS(N) EXPORT int wasm_pdf_annot_has_ ## N(pdf_annot *annot) { INTEGER(pdf_annot_has_ ## N, annot) }
1816
1817 PDF_ANNOT_GET(pdf_obj*, POINTER, obj)
1818 PDF_ANNOT_GET(int, INTEGER, type)
1819
1820 PDF_ANNOT_GETSET(int, INTEGER, flags)
1821 PDF_ANNOT_GETSET(char*, POINTER, contents)
1822 PDF_ANNOT_GETSET(char*, POINTER, author)
1823 PDF_ANNOT_GETSET(int, INTEGER, creation_date)
1824 PDF_ANNOT_GETSET(int, INTEGER, modification_date)
1825 PDF_ANNOT_GETSET(float, NUMBER, border_width)
1826 PDF_ANNOT_GETSET(int, INTEGER, border_style)
1827 PDF_ANNOT_GETSET(int, INTEGER, border_effect)
1828 PDF_ANNOT_GETSET(float, NUMBER, border_effect_intensity)
1829 PDF_ANNOT_GETSET(float, NUMBER, opacity)
1830 PDF_ANNOT_GETSET(pdf_obj*, POINTER, filespec)
1831 PDF_ANNOT_GETSET(int, INTEGER, quadding)
1832 PDF_ANNOT_GETSET(boolean, BOOLEAN, is_open)
1833 PDF_ANNOT_GETSET(boolean, BOOLEAN, hidden_for_editing)
1834 PDF_ANNOT_GETSET(char*, POINTER, icon_name)
1835 PDF_ANNOT_GETSET(int, INTEGER, intent)
1836 PDF_ANNOT_GETSET(int, INTEGER, callout_style)
1837 PDF_ANNOT_GETSET(float, NUMBER, line_leader)
1838 PDF_ANNOT_GETSET(float, NUMBER, line_leader_extension)
1839 PDF_ANNOT_GETSET(float, NUMBER, line_leader_offset)
1840 PDF_ANNOT_GETSET(boolean, BOOLEAN, line_caption)
1841 PDF_ANNOT_GETSET(char*, POINTER, rich_defaults)
1842
1843 PDF_ANNOT_GET(fz_point*, POINT, callout_point)
1844 PDF_ANNOT_GET(fz_point*, POINT, line_caption_offset)
1845
1846 PDF_ANNOT_GET(fz_rect*, RECT, rect)
1847 PDF_ANNOT_GET(fz_rect*, RECT, popup)
1848
1849 PDF_ANNOT_GET(int, INTEGER, quad_point_count)
1850 PDF_ANNOT_GET1(fz_quad*, QUAD, quad_point)
1851
1852 PDF_ANNOT_GET(int, INTEGER, vertex_count)
1853 PDF_ANNOT_GET1(fz_point*, POINT, vertex)
1854
1855 PDF_ANNOT_GET(int, INTEGER, ink_list_count)
1856 PDF_ANNOT_GET1(int, INTEGER, ink_list_stroke_count)
1857 PDF_ANNOT_GET2(fz_point*, POINT, ink_list_stroke_vertex)
1858
1859 PDF_ANNOT_GET(char*, POINTER, rich_contents)
1860
1861 PDF_ANNOT_GET(int, INTEGER, border_dash_count)
1862 PDF_ANNOT_GET1(float, NUMBER, border_dash_item)
1863
1864 PDF_ANNOT_HAS(rect)
1865 PDF_ANNOT_HAS(ink_list)
1866 PDF_ANNOT_HAS(quad_points)
1867 PDF_ANNOT_HAS(vertices)
1868 PDF_ANNOT_HAS(line)
1869 PDF_ANNOT_HAS(interior_color)
1870 PDF_ANNOT_HAS(line_ending_styles)
1871 PDF_ANNOT_HAS(border)
1872 PDF_ANNOT_HAS(border_effect)
1873 PDF_ANNOT_HAS(icon_name)
1874 PDF_ANNOT_HAS(open)
1875 PDF_ANNOT_HAS(author)
1876 PDF_ANNOT_HAS(filespec)
1877 PDF_ANNOT_HAS(callout)
1878 PDF_ANNOT_HAS(rich_contents)
1879
1880 EXPORT
1881 char * wasm_pdf_annot_language(pdf_annot *annot)
1882 {
1883 static char str[8];
1884 TRY ({
1885 fz_string_from_text_language(str, pdf_annot_language(ctx, annot));
1886 })
1887 return str;
1888 }
1889
1890 EXPORT
1891 void wasm_pdf_set_annot_language(pdf_annot *annot, char *str)
1892 {
1893 VOID(pdf_set_annot_language, annot, fz_text_language_from_string(str))
1894 }
1895
1896 EXPORT
1897 void wasm_pdf_set_annot_popup(pdf_annot *annot, fz_rect *rect)
1898 {
1899 VOID(pdf_set_annot_popup, annot, *rect)
1900 }
1901
1902 EXPORT
1903 void wasm_pdf_set_annot_rect(pdf_annot *annot, fz_rect *rect)
1904 {
1905 VOID(pdf_set_annot_rect, annot, *rect)
1906 }
1907
1908 EXPORT
1909 void wasm_pdf_clear_annot_quad_points(pdf_annot *annot)
1910 {
1911 VOID(pdf_clear_annot_quad_points, annot)
1912 }
1913
1914 EXPORT
1915 void wasm_pdf_clear_annot_vertices(pdf_annot *annot)
1916 {
1917 VOID(pdf_clear_annot_vertices, annot)
1918 }
1919
1920 EXPORT
1921 void wasm_pdf_clear_annot_ink_list(pdf_annot *annot)
1922 {
1923 VOID(pdf_clear_annot_ink_list, annot)
1924 }
1925
1926 EXPORT
1927 void wasm_pdf_clear_annot_border_dash(pdf_annot *annot)
1928 {
1929 VOID(pdf_clear_annot_border_dash, annot)
1930 }
1931
1932 EXPORT
1933 void wasm_pdf_add_annot_quad_point(pdf_annot *annot, fz_quad *quad)
1934 {
1935 VOID(pdf_add_annot_quad_point, annot, *quad)
1936 }
1937
1938 EXPORT
1939 void wasm_pdf_add_annot_vertex(pdf_annot *annot, fz_point *point)
1940 {
1941 VOID(pdf_add_annot_vertex, annot, *point)
1942 }
1943
1944 EXPORT
1945 void wasm_pdf_add_annot_ink_list_stroke(pdf_annot *annot)
1946 {
1947 VOID(pdf_add_annot_ink_list_stroke, annot)
1948 }
1949
1950 EXPORT
1951 void wasm_pdf_add_annot_ink_list_stroke_vertex(pdf_annot *annot, fz_point *point)
1952 {
1953 VOID(pdf_add_annot_ink_list_stroke_vertex, annot, *point)
1954 }
1955
1956 EXPORT
1957 void wasm_pdf_add_annot_border_dash_item(pdf_annot *annot, float v)
1958 {
1959 VOID(pdf_add_annot_border_dash_item, annot, v)
1960 }
1961
1962 EXPORT
1963 int wasm_pdf_annot_line_ending_styles_start(pdf_annot *annot)
1964 {
1965 enum pdf_line_ending start;
1966 enum pdf_line_ending end;
1967 TRY ({
1968 pdf_annot_line_ending_styles(ctx, annot, &start, &end);
1969 })
1970 return start;
1971 }
1972
1973 EXPORT
1974 fz_point * wasm_pdf_annot_line_1(pdf_annot *annot)
1975 {
1976 fz_point tmp;
1977 TRY ({
1978 pdf_annot_line(ctx, annot, &out_point, &tmp);
1979 })
1980 return &out_point;
1981 }
1982
1983 EXPORT
1984 fz_point * wasm_pdf_annot_line_2(pdf_annot *annot)
1985 {
1986 fz_point tmp;
1987 TRY ({
1988 pdf_annot_line(ctx, annot, &tmp, &out_point);
1989 })
1990 return &out_point;
1991 }
1992
1993 EXPORT
1994 void wasm_pdf_set_annot_line(pdf_annot *annot, fz_point *a, fz_point *b)
1995 {
1996 VOID(pdf_set_annot_line, annot, *a, *b)
1997 }
1998
1999 EXPORT
2000 void wasm_pdf_set_annot_callout_point(pdf_annot *annot, fz_point *point)
2001 {
2002 VOID(pdf_set_annot_callout_point, annot, *point)
2003 }
2004
2005 EXPORT
2006 int wasm_pdf_annot_callout_line(pdf_annot *annot, fz_point *line)
2007 {
2008 int n = 0;
2009 TRY ({
2010 pdf_annot_callout_line(ctx, annot, line, &n);
2011 })
2012 return n;
2013 }
2014
2015 EXPORT
2016 void wasm_pdf_set_annot_callout_line(pdf_annot *annot, int n, fz_point *a, fz_point *b, fz_point *c)
2017 {
2018 fz_point line[3] = { {0,0}, {0,0}, {0,0} };
2019 if (a) line[0] = *a;
2020 if (b) line[1] = *b;
2021 if (c) line[2] = *c;
2022 VOID(pdf_set_annot_callout_line, annot, line, n)
2023 }
2024
2025 EXPORT
2026 void wasm_pdf_set_annot_line_caption_offset(pdf_annot *annot, fz_point *point)
2027 {
2028 VOID(pdf_set_annot_line_caption_offset, annot, *point)
2029 }
2030
2031 EXPORT
2032 int wasm_pdf_annot_line_ending_styles_end(pdf_annot *annot)
2033 {
2034 enum pdf_line_ending start;
2035 enum pdf_line_ending end;
2036 TRY ({
2037 pdf_annot_line_ending_styles(ctx, annot, &start, &end);
2038 })
2039 return end;
2040 }
2041
2042 EXPORT
2043 void wasm_pdf_set_annot_line_ending_styles(pdf_annot *annot, int start, int end)
2044 {
2045 VOID(pdf_set_annot_line_ending_styles, annot, start, end)
2046 }
2047
2048 EXPORT
2049 int wasm_pdf_annot_color(pdf_annot *annot, float *color)
2050 {
2051 int n;
2052 TRY ({
2053 pdf_annot_color(ctx, annot, &n, color);
2054 })
2055 return n;
2056 }
2057
2058 EXPORT
2059 int wasm_pdf_annot_interior_color(pdf_annot *annot, float *color)
2060 {
2061 int n;
2062 TRY ({
2063 pdf_annot_interior_color(ctx, annot, &n, color);
2064 })
2065 return n;
2066 }
2067
2068 EXPORT
2069 void wasm_pdf_set_annot_color(pdf_annot *annot, int n, float *color)
2070 {
2071 VOID(pdf_set_annot_color, annot, n, color);
2072 }
2073
2074 EXPORT
2075 void wasm_pdf_set_annot_interior_color(pdf_annot *annot, int n, float *color)
2076 {
2077 VOID(pdf_set_annot_interior_color, annot, n, color);
2078 }
2079
2080 EXPORT
2081 void wasm_pdf_set_annot_default_appearance(pdf_annot *annot, char *font, float size, int ncolor, float *color)
2082 {
2083 VOID(pdf_set_annot_default_appearance, annot, font, size, ncolor, color)
2084 }
2085
2086 EXPORT
2087 const char * wasm_pdf_annot_default_appearance_font(pdf_annot *annot)
2088 {
2089 const char *font;
2090 float size, color[4];
2091 int n;
2092 TRY({
2093 pdf_annot_default_appearance(ctx, annot, &font, &size, &n, color);
2094 })
2095 return font;
2096 }
2097
2098 EXPORT
2099 float wasm_pdf_annot_default_appearance_size(pdf_annot *annot)
2100 {
2101 const char *font;
2102 float size, color[4];
2103 int n;
2104 TRY({
2105 pdf_annot_default_appearance(ctx, annot, &font, &size, &n, color);
2106 })
2107 return size;
2108 }
2109
2110 EXPORT
2111 int wasm_pdf_annot_default_appearance_color(pdf_annot *annot, float *color)
2112 {
2113 const char *font;
2114 float size;
2115 int n;
2116 TRY({
2117 pdf_annot_default_appearance(ctx, annot, &font, &size, &n, color);
2118 })
2119 return n;
2120 }
2121
2122 EXPORT
2123 void wasm_pdf_set_annot_rich_contents(pdf_annot *annot, char *plain, char *rich)
2124 {
2125 VOID(pdf_set_annot_rich_contents, annot, plain, rich)
2126 }
2127
2128 EXPORT
2129 void wasm_pdf_set_annot_stamp_image(pdf_annot *annot, fz_image *img)
2130 {
2131 VOID(pdf_set_annot_stamp_image, annot, img)
2132 }
2133
2134 EXPORT
2135 void wasm_pdf_set_annot_appearance_from_display_list(pdf_annot *annot, char *appearance, char *state, fz_matrix *ctm, fz_display_list *list)
2136 {
2137 VOID(pdf_set_annot_appearance_from_display_list, annot, appearance, state, *ctm, list)
2138 }
2139
2140 EXPORT
2141 void wasm_pdf_set_annot_appearance(pdf_annot *annot, char *appearance, char *state, fz_matrix *ctm, fz_rect *bbox, pdf_obj *resources, fz_buffer *contents)
2142 {
2143 VOID(pdf_set_annot_appearance, annot, appearance, state, *ctm, *bbox, resources, contents)
2144 }
2145
2146 EXPORT
2147 void wasm_pdf_apply_redaction(pdf_annot *annot, int black_boxes, int image_method, int line_art_method, int text_method)
2148 {
2149 pdf_redact_options opts = { black_boxes, image_method, line_art_method, text_method };
2150 VOID(pdf_apply_redaction, annot, &opts)
2151 }
2152
2153 // --- PDFWidget ---
2154
2155 EXPORT
2156 void wasm_pdf_reset_form(pdf_document *doc, pdf_obj *fields, int exclude)
2157 {
2158 VOID(pdf_reset_form, doc, fields, exclude)
2159 }
2160
2161 EXPORT
2162 int wasm_pdf_annot_field_type(pdf_annot *widget)
2163 {
2164 INTEGER(pdf_field_type, pdf_annot_obj(ctx, widget))
2165 }
2166
2167 EXPORT
2168 int wasm_pdf_annot_field_flags(pdf_annot *widget)
2169 {
2170 INTEGER(pdf_field_flags, pdf_annot_obj(ctx, widget))
2171 }
2172
2173 PDF_ANNOT_GET(char*, POINTER, field_label)
2174 PDF_ANNOT_GET(char*, POINTER, field_value)
2175
2176 EXPORT
2177 char * wasm_pdf_load_field_name(pdf_annot *widget)
2178 {
2179 POINTER(pdf_load_field_name, pdf_annot_obj(ctx, widget))
2180 }
2181
2182 EXPORT
2183 int wasm_pdf_annot_text_widget_max_len(pdf_annot *widget)
2184 {
2185 INTEGER(pdf_text_widget_max_len, widget)
2186 }
2187
2188 EXPORT
2189 int wasm_pdf_set_annot_text_field_value(pdf_annot *widget, char *value)
2190 {
2191 INTEGER(pdf_set_text_field_value, widget, value)
2192 }
2193
2194 EXPORT
2195 int wasm_pdf_set_annot_choice_field_value(pdf_annot *widget, char *value)
2196 {
2197 INTEGER(pdf_set_choice_field_value, widget, value)
2198 }
2199
2200 EXPORT
2201 int wasm_pdf_annot_choice_field_option_count(pdf_annot *widget)
2202 {
2203 INTEGER(pdf_choice_field_option_count, pdf_annot_obj(ctx, widget))
2204 }
2205
2206 EXPORT
2207 char * wasm_pdf_annot_choice_field_option(pdf_annot *widget, boolean is_export, int i)
2208 {
2209 POINTER(pdf_choice_field_option, pdf_annot_obj(ctx, widget), is_export, i)
2210 }
2211
2212 EXPORT
2213 int wasm_pdf_toggle_widget(pdf_annot *widget)
2214 {
2215 INTEGER(pdf_toggle_widget, widget)
2216 }
2217
2218 // --- PDFObject ---
2219
2220 #define PDF_IS(N) EXPORT int wasm_pdf_is_ ## N(pdf_obj *obj) { INTEGER(pdf_is_ ## N, obj) }
2221 #define PDF_TO(T,R,N) EXPORT T wasm_pdf_to_ ## N(pdf_obj *obj) { R(pdf_to_ ## N, obj) }
2222 #define PDF_NEW(N,T) EXPORT pdf_obj* wasm_pdf_new_ ## N(pdf_document *doc, T v) { POINTER(pdf_new_ ## N, doc, v) }
2223 #define PDF_NEW2(N,T1,T2) EXPORT pdf_obj* wasm_pdf_new_ ## N(pdf_document *doc, T1 v1, T2 v2) { POINTER(pdf_new_ ## N, doc, v1, v2) }
2224
2225 PDF_IS(indirect)
2226 PDF_IS(bool)
2227 PDF_IS(int)
2228 PDF_IS(real)
2229 PDF_IS(number)
2230 PDF_IS(name)
2231 PDF_IS(string)
2232
2233 PDF_IS(array)
2234 PDF_IS(dict)
2235 PDF_IS(stream)
2236
2237 PDF_TO(int, INTEGER, num)
2238 PDF_TO(int, INTEGER, bool)
2239 PDF_TO(double, NUMBER, real)
2240 PDF_TO(char*, POINTER, name)
2241 PDF_TO(char*, POINTER, text_string)
2242
2243 EXPORT
2244 pdf_obj * wasm_pdf_new_indirect(pdf_document *doc, int num)
2245 {
2246 POINTER(pdf_new_indirect, doc, num, 0)
2247 }
2248
2249 EXPORT
2250 pdf_obj * wasm_pdf_new_array(pdf_document *doc)
2251 {
2252 POINTER(pdf_new_array, doc, 0)
2253 }
2254
2255 EXPORT
2256 pdf_obj * wasm_pdf_new_dict(pdf_document *doc)
2257 {
2258 POINTER(pdf_new_dict, doc, 0)
2259 }
2260
2261 EXPORT
2262 pdf_obj * wasm_pdf_new_bool(boolean v)
2263 {
2264 return v ? PDF_TRUE : PDF_FALSE;
2265 }
2266
2267 EXPORT
2268 pdf_obj * wasm_pdf_new_int(int v)
2269 {
2270 POINTER(pdf_new_int, v)
2271 }
2272
2273 EXPORT
2274 pdf_obj * wasm_pdf_new_real(float v)
2275 {
2276 POINTER(pdf_new_real, v)
2277 }
2278
2279 EXPORT
2280 pdf_obj * wasm_pdf_new_name(char *v)
2281 {
2282 POINTER(pdf_new_name, v)
2283 }
2284
2285 EXPORT
2286 pdf_obj * wasm_pdf_new_text_string(char *v)
2287 {
2288 POINTER(pdf_new_text_string, v)
2289 }
2290
2291 EXPORT
2292 pdf_obj * wasm_pdf_new_string(char *ptr, int len)
2293 {
2294 POINTER(pdf_new_string, ptr, len)
2295 }
2296
2297 EXPORT
2298 pdf_obj * wasm_pdf_resolve_indirect(pdf_obj *obj)
2299 {
2300 POINTER(pdf_resolve_indirect, obj)
2301 }
2302
2303 EXPORT
2304 pdf_obj * wasm_pdf_array_len(pdf_obj *obj)
2305 {
2306 POINTER(pdf_array_len, obj)
2307 }
2308
2309 EXPORT
2310 pdf_obj * wasm_pdf_array_get(pdf_obj *obj, int idx)
2311 {
2312 POINTER(pdf_array_get, obj, idx)
2313 }
2314
2315 EXPORT
2316 pdf_obj * wasm_pdf_dict_get(pdf_obj *obj, pdf_obj *key)
2317 {
2318 POINTER(pdf_dict_get, obj, key)
2319 }
2320
2321 EXPORT
2322 pdf_obj * wasm_pdf_dict_len(pdf_obj *obj)
2323 {
2324 POINTER(pdf_dict_len, obj)
2325 }
2326
2327 EXPORT
2328 pdf_obj * wasm_pdf_dict_get_key(pdf_obj *obj, int idx)
2329 {
2330 POINTER(pdf_dict_get_key, obj, idx)
2331 }
2332
2333 EXPORT
2334 pdf_obj * wasm_pdf_dict_get_val(pdf_obj *obj, int idx)
2335 {
2336 POINTER(pdf_dict_get_val, obj, idx)
2337 }
2338
2339 EXPORT
2340 pdf_obj * wasm_pdf_dict_get_inheritable(pdf_obj *obj, pdf_obj *key)
2341 {
2342 POINTER(pdf_dict_get_inheritable, obj, key)
2343 }
2344
2345 EXPORT
2346 pdf_obj * wasm_pdf_dict_gets(pdf_obj *obj, char *key)
2347 {
2348 POINTER(pdf_dict_gets, obj, key)
2349 }
2350
2351 EXPORT
2352 pdf_obj * wasm_pdf_dict_gets_inheritable(pdf_obj *obj, char *key)
2353 {
2354 POINTER(pdf_dict_gets_inheritable, obj, key)
2355 }
2356
2357 EXPORT
2358 void wasm_pdf_dict_put(pdf_obj *obj, pdf_obj *key, pdf_obj *val)
2359 {
2360 VOID(pdf_dict_put, obj, key, val)
2361 }
2362
2363 EXPORT
2364 void wasm_pdf_dict_puts(pdf_obj *obj, char *key, pdf_obj *val)
2365 {
2366 VOID(pdf_dict_puts, obj, key, val)
2367 }
2368
2369 EXPORT
2370 void wasm_pdf_dict_del(pdf_obj *obj, pdf_obj *key)
2371 {
2372 VOID(pdf_dict_del, obj, key)
2373 }
2374
2375 EXPORT
2376 void wasm_pdf_dict_dels(pdf_obj *obj, char *key)
2377 {
2378 VOID(pdf_dict_dels, obj, key)
2379 }
2380
2381 EXPORT
2382 void wasm_pdf_array_put(pdf_obj *obj, int key, pdf_obj *val)
2383 {
2384 VOID(pdf_array_put, obj, key, val)
2385 }
2386
2387 EXPORT
2388 void wasm_pdf_array_push(pdf_obj *obj, pdf_obj *val)
2389 {
2390 VOID(pdf_array_push, obj, val)
2391 }
2392
2393 EXPORT
2394 void wasm_pdf_array_delete(pdf_obj *obj, int key)
2395 {
2396 VOID(pdf_array_delete, obj, key)
2397 }
2398
2399 EXPORT
2400 char * wasm_pdf_sprint_obj(pdf_obj *obj, boolean tight, boolean ascii)
2401 {
2402 size_t len;
2403 POINTER(pdf_sprint_obj, NULL, 0, &len, obj, tight, ascii)
2404 }
2405
2406 EXPORT
2407 fz_buffer * wasm_pdf_load_stream(pdf_obj *obj)
2408 {
2409 POINTER(pdf_load_stream, obj)
2410 }
2411
2412 EXPORT
2413 fz_buffer * wasm_pdf_load_raw_stream(pdf_obj *obj)
2414 {
2415 POINTER(pdf_load_raw_stream, obj)
2416 }
2417
2418 EXPORT
2419 void wasm_pdf_update_object(pdf_document *doc, int num, pdf_obj *obj)
2420 {
2421 VOID(pdf_update_object, doc, num, obj)
2422 }
2423
2424 EXPORT
2425 void wasm_pdf_update_stream(pdf_document *doc, pdf_obj *ref, fz_buffer *buf, int raw)
2426 {
2427 VOID(pdf_update_stream, doc, ref, buf, raw)
2428 }
2429
2430 EXPORT
2431 char * wasm_pdf_to_string(pdf_obj *obj, size_t *size)
2432 {
2433 POINTER(pdf_to_string, obj, size)
2434 }
2435
2436 // --- STREAMS ---
2437
2438 struct js_stm_state {
2439 int id;
2440 unsigned char buf[8192];
2441 };
2442
2443 static void js_stm_drop(fz_context *ctx, void *state_)
2444 {
2445 struct js_stm_state *state = state_;
2446 EM_ASM({
2447 globalThis.$libmupdf_stm_close($0);
2448 }, state->id);
2449 fz_free(ctx, state);
2450 }
2451
2452 static int js_stm_next(fz_context *ctx, fz_stream *stm, size_t len)
2453 {
2454 struct js_stm_state *state = stm->state;
2455 int n = EM_ASM_INT(
2456 {
2457 return globalThis.$libmupdf_stm_read($0, $1, $2, $3);
2458 },
2459 (int) state->id,
2460 (int) stm->pos,
2461 (int) state->buf,
2462 (int) sizeof state->buf
2463 );
2464
2465 stm->rp = state->buf;
2466 stm->wp = state->buf + n;
2467 stm->pos += n;
2468
2469 if (n < 0)
2470 fz_throw(ctx, FZ_ERROR_TRYLATER, "trylater from stream callback");
2471 if (n == 0)
2472 return EOF;
2473 return *stm->rp++;
2474 }
2475
2476 static void js_stm_seek(fz_context *ctx, fz_stream *stm, int64_t offset, int whence)
2477 {
2478 struct js_stm_state *state = stm->state;
2479 int n = EM_ASM_INT(
2480 {
2481 return globalThis.$libmupdf_stm_seek($0, $1, $2, $3);
2482 },
2483 (int) state->id,
2484 (int) stm->pos,
2485 (int) offset,
2486 (int) whence
2487 );
2488 if (n < 0)
2489 fz_throw(ctx, FZ_ERROR_TRYLATER, "trylater from stream callback");
2490 stm->rp = stm->wp = state->buf;
2491 stm->pos = n;
2492 }
2493
2494 EXPORT
2495 fz_stream *wasm_new_stream(int id)
2496 {
2497 fz_stream *stm = NULL;
2498 TRY({
2499 struct js_stm_state *state = fz_malloc(ctx, sizeof *state);
2500 state->id = id;
2501 stm = fz_new_stream(ctx, state, js_stm_next, js_stm_drop);
2502 stm->seek = js_stm_seek;
2503 })
2504 return stm;
2505 }
2506
2507 // --- PATH WALKER CALLBACK DEVICE ---
2508
2509 static void
2510 path_walk_moveto(fz_context *ctx, void *arg, float x, float y)
2511 {
2512 EM_ASM({ globalThis.$libmupdf_path_walk.moveto($0, $1, $2) }, (int)arg, x, y);
2513 }
2514
2515 static void
2516 path_walk_lineto(fz_context *ctx, void *arg, float x, float y)
2517 {
2518 EM_ASM({ globalThis.$libmupdf_path_walk.lineto($0, $1, $2) }, (int)arg, x, y);
2519 }
2520
2521 static void
2522 path_walk_curveto(fz_context *ctx, void *arg, float x1, float y1, float x2, float y2, float x3, float y3)
2523 {
2524 EM_ASM({ globalThis.$libmupdf_path_walk.curveto($0, $1, $2, $3, $4, $5, $6) }, (int)arg, x1, y1, x2, y2, x3, y3);
2525 }
2526
2527 static void
2528 path_walk_closepath(fz_context *ctx, void *arg)
2529 {
2530 EM_ASM({ globalThis.$libmupdf_path_walk.closepath($0) }, (int)arg);
2531 }
2532
2533 EXPORT
2534 void wasm_walk_path(fz_path *path, int walk_id)
2535 {
2536 fz_path_walker walker = {
2537 path_walk_moveto,
2538 path_walk_lineto,
2539 path_walk_curveto,
2540 path_walk_closepath,
2541 };
2542 TRY({
2543 fz_walk_path(ctx, path, &walker, (void*)walk_id);
2544 })
2545 }
2546
2547 // --- TEXT WALKER CALLBACK DEVICE ---
2548
2549 EXPORT
2550 void wasm_walk_text(fz_text *text, int walk_id)
2551 {
2552 char buf[8];
2553 fz_text_span *span;
2554 fz_matrix trm;
2555 int i;
2556
2557 for (span = text->head; span; span = span->next) {
2558 trm = span->trm;
2559 EM_ASM({ globalThis.$libmupdf_text_walk.begin_span($0, $1, $2, $3, $4, $5, $6) },
2560 walk_id,
2561 span->font,
2562 &trm,
2563 span->wmode,
2564 span->bidi_level,
2565 span->markup_dir,
2566 fz_string_from_text_language(buf, span->language)
2567 );
2568 for (i = 0; i < span->len; ++i) {
2569 trm.e = span->items[i].x;
2570 trm.f = span->items[i].y;
2571 EM_ASM({ globalThis.$libmupdf_text_walk.show_glyph($0, $1, $2, $3, $4, $5, $6, $7) },
2572 walk_id,
2573 span->font,
2574 &trm,
2575 span->items[i].gid,
2576 span->items[i].ucs,
2577 span->wmode,
2578 span->bidi_level,
2579 span->markup_dir
2580 );
2581 }
2582 EM_ASM({ globalThis.$libmupdf_text_walk.end_span($0) }, walk_id);
2583 }
2584 }
2585
2586 // --- JAVASCRIPT CALLBACK DEVICE ---
2587
2588 typedef struct
2589 {
2590 fz_device super;
2591 int id;
2592 } js_device;
2593
2594 static void
2595 js_dev_drop_device(fz_context *ctx, fz_device *dev)
2596 {
2597 EM_ASM({ globalThis.$libmupdf_device.drop_device($0) }, ((js_device*)dev)->id);
2598 }
2599
2600 static void
2601 js_dev_close_device(fz_context *ctx, fz_device *dev)
2602 {
2603 EM_ASM({ globalThis.$libmupdf_device.close_device($0) }, ((js_device*)dev)->id);
2604 }
2605
2606 static void
2607 js_dev_fill_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm,
2608 fz_colorspace *colorspace, const float *color, float alpha, fz_color_params color_params)
2609 {
2610 EM_ASM({ globalThis.$libmupdf_device.fill_path($0, $1, $2, $3, $4, $5, $6, $7) },
2611 ((js_device*)dev)->id,
2612 path,
2613 even_odd,
2614 &ctm,
2615 colorspace,
2616 colorspace->n,
2617 color,
2618 alpha
2619 );
2620 }
2621
2622 static void
2623 js_dev_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm,
2624 fz_rect scissor)
2625 {
2626 EM_ASM({ globalThis.$libmupdf_device.clip_path($0, $1, $2, $3) },
2627 ((js_device*)dev)->id,
2628 path,
2629 even_odd,
2630 &ctm
2631 );
2632 }
2633
2634 static void
2635 js_dev_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path,
2636 const fz_stroke_state *stroke, fz_matrix ctm,
2637 fz_colorspace *colorspace, const float *color, float alpha, fz_color_params color_params)
2638 {
2639 EM_ASM({ globalThis.$libmupdf_device.stroke_path($0, $1, $2, $3, $4, $5, $6, $7) },
2640 ((js_device*)dev)->id,
2641 path,
2642 stroke,
2643 &ctm,
2644 colorspace,
2645 colorspace->n,
2646 color,
2647 alpha
2648 );
2649 }
2650
2651 static void
2652 js_dev_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke,
2653 fz_matrix ctm, fz_rect scissor)
2654 {
2655 EM_ASM({ globalThis.$libmupdf_device.clip_stroke_path($0, $1, $2, $3) },
2656 ((js_device*)dev)->id,
2657 path,
2658 stroke,
2659 &ctm
2660 );
2661 }
2662
2663 static void
2664 js_dev_fill_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm,
2665 fz_colorspace *colorspace, const float *color, float alpha, fz_color_params color_params)
2666 {
2667 EM_ASM({ globalThis.$libmupdf_device.fill_text($0, $1, $2, $3, $4, $5, $6) },
2668 ((js_device*)dev)->id,
2669 text,
2670 &ctm,
2671 colorspace,
2672 colorspace->n,
2673 color,
2674 alpha
2675 );
2676 }
2677
2678 static void
2679 js_dev_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke,
2680 fz_matrix ctm, fz_colorspace *colorspace, const float *color, float alpha, fz_color_params color_params)
2681 {
2682 EM_ASM({ globalThis.$libmupdf_device.stroke_text($0, $1, $2, $3, $4, $5, $6, $7) },
2683 ((js_device*)dev)->id,
2684 text,
2685 stroke,
2686 &ctm,
2687 colorspace,
2688 colorspace->n,
2689 color,
2690 alpha
2691 );
2692 }
2693
2694 static void
2695 js_dev_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, fz_rect scissor)
2696 {
2697 EM_ASM({ globalThis.$libmupdf_device.clip_text($0, $1, $2) },
2698 ((js_device*)dev)->id,
2699 text,
2700 &ctm
2701 );
2702 }
2703
2704 static void
2705 js_dev_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke,
2706 fz_matrix ctm, fz_rect scissor)
2707 {
2708 EM_ASM({ globalThis.$libmupdf_device.clip_stroke_text($0, $1, $2, $3) },
2709 ((js_device*)dev)->id,
2710 text,
2711 stroke,
2712 &ctm
2713 );
2714 }
2715
2716 static void
2717 js_dev_ignore_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm)
2718 {
2719 EM_ASM({ globalThis.$libmupdf_device.ignore_text($0, $1, $2) },
2720 ((js_device*)dev)->id,
2721 text,
2722 &ctm
2723 );
2724 }
2725
2726 static void
2727 js_dev_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha, fz_color_params color_params)
2728 {
2729 EM_ASM({ globalThis.$libmupdf_device.fill_shade($0, $1, $2, $3) },
2730 ((js_device*)dev)->id,
2731 shade,
2732 &ctm,
2733 alpha
2734 );
2735 }
2736
2737 static void
2738 js_dev_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, float alpha, fz_color_params color_params)
2739 {
2740 EM_ASM({ globalThis.$libmupdf_device.fill_image($0, $1, $2, $3) },
2741 ((js_device*)dev)->id,
2742 image,
2743 &ctm,
2744 alpha
2745 );
2746 }
2747
2748 static void
2749 js_dev_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm,
2750 fz_colorspace *colorspace, const float *color, float alpha, fz_color_params color_params)
2751 {
2752 EM_ASM({ globalThis.$libmupdf_device.fill_image_mask($0, $1, $2, $3, $4, $5, $6) },
2753 ((js_device*)dev)->id,
2754 image,
2755 &ctm,
2756 colorspace,
2757 colorspace->n,
2758 color,
2759 alpha
2760 );
2761 }
2762
2763 static void
2764 js_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, fz_rect scissor)
2765 {
2766 EM_ASM({ globalThis.$libmupdf_device.clip_image_mask($0, $1, $2) },
2767 ((js_device*)dev)->id,
2768 image,
2769 &ctm
2770 );
2771 }
2772
2773 static void
2774 js_dev_pop_clip(fz_context *ctx, fz_device *dev)
2775 {
2776 EM_ASM({ globalThis.$libmupdf_device.pop_clip($0) },
2777 ((js_device*)dev)->id
2778 );
2779 }
2780
2781 static void
2782 js_dev_begin_mask(fz_context *ctx, fz_device *dev, fz_rect bbox, int luminosity,
2783 fz_colorspace *colorspace, const float *color, fz_color_params color_params)
2784 {
2785 EM_ASM({ globalThis.$libmupdf_device.begin_mask($0, $1, $2, $3, $4, $5) },
2786 ((js_device*)dev)->id,
2787 &bbox,
2788 luminosity,
2789 colorspace,
2790 colorspace->n,
2791 color
2792 );
2793 }
2794
2795 static void
2796 js_dev_end_mask(fz_context *ctx, fz_device *dev, fz_function *tr)
2797 {
2798 EM_ASM({ globalThis.$libmupdf_device.end_mask($0, $1) },
2799 ((js_device*)dev)->id,
2800 tr
2801 );
2802 }
2803
2804 static void
2805 js_dev_begin_group(fz_context *ctx, fz_device *dev, fz_rect bbox,
2806 fz_colorspace *colorspace, int isolated, int knockout, int blendmode, float alpha)
2807 {
2808 EM_ASM({ globalThis.$libmupdf_device.begin_group($0, $1, $2, $3, $4, $5, $6) },
2809 ((js_device*)dev)->id,
2810 &bbox,
2811 colorspace,
2812 isolated,
2813 knockout,
2814 blendmode,
2815 alpha
2816 );
2817 }
2818
2819 static void
2820 js_dev_end_group(fz_context *ctx, fz_device *dev)
2821 {
2822 EM_ASM({ globalThis.$libmupdf_device.end_group($0) },
2823 ((js_device*)dev)->id
2824 );
2825 }
2826
2827 static int
2828 js_dev_begin_tile(fz_context *ctx, fz_device *dev, fz_rect area, fz_rect view,
2829 float xstep, float ystep, fz_matrix ctm, int id, int doc_id)
2830 {
2831 return EM_ASM_INT({ return globalThis.$libmupdf_device.begin_tile($0, $1, $2, $3, $4, $5, $6) },
2832 ((js_device*)dev)->id,
2833 &area,
2834 &view,
2835 xstep,
2836 ystep,
2837 &ctm,
2838 id,
2839 doc_id
2840 );
2841 }
2842
2843 static void
2844 js_dev_end_tile(fz_context *ctx, fz_device *dev)
2845 {
2846 EM_ASM({ globalThis.$libmupdf_device.end_tile($0) },
2847 ((js_device*)dev)->id
2848 );
2849 }
2850
2851 static void
2852 js_dev_begin_layer(fz_context *ctx, fz_device *dev, const char *name)
2853 {
2854 EM_ASM({ globalThis.$libmupdf_device.begin_layer($0, $1) },
2855 ((js_device*)dev)->id,
2856 name
2857 );
2858 }
2859
2860 static void
2861 js_dev_end_layer(fz_context *ctx, fz_device *dev)
2862 {
2863 EM_ASM({ globalThis.$libmupdf_device.end_layer($0) },
2864 ((js_device*)dev)->id
2865 );
2866 }
2867
2868 EXPORT
2869 fz_device *wasm_new_js_device(int id)
2870 {
2871 js_device *dev = fz_new_derived_device(ctx, js_device);
2872
2873 dev->super.close_device = js_dev_close_device;
2874 dev->super.drop_device = js_dev_drop_device;
2875
2876 dev->super.fill_path = js_dev_fill_path;
2877 dev->super.stroke_path = js_dev_stroke_path;
2878 dev->super.clip_path = js_dev_clip_path;
2879 dev->super.clip_stroke_path = js_dev_clip_stroke_path;
2880
2881 dev->super.fill_text = js_dev_fill_text;
2882 dev->super.stroke_text = js_dev_stroke_text;
2883 dev->super.clip_text = js_dev_clip_text;
2884 dev->super.clip_stroke_text = js_dev_clip_stroke_text;
2885 dev->super.ignore_text = js_dev_ignore_text;
2886
2887 dev->super.fill_shade = js_dev_fill_shade;
2888 dev->super.fill_image = js_dev_fill_image;
2889 dev->super.fill_image_mask = js_dev_fill_image_mask;
2890 dev->super.clip_image_mask = js_dev_clip_image_mask;
2891
2892 dev->super.pop_clip = js_dev_pop_clip;
2893
2894 dev->super.begin_mask = js_dev_begin_mask;
2895 dev->super.end_mask = js_dev_end_mask;
2896 dev->super.begin_group = js_dev_begin_group;
2897 dev->super.end_group = js_dev_end_group;
2898
2899 dev->super.begin_tile = js_dev_begin_tile;
2900 dev->super.end_tile = js_dev_end_tile;
2901
2902 dev->super.begin_layer = js_dev_begin_layer;
2903 dev->super.end_layer = js_dev_end_layer;
2904
2905 dev->id = id;
2906
2907 return (fz_device*)dev;
2908 }