Mercurial > hgrepos > Python2 > PyMuPDF

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