?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Alternative is worse
[llpp.git] / link.c
blob5f8e6582e03155b2b7e1a122dacd8393faa2b840
1 /* lots of code c&p-ed directly from mupdf */
2 #include <errno.h>
3 #include <stdio.h>
4 #include <ctype.h>
5 #include <string.h>
6 #include <stdlib.h>
7 #include <signal.h>
8 #include <wchar.h>
9
10 #include <unistd.h>
11 #include <pthread.h>
12 #include <sys/time.h>
13 #include <sys/types.h>
14 #include <sys/ioctl.h>
15
16 #ifdef __CYGWIN__
17 #include <cygwin/socket.h> /* FIONREAD */
18 #else
19 #include <spawn.h>
20 #endif
21
22 #include <regex.h>
23 #include <stdarg.h>
24 #include <limits.h>
25
26 #include <GL/gl.h>
27
28 #include <caml/fail.h>
29 #include <caml/alloc.h>
30 #include <caml/memory.h>
31 #include <caml/unixsupport.h>
32
33 #include <mupdf/fitz.h>
34 #include <mupdf/cbz.h>
35 #include <mupdf/pdf.h>
36 #include <mupdf/xps.h>
37 #include <mupdf/img.h>
38
39 #include FT_FREETYPE_H
40
41 #ifdef USE_FONTCONFIG
42 #include <fontconfig/fontconfig.h>
43 #endif
44
45 #define PIGGYBACK
46
47 #ifndef __USE_GNU
48 extern char **environ;
49 #endif
50
51 #define MIN(a,b) ((a) < (b) ? (a) : (b))
52 #define MAX(a,b) ((a) > (b) ? (a) : (b))
53
54 #if defined __GNUC__
55 #define NORETURN_ATTR __attribute__ ((noreturn))
56 #define UNUSED_ATTR __attribute__ ((unused))
57 #if !defined __clang__
58 #define OPTIMIZE_ATTR(n) __attribute__ ((optimize ("O"#n)))
59 #else
60 #define OPTIMIZE_ATTR(n)
61 #endif
62 #define GCC_FMT_ATTR(a, b) __attribute__ ((format (printf, a, b)))
63 #else
64 #define NORETURN_ATTR
65 #define UNUSED_ATTR
66 #define OPTIMIZE_ATTR(n)
67 #define GCC_FMT_ATTR(a, b)
68 #endif
69
70 #define FMT_s "zu"
71
72 #define FMT_ptr "p"
73 #define FMT_ptr_cast(p) (p)
74 #define FMT_ptr_cast2(p) (p)
75
76 static void NORETURN_ATTR GCC_FMT_ATTR (2, 3)
77 err (int exitcode, const char *fmt, ...)
78 {
79 va_list ap;
80 int savederrno;
81
82 savederrno = errno;
83 va_start (ap, fmt);
84 vfprintf (stderr, fmt, ap);
85 va_end (ap);
86 fprintf (stderr, ": %s\n", strerror (savederrno));
87 fflush (stderr);
88 _exit (exitcode);
89 }
90
91 static void NORETURN_ATTR GCC_FMT_ATTR (2, 3)
92 errx (int exitcode, const char *fmt, ...)
93 {
94 va_list ap;
95
96 va_start (ap, fmt);
97 vfprintf (stderr, fmt, ap);
98 va_end (ap);
99 fputc ('\n', stderr);
100 fflush (stderr);
101 _exit (exitcode);
102 }
103
104 #ifndef GL_TEXTURE_RECTANGLE_ARB
105 #define GL_TEXTURE_RECTANGLE_ARB 0x84F5
106 #endif
107
108 #ifndef GL_BGRA
109 #define GL_BGRA 0x80E1
110 #endif
111
112 #ifndef GL_UNSIGNED_INT_8_8_8_8
113 #define GL_UNSIGNED_INT_8_8_8_8 0x8035
114 #endif
115
116 #ifndef GL_UNSIGNED_INT_8_8_8_8_REV
117 #define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
118 #endif
119
120 #if 0
121 #define lprintf printf
122 #else
123 #define lprintf(...)
124 #endif
125
126 #define ARSERT(cond) for (;;) { \
127 if (!(cond)) { \
128 errx (1, "%s:%d " #cond, __FILE__, __LINE__); \
129 } \
130 break; \
131 }
132
133 struct slice {
134 int h;
135 int texindex;
136 };
137
138 struct tile {
139 int w, h;
140 int slicecount;
141 int sliceheight;
142 struct pbo *pbo;
143 fz_pixmap *pixmap;
144 struct slice slices[1];
145 };
146
147 struct pagedim {
148 int pageno;
149 int rotate;
150 int left;
151 int tctmready;
152 fz_irect bounds;
153 fz_rect pagebox;
154 fz_rect mediabox;
155 fz_matrix ctm, zoomctm, lctm, tctm;
156 };
157
158 struct slink {
159 fz_irect bbox;
160 fz_link *link;
161 };
162
163 enum { DPDF, DXPS, DCBZ, DIMG };
164
165 struct page {
166 int tgen;
167 int sgen;
168 int type;
169 int pageno;
170 int pdimno;
171 fz_text_page *text;
172 fz_text_sheet *sheet;
173 union {
174 void *ptr;
175 pdf_page *pdfpage;
176 xps_page *xpspage;
177 cbz_page *cbzpage;
178 image_page *imgpage;
179 } u;
180 fz_display_list *dlist;
181 int slinkcount;
182 struct slink *slinks;
183 struct mark {
184 int i;
185 fz_text_span *span;
186 } fmark, lmark;
187 void (*freepage) (void *);
188 };
189
190 struct {
191 int type;
192 int sliceheight;
193 struct pagedim *pagedims;
194 int pagecount;
195 int pagedimcount;
196 union {
197 pdf_document *pdf;
198 xps_document *xps;
199 cbz_document *cbz;
200 image_document *img;
201 } u;
202 fz_context *ctx;
203 int w, h;
204
205 int texindex;
206 int texcount;
207 GLuint *texids;
208
209 GLenum texiform;
210 GLenum texform;
211 GLenum texty;
212
213 fz_colorspace *colorspace;
214
215 struct {
216 int w, h;
217 struct slice *slice;
218 } *texowners;
219
220 int rotate;
221 enum { FitWidth, FitProportional, FitPage } fitmodel;
222 int trimmargins;
223 int needoutline;
224 int gen;
225 int aalevel;
226
227 int trimanew;
228 fz_irect trimfuzz;
229 fz_pixmap *pig;
230
231 pthread_t thread;
232 int cr, cw;
233 FT_Face face;
234
235 void (*closedoc) (void);
236 void (*freepage) (void *);
237
238 char *trimcachepath;
239 int cxack;
240
241 GLuint stid;
242
243 int pbo_usable;
244 void (*glBindBufferARB) (GLenum, GLuint);
245 GLboolean (*glUnmapBufferARB) (GLenum);
246 void *(*glMapBufferARB) (GLenum, GLenum);
247 void (*glBufferDataARB) (GLenum, GLsizei, void *, GLenum);
248 void (*glGenBuffersARB) (GLsizei, GLuint *);
249 void (*glDeleteBuffersARB) (GLsizei, GLuint *);
250
251 GLfloat texcoords[8];
252 GLfloat vertices[16];
253 } state;
254
255 struct pbo {
256 GLuint id;
257 void *ptr;
258 size_t size;
259 };
260
261 static void UNUSED_ATTR debug_rect (const char *cap, fz_rect r)
262 {
263 printf ("%s(rect) %.2f,%.2f,%.2f,%.2f\n", cap, r.x0, r.y0, r.x1, r.y1);
264 }
265
266 static void UNUSED_ATTR debug_bbox (const char *cap, fz_irect r)
267 {
268 printf ("%s(bbox) %d,%d,%d,%d\n", cap, r.x0, r.y0, r.x1, r.y1);
269 }
270
271 static void UNUSED_ATTR debug_matrix (const char *cap, fz_matrix m)
272 {
273 printf ("%s(matrix) %.2f,%.2f,%.2f,%.2f %.2f %.2f\n", cap,
274 m.a, m.b, m.c, m.d, m.e, m.f);
275 }
276
277 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
278
279 static void lock (const char *cap)
280 {
281 int ret = pthread_mutex_lock (&mutex);
282 if (ret) {
283 errx (1, "%s: pthread_mutex_lock: %s", cap, strerror (ret));
284 }
285 }
286
287 static void unlock (const char *cap)
288 {
289 int ret = pthread_mutex_unlock (&mutex);
290 if (ret) {
291 errx (1, "%s: pthread_mutex_unlock: %s", cap, strerror (ret));
292 }
293 }
294
295 static int trylock (const char *cap)
296 {
297 int ret = pthread_mutex_trylock (&mutex);
298 if (ret && ret != EBUSY) {
299 errx (1, "%s: pthread_mutex_trylock: %s", cap, strerror (ret));
300 }
301 return ret == EBUSY;
302 }
303
304 static void *parse_pointer (const char *cap, const char *s)
305 {
306 int ret;
307 void *ptr;
308
309 ret = sscanf (s, "%" FMT_ptr, FMT_ptr_cast (&ptr));
310 if (ret != 1) {
311 errx (1, "%s: cannot parse pointer in `%s'", cap, s);
312 }
313 return ptr;
314 }
315
316 static double now (void)
317 {
318 struct timeval tv;
319
320 if (gettimeofday (&tv, NULL)) {
321 err (1, "gettimeofday");
322 }
323 return tv.tv_sec + tv.tv_usec*1e-6;
324 }
325
326 static int hasdata (void)
327 {
328 int ret, avail;
329 ret = ioctl (state.cr, FIONREAD, &avail);
330 if (ret) err (1, "hasdata: FIONREAD error ret=%d", ret);
331 return avail > 0;
332 }
333
334 CAMLprim value ml_hasdata (value fd_v)
335 {
336 CAMLparam1 (fd_v);
337 int ret, avail;
338
339 ret = ioctl (Int_val (fd_v), FIONREAD, &avail);
340 if (ret) uerror ("ioctl (FIONREAD)", Nothing);
341 CAMLreturn (Val_bool (avail > 0));
342 }
343
344 static void readdata (void *p, int size)
345 {
346 ssize_t n;
347
348 again:
349 n = read (state.cr, p, size);
350 if (n < 0) {
351 if (errno == EINTR) goto again;
352 err (1, "read (req %d, ret %zd)", size, n);
353 }
354 if (n - size) {
355 if (!n) errx (1, "EOF while reading");
356 errx (1, "read (req %d, ret %zd)", size, n);
357 }
358 }
359
360 static void writedata (char *p, int size)
361 {
362 ssize_t n;
363
364 p[0] = (size >> 24) & 0xff;
365 p[1] = (size >> 16) & 0xff;
366 p[2] = (size >> 8) & 0xff;
367 p[3] = (size >> 0) & 0xff;
368
369 n = write (state.cw, p, size + 4);
370 if (n - size - 4) {
371 if (!n) errx (1, "EOF while writing data");
372 err (1, "write (req %d, ret %zd)", size + 4, n);
373 }
374 }
375
376 static int readlen (void)
377 {
378 unsigned char p[4];
379
380 readdata (p, 4);
381 return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
382 }
383
384 static void GCC_FMT_ATTR (1, 2) printd (const char *fmt, ...)
385 {
386 int size = 200, len;
387 va_list ap;
388 char *buf;
389
390 buf = malloc (size);
391 for (;;) {
392 if (!buf) err (1, "malloc for temp buf (%d bytes) failed", size);
393
394 va_start (ap, fmt);
395 len = vsnprintf (buf + 4, size - 4, fmt, ap);
396 va_end (ap);
397
398 if (len > -1) {
399 if (len < size - 4) {
400 writedata (buf, len);
401 break;
402 }
403 else size = len + 5;
404 }
405 else {
406 err (1, "vsnprintf for `%s' failed", fmt);
407 }
408 buf = realloc (buf, size);
409 }
410 free (buf);
411 }
412
413 static void closepdf (void)
414 {
415 if (state.u.pdf) {
416 pdf_close_document (state.u.pdf);
417 state.u.pdf = NULL;
418 }
419 }
420
421 static void closexps (void)
422 {
423 if (state.u.xps) {
424 xps_close_document (state.u.xps);
425 state.u.xps = NULL;
426 }
427 }
428
429 static void closecbz (void)
430 {
431 if (state.u.cbz) {
432 cbz_close_document (state.u.cbz);
433 state.u.cbz = NULL;
434 }
435 }
436
437 static void closeimg (void)
438 {
439 if (state.u.img) {
440 image_close_document (state.u.img);
441 state.u.img = NULL;
442 }
443 }
444
445 static void freepdfpage (void *ptr)
446 {
447 pdf_free_page (state.u.pdf, ptr);
448 }
449
450 static void freeemptyxxxpage (void *ptr)
451 {
452 (void) ptr;
453 }
454
455 static void freexpspage (void *ptr)
456 {
457 xps_free_page (state.u.xps, ptr);
458 }
459
460 static void freecbzpage (void *ptr)
461 {
462 cbz_free_page (state.u.cbz, ptr);
463 }
464
465 static void freeimgpage (void *ptr)
466 {
467 image_free_page (state.u.img, ptr);
468 }
469
470 static void openxref (char *filename, char *password)
471 {
472 int i, len;
473
474 for (i = 0; i < state.texcount; ++i) {
475 state.texowners[i].w = -1;
476 state.texowners[i].slice = NULL;
477 }
478
479 if (state.closedoc) state.closedoc ();
480
481 len = strlen (filename);
482
483 state.type = DPDF;
484 {
485 int i;
486 struct {
487 char *ext;
488 int type;
489 } tbl[] = {
490 { "pdf", DPDF },
491 { "xps", DXPS },
492 { "cbz", DCBZ },
493 { "jpg", DIMG },
494 { "jpeg", DIMG },
495 { "png", DIMG }
496 };
497
498 for (i = 0; i < sizeof (tbl) / sizeof (*tbl); ++i) {
499 int len2 = strlen (tbl[i].ext);
500
501 if (len2 < len && !strcasecmp (tbl[i].ext, filename + len - len2)) {
502 state.type = tbl[i].type;
503 break;
504 }
505 }
506 }
507
508 if (state.pagedims) {
509 free (state.pagedims);
510 state.pagedims = NULL;
511 }
512 state.pagedimcount = 0;
513
514 fz_set_aa_level (state.ctx, state.aalevel);
515 switch (state.type) {
516 case DPDF:
517 state.u.pdf = pdf_open_document (state.ctx, filename);
518 if (pdf_needs_password (state.u.pdf)) {
519 int okay = pdf_authenticate_password (state.u.pdf, password);
520 if (!okay) {
521 errx (1, "invalid password");
522 }
523 }
524 state.pagecount = pdf_count_pages (state.u.pdf);
525 state.closedoc = closepdf;
526 state.freepage = freepdfpage;
527 break;
528
529 case DXPS:
530 state.u.xps = xps_open_document (state.ctx, filename);
531 state.pagecount = xps_count_pages (state.u.xps);
532 state.closedoc = closexps;
533 state.freepage = freexpspage;
534 break;
535
536 case DCBZ:
537 state.u.cbz = cbz_open_document (state.ctx, filename);
538 state.pagecount = cbz_count_pages (state.u.cbz);
539 state.closedoc = closecbz;
540 state.freepage = freecbzpage;
541 break;
542
543 case DIMG:
544 state.u.img = image_open_document (state.ctx, filename);
545 state.pagecount = 1;
546 state.closedoc = closeimg;
547 state.freepage = freeimgpage;
548 break;
549 }
550 }
551
552 static void pdfinfo (void)
553 {
554 if (state.type == DPDF) {
555 pdf_obj *infoobj;
556
557 printd ("info PDF version\t%d.%d",
558 state.u.pdf->version / 10, state.u.pdf->version % 10);
559
560 infoobj = pdf_dict_gets (pdf_trailer (state.u.pdf), "Info");
561 if (infoobj) {
562 int i;
563 char *s;
564 char *items[] = { "Title", "Author", "Creator",
565 "Producer", "CreationDate" };
566
567 for (i = 0; i < sizeof (items) / sizeof (*items); ++i) {
568 pdf_obj *obj = pdf_dict_gets (infoobj, items[i]);
569 s = pdf_to_utf8 (state.u.pdf, obj);
570 if (*s) {
571 if (i == 0) {
572 printd ("title %s", s);
573 }
574 printd ("info %s\t%s", items[i], s);
575 }
576 fz_free (state.ctx, s);
577 }
578 }
579 printd ("infoend");
580 }
581 }
582
583 static void unlinktile (struct tile *tile)
584 {
585 int i;
586
587 for (i = 0; i < tile->slicecount; ++i) {
588 struct slice *s = &tile->slices[i];
589
590 if (s->texindex != -1) {
591 if (state.texowners[s->texindex].slice == s) {
592 state.texowners[s->texindex].slice = NULL;
593 }
594 }
595 }
596 }
597
598 static void freepage (struct page *page)
599 {
600 if (page->text) {
601 fz_free_text_page (state.ctx, page->text);
602 }
603 if (page->sheet) {
604 fz_free_text_sheet (state.ctx, page->sheet);
605 }
606 if (page->slinks) {
607 free (page->slinks);
608 }
609 fz_drop_display_list (state.ctx, page->dlist);
610 page->freepage (page->u.ptr);
611 free (page);
612 }
613
614 static void freetile (struct tile *tile)
615 {
616 unlinktile (tile);
617 if (!tile->pbo) {
618 #ifndef PIGGYBACK
619 fz_drop_pixmap (state.ctx, tile->pixmap);
620 #else
621 if (state.pig) {
622 fz_drop_pixmap (state.ctx, state.pig);
623 }
624 state.pig = tile->pixmap;
625 #endif
626 }
627 else {
628 free (tile->pbo);
629 fz_drop_pixmap (state.ctx, tile->pixmap);
630 }
631 free (tile);
632 }
633
634 #ifdef __ALTIVEC__
635 #include <stdint.h>
636 #include <altivec.h>
637
638 static int cacheline32bytes;
639
640 static void __attribute__ ((constructor)) clcheck (void)
641 {
642 char **envp = environ;
643 unsigned long *auxv;
644
645 while (*envp++);
646
647 for (auxv = (unsigned long *) envp; *auxv != 0; auxv += 2) {
648 if (*auxv == 19) {
649 cacheline32bytes = auxv[1] == 32;
650 return;
651 }
652 }
653 }
654
655 static void OPTIMIZE_ATTR (3) clearpixmap (fz_pixmap *pixmap)
656 {
657 size_t size = pixmap->w * pixmap->h * pixmap->n;
658 if (cacheline32bytes && size > 32) {
659 intptr_t a1, a2, diff;
660 size_t sizea, i;
661 vector unsigned char v = vec_splat_u8 (-1);
662 vector unsigned char *p;
663
664 a1 = a2 = (intptr_t) pixmap->samples;
665 a2 = (a1 + 31) & ~31;
666 diff = a2 - a1;
667 sizea = size - diff;
668 p = (void *) a2;
669
670 while (a1 != a2) *(char *) a1++ = 0xff;
671 for (i = 0; i < (sizea & ~31); i += 32) {
672 __asm volatile ("dcbz %0, %1"::"b"(a2),"r"(i));
673 vec_st (v, i, p);
674 vec_st (v, i + 16, p);
675 }
676 while (i < sizea) *((char *) a1 + i++) = 0xff;
677 }
678 else fz_clear_pixmap_with_value (state.ctx, pixmap, 0xff);
679 }
680 #else
681 #define clearpixmap(p) fz_clear_pixmap_with_value (state.ctx, p, 0xff)
682 #endif
683
684 static void trimctm (pdf_page *page, int pindex)
685 {
686 fz_matrix ctm;
687 struct pagedim *pdim = &state.pagedims[pindex];
688
689 if (!pdim->tctmready) {
690 if (state.trimmargins) {
691 fz_rect realbox;
692 fz_matrix rm, sm, tm, im, ctm1;
693
694 fz_rotate (&rm, -pdim->rotate);
695 fz_scale (&sm, 1, -1);
696 fz_concat (&ctm, &rm, &sm);
697 realbox = pdim->mediabox;
698 fz_transform_rect (&realbox, &ctm);
699 fz_translate (&tm, -realbox.x0, -realbox.y0);
700 fz_concat (&ctm1, &ctm, &tm);
701 fz_invert_matrix (&im, &page->ctm);
702 fz_concat (&ctm, &im, &ctm1);
703 }
704 else {
705 ctm = fz_identity;
706 }
707 pdim->tctm = ctm;
708 pdim->tctmready = 1;
709 }
710 }
711
712 static fz_matrix pagectm (struct page *page)
713 {
714 fz_matrix ctm, tm;
715
716 if (page->type == DPDF) {
717 trimctm (page->u.pdfpage, page->pdimno);
718 fz_concat (&ctm,
719 &state.pagedims[page->pdimno].tctm,
720 &state.pagedims[page->pdimno].ctm);
721 }
722 else {
723 struct pagedim *pdim = &state.pagedims[page->pdimno];
724
725 fz_translate (&tm, -pdim->mediabox.x0, -pdim->mediabox.y0);
726 fz_concat (&ctm, &tm, &state.pagedims[page->pdimno].ctm);
727 }
728 return ctm;
729 }
730
731 static void *loadpage (int pageno, int pindex)
732 {
733 fz_device *dev;
734 struct page *page;
735
736 page = calloc (sizeof (struct page), 1);
737 if (!page) {
738 err (1, "calloc page %d", pageno);
739 }
740
741 page->dlist = fz_new_display_list (state.ctx);
742 dev = fz_new_list_device (state.ctx, page->dlist);
743 fz_try (state.ctx) {
744 switch (state.type) {
745 case DPDF:
746 page->u.pdfpage = pdf_load_page (state.u.pdf, pageno);
747 pdf_run_page (state.u.pdf, page->u.pdfpage, dev,
748 &fz_identity, NULL);
749 page->freepage = freepdfpage;
750 break;
751
752 case DXPS:
753 page->u.xpspage = xps_load_page (state.u.xps, pageno);
754 xps_run_page (state.u.xps, page->u.xpspage, dev,
755 &fz_identity, NULL);
756 page->freepage = freexpspage;
757 break;
758
759 case DCBZ:
760 page->u.cbzpage = cbz_load_page (state.u.cbz, pageno);
761 cbz_run_page (state.u.cbz, page->u.cbzpage, dev,
762 &fz_identity, NULL);
763 page->freepage = freecbzpage;
764 break;
765
766 case DIMG:
767 page->u.imgpage = image_load_page (state.u.img, pageno);
768 image_run_page (state.u.img, page->u.imgpage, dev,
769 &fz_identity, NULL);
770 page->freepage = freeimgpage;
771 break;
772 }
773 }
774 fz_catch (state.ctx) {
775 page->u.ptr = NULL;
776 page->freepage = freeemptyxxxpage;
777 }
778 fz_free_device (dev);
779
780 page->pdimno = pindex;
781 page->pageno = pageno;
782 page->sgen = state.gen;
783 page->tgen = state.gen;
784 page->type = state.type;
785
786 return page;
787 }
788
789 static struct tile *alloctile (int h)
790 {
791 int i;
792 int slicecount;
793 size_t tilesize;
794 struct tile *tile;
795
796 slicecount = (h + state.sliceheight - 1) / state.sliceheight;
797 tilesize = sizeof (*tile) + ((slicecount - 1) * sizeof (struct slice));
798 tile = calloc (tilesize, 1);
799 if (!tile) {
800 err (1, "can not allocate tile (%" FMT_s " bytes)", tilesize);
801 }
802 for (i = 0; i < slicecount; ++i) {
803 int sh = MIN (h, state.sliceheight);
804 tile->slices[i].h = sh;
805 tile->slices[i].texindex = -1;
806 h -= sh;
807 }
808 tile->slicecount = slicecount;
809 tile->sliceheight = state.sliceheight;
810 return tile;
811 }
812
813 #ifdef OBSCURED_OPT
814 struct obs {
815 int cured;
816 fz_irect b;
817 };
818
819 static void obs_fill_image (fz_device *dev, fz_image *image,
820 const fz_matrix *ctm, float alpha)
821 {
822 struct obs *obs = dev->user;
823
824 if (!obs->cured && fabs (1.0 - alpha) < 1e6) {
825 fz_irect b;
826 fz_rect rect = fz_unit_rect;
827
828 fz_transform_rect (&rect, ctm);
829 fz_round_rect (&b, &rect);
830 fz_intersect_irect (&b, &obs->b);
831 obs->cured = b.x0 == obs->b.x0
832 && b.x1 == obs->b.x1
833 && b.y0 == obs->b.y0
834 && b.y1 == obs->b.y1;
835 }
836 }
837
838 static int obscured (struct page *page, fz_irect bbox)
839 {
840 fz_rect rect;
841 fz_matrix ctm;
842 fz_device dev;
843 struct obs obs;
844
845 memset (&dev, 0, sizeof (dev));
846 memset (&obs, 0, sizeof (obs));
847 dev.hints = 0;
848 dev.flags = 0;
849 dev.user = &obs;
850 dev.ctx = state.ctx;
851 dev.fill_image = obs_fill_image;
852 obs.b = bbox;
853 fz_rect_from_irect (&rect, &bbox);
854 ctm = pagectm (page);
855 fz_run_display_list (page->dlist, &dev, &ctm, &rect, NULL);
856 return obs.cured;
857 }
858 #define OBSCURED obscured
859 #else
860 #define OBSCURED(a, b) 0
861 #endif
862
863 static struct tile *rendertile (struct page *page, int x, int y, int w, int h,
864 struct pbo *pbo)
865 {
866 fz_rect rect;
867 fz_irect bbox;
868 fz_matrix ctm;
869 fz_device *dev;
870 struct tile *tile;
871 struct pagedim *pdim;
872
873 tile = alloctile (h);
874 pdim = &state.pagedims[page->pdimno];
875
876 bbox = pdim->bounds;
877 bbox.x0 += x;
878 bbox.y0 += y;
879 bbox.x1 = bbox.x0 + w;
880 bbox.y1 = bbox.y0 + h;
881
882 if (state.pig) {
883 if (state.pig->w == w
884 && state.pig->h == h
885 && state.pig->colorspace == state.colorspace) {
886 tile->pixmap = state.pig;
887 tile->pixmap->x = bbox.x0;
888 tile->pixmap->y = bbox.y0;
889 }
890 else {
891 fz_drop_pixmap (state.ctx, state.pig);
892 }
893 state.pig = NULL;
894 }
895 if (!tile->pixmap) {
896 if (pbo) {
897 tile->pixmap =
898 fz_new_pixmap_with_bbox_and_data (state.ctx, state.colorspace,
899 &bbox, pbo->ptr);
900 tile->pbo = pbo;
901 }
902 else {
903 tile->pixmap =
904 fz_new_pixmap_with_bbox (state.ctx, state.colorspace, &bbox);
905 }
906 }
907
908 tile->w = w;
909 tile->h = h;
910 if (!page->u.ptr || ((w < 128 && h < 128) || !OBSCURED (page, bbox))) {
911 clearpixmap (tile->pixmap);
912 }
913 dev = fz_new_draw_device (state.ctx, tile->pixmap);
914 ctm = pagectm (page);
915 fz_rect_from_irect (&rect, &bbox);
916 fz_run_display_list (page->dlist, dev, &ctm, &rect, NULL);
917 fz_free_device (dev);
918
919 return tile;
920 }
921
922 static void initpdims (void)
923 {
924 double start, end;
925 FILE *trimf = NULL;
926 fz_rect rootmediabox;
927 int pageno, trim, show;
928 int trimw = 0, cxcount;
929
930 start = now ();
931
932 if (state.trimmargins && state.trimcachepath) {
933 trimf = fopen (state.trimcachepath, "rb");
934 if (!trimf) {
935 trimf = fopen (state.trimcachepath, "wb");
936 trimw = 1;
937 }
938 }
939
940 if (state.trimmargins || state.type == DPDF || !state.cxack)
941 cxcount = state.pagecount;
942 else
943 cxcount = MIN (state.pagecount, 1);
944
945 if (state.type == DPDF) {
946 pdf_obj *obj;
947 obj = pdf_dict_getp (pdf_trailer (state.u.pdf),
948 "Root/Pages/MediaBox");
949 pdf_to_rect (state.ctx, obj, &rootmediabox);
950 }
951
952 for (pageno = 0; pageno < cxcount; ++pageno) {
953 int rotate = 0;
954 struct pagedim *p;
955 fz_rect mediabox;
956
957 switch (state.type) {
958 case DPDF: {
959 pdf_document *pdf = state.u.pdf;
960 pdf_obj *pageref = pdf_lookup_page_obj (pdf, pageno);
961 pdf_obj *pageobj = pdf_resolve_indirect (pageref);
962
963 if (state.trimmargins) {
964 pdf_obj *obj;
965 pdf_page *page;
966
967 fz_try (state.ctx) {
968 page = pdf_load_page (pdf, pageno);
969 obj = pdf_dict_gets (pageobj, "llpp.TrimBox");
970 trim = state.trimanew || !obj;
971 if (trim) {
972 fz_rect rect;
973 fz_matrix ctm;
974 fz_device *dev;
975
976 dev = fz_new_bbox_device (state.ctx, &rect);
977 dev->hints |= FZ_IGNORE_SHADE;
978 fz_invert_matrix (&ctm, &page->ctm);
979 pdf_run_page (pdf, page, dev, &fz_identity, NULL);
980 fz_free_device (dev);
981
982 rect.x0 += state.trimfuzz.x0;
983 rect.x1 += state.trimfuzz.x1;
984 rect.y0 += state.trimfuzz.y0;
985 rect.y1 += state.trimfuzz.y1;
986 fz_transform_rect (&rect, &ctm);
987 fz_intersect_rect (&rect, &page->mediabox);
988
989 if (fz_is_empty_rect (&rect)) {
990 mediabox = page->mediabox;
991 }
992 else {
993 mediabox = rect;
994 }
995
996 obj = pdf_new_array (pdf, 4);
997 pdf_array_push (obj, pdf_new_real (pdf, mediabox.x0));
998 pdf_array_push (obj, pdf_new_real (pdf, mediabox.y0));
999 pdf_array_push (obj, pdf_new_real (pdf, mediabox.x1));
1000 pdf_array_push (obj, pdf_new_real (pdf, mediabox.y1));
1001 pdf_dict_puts (pageobj, "llpp.TrimBox", obj);
1002 }
1003 else {
1004 mediabox.x0 = pdf_to_real (pdf_array_get (obj, 0));
1005 mediabox.y0 = pdf_to_real (pdf_array_get (obj, 1));
1006 mediabox.x1 = pdf_to_real (pdf_array_get (obj, 2));
1007 mediabox.y1 = pdf_to_real (pdf_array_get (obj, 3));
1008 }
1009
1010 rotate = page->rotate;
1011 pdf_free_page (pdf, page);
1012
1013 show = trim ? pageno % 5 == 0 : pageno % 20 == 0;
1014 if (show) {
1015 printd ("progress %f Trimming %d",
1016 (double) (pageno + 1) / state.pagecount,
1017 pageno + 1);
1018 }
1019 }
1020 fz_catch (state.ctx) {
1021 fprintf (stderr, "failed to load page %d\n", pageno+1);
1022 }
1023 }
1024 else {
1025 int empty = 0;
1026 fz_rect cropbox;
1027
1028 pdf_to_rect (state.ctx, pdf_dict_gets (pageobj, "MediaBox"),
1029 &mediabox);
1030 if (fz_is_empty_rect (&mediabox)) {
1031 mediabox.x0 = 0;
1032 mediabox.y0 = 0;
1033 mediabox.x1 = 612;
1034 mediabox.y1 = 792;
1035 empty = 1;
1036 }
1037
1038 pdf_to_rect (state.ctx, pdf_dict_gets (pageobj, "CropBox"),
1039 &cropbox);
1040 if (!fz_is_empty_rect (&cropbox)) {
1041 if (empty) {
1042 mediabox = cropbox;
1043 }
1044 else {
1045 fz_intersect_rect (&mediabox, &cropbox);
1046 }
1047 }
1048 else {
1049 if (empty) {
1050 if (fz_is_empty_rect (&rootmediabox)) {
1051 fprintf (stderr,
1052 "cannot find page size for page %d\n",
1053 pageno+1);
1054 }
1055 else {
1056 mediabox = rootmediabox;
1057 }
1058 }
1059 }
1060 rotate = pdf_to_int (pdf_dict_gets (pageobj, "Rotate"));
1061 }
1062 break;
1063 }
1064
1065 case DXPS:
1066 {
1067 xps_page *page;
1068
1069 fz_try (state.ctx) {
1070 page = xps_load_page (state.u.xps, pageno);
1071 xps_bound_page (state.u.xps, page, &mediabox);
1072 rotate = 0;
1073 if (state.trimmargins) {
1074 fz_rect rect;
1075 fz_device *dev;
1076
1077 dev = fz_new_bbox_device (state.ctx, &rect);
1078 dev->hints |= FZ_IGNORE_SHADE;
1079 xps_run_page (state.u.xps, page, dev,
1080 &fz_identity, NULL);
1081 fz_free_device (dev);
1082
1083 rect.x0 += state.trimfuzz.x0;
1084 rect.x1 += state.trimfuzz.x1;
1085 rect.y0 += state.trimfuzz.y0;
1086 rect.y1 += state.trimfuzz.y1;
1087 fz_intersect_rect (&rect, &mediabox);
1088
1089 if (!fz_is_empty_rect (&rect)) {
1090 mediabox = rect;
1091 }
1092 }
1093 xps_free_page (state.u.xps, page);
1094 if (!state.cxack) {
1095 printd ("progress %f loading %d",
1096 (double) (pageno + 1) / state.pagecount,
1097 pageno + 1);
1098 }
1099 }
1100 fz_catch (state.ctx) {
1101 }
1102 }
1103 break;
1104
1105 case DCBZ:
1106 {
1107 rotate = 0;
1108 mediabox.x0 = 0;
1109 mediabox.y0 = 0;
1110 mediabox.x1 = 900;
1111 mediabox.y1 = 900;
1112 if (state.trimmargins && trimw) {
1113 cbz_page *page;
1114
1115 fz_try (state.ctx) {
1116 page = cbz_load_page (state.u.cbz, pageno);
1117 cbz_bound_page (state.u.cbz, page, &mediabox);
1118 cbz_free_page (state.u.cbz, page);
1119 printd ("progress %f Trimming %d",
1120 (double) (pageno + 1) / state.pagecount,
1121 pageno + 1);
1122 }
1123 fz_catch (state.ctx) {
1124 fprintf (stderr, "failed to load page %d\n", pageno+1);
1125 }
1126 if (trimf) {
1127 int n = fwrite (&mediabox, sizeof (mediabox), 1, trimf);
1128 if (n - 1) {
1129 err (1, "fwrite trim mediabox");
1130 }
1131 }
1132 }
1133 else {
1134 if (trimf) {
1135 int n = fread (&mediabox, sizeof (mediabox), 1, trimf);
1136 if (n - 1) {
1137 err (1, "fread trim mediabox");
1138 }
1139 }
1140 else {
1141 if (state.cxack) {
1142 cbz_page *page;
1143 fz_try (state.ctx) {
1144 page = cbz_load_page (state.u.cbz, pageno);
1145 cbz_bound_page (state.u.cbz, page, &mediabox);
1146 cbz_free_page (state.u.cbz, page);
1147 }
1148 fz_catch (state.ctx) {
1149 fprintf (stderr, "failed to load cbz page\n");
1150 }
1151 }
1152 }
1153 }
1154 }
1155 break;
1156
1157 case DIMG:
1158 {
1159 image_page *page;
1160
1161 rotate = 0;
1162 mediabox.x0 = 0;
1163 mediabox.y0 = 0;
1164 mediabox.x1 = 900;
1165 mediabox.y1 = 900;
1166
1167 fz_try (state.ctx) {
1168 page = image_load_page (state.u.img, pageno);
1169 image_bound_page (state.u.img, page, &mediabox);
1170 image_free_page (state.u.img, page);
1171 }
1172 fz_catch (state.ctx) {
1173 fprintf (stderr, "failed to load page %d\n", pageno+1);
1174 }
1175 }
1176 break;
1177
1178 default:
1179 ARSERT (0 && state.type);
1180 }
1181
1182 if (state.pagedimcount == 0
1183 || (p = &state.pagedims[state.pagedimcount-1], p->rotate != rotate)
1184 || memcmp (&p->mediabox, &mediabox, sizeof (mediabox))) {
1185 size_t size;
1186
1187 size = (state.pagedimcount + 1) * sizeof (*state.pagedims);
1188 state.pagedims = realloc (state.pagedims, size);
1189 if (!state.pagedims) {
1190 err (1, "realloc pagedims to %" FMT_s " (%d elems)",
1191 size, state.pagedimcount + 1);
1192 }
1193
1194 p = &state.pagedims[state.pagedimcount++];
1195 p->rotate = rotate;
1196 p->mediabox = mediabox;
1197 p->pageno = pageno;
1198 }
1199 }
1200 end = now ();
1201 if (state.trimmargins) {
1202 printd ("progress 1 Trimmed %d pages in %f seconds",
1203 state.pagecount, end - start);
1204 }
1205 else {
1206 printd ("vmsg Processed %d pages in %f seconds",
1207 state.pagecount, end - start);
1208 }
1209 state.trimanew = 0;
1210 if (trimf) {
1211 if (fclose (trimf)) {
1212 err (1, "fclose");
1213 }
1214 }
1215 }
1216
1217 static void layout (void)
1218 {
1219 int pindex;
1220 fz_rect box;
1221 fz_matrix ctm, rm;
1222 struct pagedim *p = p;
1223 double zw, w, maxw = 0.0, zoom = zoom;
1224
1225 if (state.pagedimcount == 0) return;
1226
1227 switch (state.fitmodel) {
1228 case FitProportional:
1229 for (pindex = 0; pindex < state.pagedimcount; ++pindex) {
1230 double x0, x1;
1231
1232 p = &state.pagedims[pindex];
1233 fz_rotate (&rm, p->rotate + state.rotate);
1234 box = p->mediabox;
1235 fz_transform_rect (&box, &rm);
1236
1237 x0 = MIN (box.x0, box.x1);
1238 x1 = MAX (box.x0, box.x1);
1239
1240 w = x1 - x0;
1241 maxw = MAX (w, maxw);
1242 zoom = state.w / maxw;
1243 }
1244 break;
1245
1246 case FitPage:
1247 maxw = state.w;
1248 break;
1249
1250 case FitWidth:
1251 break;
1252
1253 default:
1254 ARSERT (0 && state.fitmodel);
1255 }
1256
1257 for (pindex = 0; pindex < state.pagedimcount; ++pindex) {
1258 fz_rect rect;
1259 fz_matrix tm, sm;
1260
1261 p = &state.pagedims[pindex];
1262 fz_rotate (&ctm, state.rotate);
1263 fz_rotate (&rm, p->rotate + state.rotate);
1264 box = p->mediabox;
1265 fz_transform_rect (&box, &rm);
1266 w = box.x1 - box.x0;
1267 switch (state.fitmodel) {
1268 case FitProportional:
1269 p->left = ((maxw - w) * zoom) / 2.0;
1270 break;
1271 case FitPage:
1272 {
1273 double zh, h;
1274 zw = maxw / w;
1275 h = box.y1 - box.y0;
1276 zh = state.h / h;
1277 zoom = MIN (zw, zh);
1278 p->left = (maxw - (w * zoom)) / 2.0;
1279 }
1280 break;
1281 case FitWidth:
1282 p->left = 0;
1283 zoom = state.w / w;
1284 break;
1285 }
1286
1287 fz_scale (&p->zoomctm, zoom, zoom);
1288 fz_concat (&ctm, &p->zoomctm, &ctm);
1289
1290 fz_rotate (&rm, p->rotate);
1291 p->pagebox = p->mediabox;
1292 fz_transform_rect (&p->pagebox, &rm);
1293 p->pagebox.x1 -= p->pagebox.x0;
1294 p->pagebox.y1 -= p->pagebox.y0;
1295 p->pagebox.x0 = 0;
1296 p->pagebox.y0 = 0;
1297 rect = p->pagebox;
1298 fz_transform_rect (&rect, &ctm);
1299 fz_round_rect (&p->bounds, &rect);
1300 p->ctm = ctm;
1301
1302 fz_translate (&tm, 0, -p->mediabox.y1);
1303 fz_scale (&sm, zoom, -zoom);
1304 fz_concat (&ctm, &tm, &sm);
1305 fz_concat (&p->lctm, &ctm, &rm);
1306
1307 p->tctmready = 0;
1308 }
1309
1310 do {
1311 int x0 = MIN (p->bounds.x0, p->bounds.x1);
1312 int y0 = MIN (p->bounds.y0, p->bounds.y1);
1313 int x1 = MAX (p->bounds.x0, p->bounds.x1);
1314 int y1 = MAX (p->bounds.y0, p->bounds.y1);
1315 int w = x1 - x0;
1316 int h = y1 - y0;
1317
1318 printd ("pdim %d %d %d %d", p->pageno, w, h, p->left);
1319 } while (p-- != state.pagedims);
1320 }
1321
1322 static
1323 struct anchor { int n; int x; int y; int w; int h; }
1324 desttoanchor (fz_link_dest *dest)
1325 {
1326 int i;
1327 struct anchor a;
1328 struct pagedim *pdim = state.pagedims;
1329
1330 a.n = -1;
1331 a.x = 0;
1332 a.y = 0;
1333 for (i = 0; i < state.pagedimcount; ++i) {
1334 if (state.pagedims[i].pageno > dest->ld.gotor.page)
1335 break;
1336 pdim = &state.pagedims[i];
1337 }
1338 if (dest->ld.gotor.flags & fz_link_flag_t_valid) {
1339 fz_point p;
1340 if (dest->ld.gotor.flags & fz_link_flag_l_valid)
1341 p.x = dest->ld.gotor.lt.x;
1342 else
1343 p.x = 0.0;
1344 p.y = dest->ld.gotor.lt.y;
1345 fz_transform_point (&p, &pdim->lctm);
1346 a.y = p.y;
1347 a.x = p.x;
1348 }
1349 if (dest->ld.gotor.page >= 0 && dest->ld.gotor.page < 1<<30) {
1350 double x0, x1, y0, y1;
1351
1352 x0 = MIN (pdim->bounds.x0, pdim->bounds.x1);
1353 x1 = MAX (pdim->bounds.x0, pdim->bounds.x1);
1354 a.w = x1 - x0;
1355 y0 = MIN (pdim->bounds.y0, pdim->bounds.y1);
1356 y1 = MAX (pdim->bounds.y0, pdim->bounds.y1);
1357 a.h = y1 - y0;
1358 a.n = dest->ld.gotor.page;
1359 }
1360 return a;
1361 }
1362
1363 static void recurse_outline (fz_outline *outline, int level)
1364 {
1365 while (outline) {
1366 switch (outline->dest.kind) {
1367 case FZ_LINK_GOTO:
1368 {
1369 struct anchor a = desttoanchor (&outline->dest);
1370
1371 if (a.n >= 0) {
1372 printd ("o %d %d %d %d %s",
1373 level, a.n, a.y, a.h, outline->title);
1374 }
1375 }
1376 break;
1377
1378 case FZ_LINK_URI:
1379 printd ("ou %d %" FMT_s " %s %s", level,
1380 strlen (outline->title), outline->title,
1381 outline->dest.ld.uri.uri);
1382 break;
1383
1384 case FZ_LINK_NONE:
1385 printd ("on %d %s", level, outline->title);
1386 break;
1387
1388 default:
1389 printd ("emsg Unhandled outline kind %d for %s\n",
1390 outline->dest.kind, outline->title);
1391 break;
1392 }
1393 if (outline->down) {
1394 recurse_outline (outline->down, level + 1);
1395 }
1396 outline = outline->next;
1397 }
1398 }
1399
1400 static void process_outline (void)
1401 {
1402 fz_outline *outline;
1403
1404 if (!state.needoutline) return;
1405
1406 state.needoutline = 0;
1407 switch (state.type) {
1408 case DPDF:
1409 outline = pdf_load_outline (state.u.pdf);
1410 break;
1411 case DXPS:
1412 outline = xps_load_outline (state.u.xps);
1413 break;
1414 default:
1415 outline = NULL;
1416 break;
1417 }
1418 if (outline) {
1419 recurse_outline (outline, 0);
1420 fz_free_outline (state.ctx, outline);
1421 }
1422 }
1423
1424 static char *strofspan (fz_text_span *span)
1425 {
1426 char *p;
1427 char utf8[10];
1428 fz_text_char *ch;
1429 size_t size = 0, cap = 80;
1430
1431 p = malloc (cap + 1);
1432 if (!p) return NULL;
1433
1434 for (ch = span->text; ch < span->text + span->len; ++ch) {
1435 int n = fz_runetochar (utf8, ch->c);
1436 if (size + n > cap) {
1437 cap *= 2;
1438 p = realloc (p, cap + 1);
1439 if (!p) return NULL;
1440 }
1441
1442 memcpy (p + size, utf8, n);
1443 size += n;
1444 }
1445 p[size] = 0;
1446 return p;
1447 }
1448
1449 static int matchspan (regex_t *re, fz_text_page *page,
1450 fz_text_span *span, fz_matrix ctm,
1451 int stop, int pageno, double start)
1452 {
1453 int ret;
1454 char *p;
1455 regmatch_t rm;
1456 int a, b, c;
1457 fz_rect sb, eb;
1458 fz_point p1, p2, p3, p4;
1459
1460 p = strofspan (span);
1461 if (!p) return -1;
1462
1463 ret = regexec (re, p, 1, &rm, 0);
1464 if (ret) {
1465 free (p);
1466 if (ret != REG_NOMATCH) {
1467 size_t size;
1468 char errbuf[80];
1469 size = regerror (ret, re, errbuf, sizeof (errbuf));
1470 printd ("msg regexec error `%.*s'",
1471 (int) size, errbuf);
1472 return -1;
1473 }
1474 return 0;
1475 }
1476 else {
1477 int l = span->len;
1478
1479 for (a = 0, c = 0; c < rm.rm_so && a < l; a++) {
1480 c += fz_runelen (span->text[a].c);
1481 }
1482 for (b = a; c < rm.rm_eo - 1 && b < l; b++) {
1483 c += fz_runelen (span->text[b].c);
1484 }
1485
1486 if (fz_runelen (span->text[b].c) > 1) {
1487 b = MAX (0, b-1);
1488 }
1489
1490 fz_text_char_bbox (&sb, span, a);
1491 fz_text_char_bbox (&eb, span, b);
1492
1493 p1.x = sb.x0;
1494 p1.y = sb.y0;
1495 p2.x = eb.x1;
1496 p2.y = sb.y0;
1497 p3.x = eb.x1;
1498 p3.y = eb.y1;
1499 p4.x = sb.x0;
1500 p4.y = eb.y1;
1501
1502 if (!stop) {
1503 printd ("firstmatch %d %d %f %f %f %f %f %f %f %f",
1504 pageno, 1,
1505 p1.x, p1.y,
1506 p2.x, p2.y,
1507 p3.x, p3.y,
1508 p4.x, p4.y);
1509
1510 printd ("progress 1 found at %d `%.*s' in %f sec",
1511 pageno + 1, (int) (rm.rm_eo - rm.rm_so), &p[rm.rm_so],
1512 now () - start);
1513 }
1514 else {
1515 printd ("match %d %d %f %f %f %f %f %f %f %f",
1516 pageno, 2,
1517 p1.x, p1.y,
1518 p2.x, p2.y,
1519 p3.x, p3.y,
1520 p4.x, p4.y);
1521 }
1522 free (p);
1523 return 1;
1524 }
1525 }
1526
1527 static int compareblocks (const void *l, const void *r)
1528 {
1529 fz_text_block const *ls = l;
1530 fz_text_block const* rs = r;
1531 return ls->bbox.y0 - rs->bbox.y0;
1532 }
1533
1534 /* wishful thinking function */
1535 static void search (regex_t *re, int pageno, int y, int forward)
1536 {
1537 int i, j;
1538 fz_matrix ctm;
1539 fz_device *tdev;
1540 union { void *ptr; pdf_page *pdfpage; xps_page *xpspage; } u;
1541 fz_text_page *text;
1542 fz_text_sheet *sheet;
1543 struct pagedim *pdim, *pdimprev;
1544 int stop = 0, niters = 0;
1545 double start, end;
1546
1547 if (!(state.type == DPDF || state.type == DXPS))
1548 return;
1549
1550 start = now ();
1551 while (pageno >= 0 && pageno < state.pagecount && !stop) {
1552 if (niters++ == 5) {
1553 niters = 0;
1554 if (hasdata ()) {
1555 printd ("progress 1 attention requested aborting search at %d",
1556 pageno);
1557 stop = 1;
1558 }
1559 else {
1560 printd ("progress %f searching in page %d",
1561 (double) (pageno + 1) / state.pagecount,
1562 pageno);
1563 }
1564 }
1565 pdimprev = NULL;
1566 for (i = 0; i < state.pagedimcount; ++i) {
1567 pdim = &state.pagedims[i];
1568 if (pdim->pageno == pageno) {
1569 goto found;
1570 }
1571 if (pdim->pageno > pageno) {
1572 pdim = pdimprev;
1573 goto found;
1574 }
1575 pdimprev = pdim;
1576 }
1577 pdim = pdimprev;
1578 found:
1579
1580 sheet = fz_new_text_sheet (state.ctx);
1581 text = fz_new_text_page (state.ctx);
1582 tdev = fz_new_text_device (state.ctx, sheet, text);
1583
1584 switch (state.type) {
1585 case DPDF:
1586 u.ptr = NULL;
1587 fz_try (state.ctx) {
1588 u.pdfpage = pdf_load_page (state.u.pdf, pageno);
1589 trimctm (u.pdfpage, pdim - state.pagedims);
1590 fz_concat (&ctm, &pdim->tctm, &pdim->zoomctm);
1591 fz_begin_page (tdev, &fz_infinite_rect, &ctm);
1592 pdf_run_page (state.u.pdf, u.pdfpage, tdev, &ctm, NULL);
1593 fz_end_page (tdev);
1594 }
1595 fz_catch (state.ctx) {
1596 fz_free_device (tdev);
1597 u.ptr = NULL;
1598 goto nextiter;
1599 }
1600 break;
1601
1602 case DXPS:
1603 u.xpspage = xps_load_page (state.u.xps, pageno);
1604 xps_run_page (state.u.xps, u.xpspage, tdev, &pdim->ctm, NULL);
1605 break;
1606
1607 default:
1608 ARSERT (0 && state.type);
1609 }
1610
1611 qsort (text->blocks, text->len, sizeof (*text->blocks), compareblocks);
1612 fz_free_device (tdev);
1613
1614 for (j = 0; j < text->len; ++j) {
1615 int k;
1616 fz_page_block *pb;
1617 fz_text_block *block;
1618
1619 pb = &text->blocks[forward ? j : text->len - 1 - j];
1620 if (pb->type != FZ_PAGE_BLOCK_TEXT) continue;
1621 block = pb->u.text;
1622
1623 for (k = 0; k < block->len; ++k) {
1624 fz_text_line *line;
1625 fz_text_span *span;
1626
1627 if (forward) {
1628 line = &block->lines[k];
1629 if (line->bbox.y0 < y + 1) continue;
1630 }
1631 else {
1632 line = &block->lines[block->len - 1 - k];
1633 if (line->bbox.y0 > y - 1) continue;
1634 }
1635
1636 for (span = line->first_span; span; span = span->next) {
1637 switch (matchspan (re, text, span, ctm,
1638 stop, pageno, start)) {
1639 case 0: break;
1640 case 1: stop = 1; break;
1641 case -1: stop = 1; goto endloop;
1642 }
1643 }
1644 }
1645 }
1646 nextiter:
1647 if (forward) {
1648 pageno += 1;
1649 y = 0;
1650 }
1651 else {
1652 pageno -= 1;
1653 y = INT_MAX;
1654 }
1655 endloop:
1656 fz_free_text_page (state.ctx, text);
1657 fz_free_text_sheet (state.ctx, sheet);
1658 if (u.ptr) {
1659 state.freepage (u.ptr);
1660 }
1661 }
1662 end = now ();
1663 if (!stop) {
1664 printd ("progress 1 no matches %f sec", end - start);
1665 }
1666 printd ("clearrects");
1667 }
1668
1669 static void set_tex_params (int colorspace)
1670 {
1671 union {
1672 unsigned char b;
1673 unsigned int s;
1674 } endianness = {1};
1675
1676 switch (colorspace) {
1677 case 0:
1678 state.texiform = GL_RGBA8;
1679 state.texform = GL_RGBA;
1680 state.texty = GL_UNSIGNED_BYTE;
1681 state.colorspace = fz_device_rgb (state.ctx);
1682 break;
1683 case 1:
1684 state.texiform = GL_RGBA8;
1685 state.texform = GL_BGRA;
1686 state.texty = endianness.s > 1
1687 ? GL_UNSIGNED_INT_8_8_8_8
1688 : GL_UNSIGNED_INT_8_8_8_8_REV;
1689 state.colorspace = fz_device_bgr (state.ctx);
1690 break;
1691 case 2:
1692 state.texiform = GL_LUMINANCE_ALPHA;
1693 state.texform = GL_LUMINANCE_ALPHA;
1694 state.texty = GL_UNSIGNED_BYTE;
1695 state.colorspace = fz_device_gray (state.ctx);
1696 break;
1697 default:
1698 errx (1, "invalid colorspce %d", colorspace);
1699 }
1700 }
1701
1702 static void realloctexts (int texcount)
1703 {
1704 size_t size;
1705
1706 if (texcount == state.texcount) return;
1707
1708 if (texcount < state.texcount) {
1709 glDeleteTextures (state.texcount - texcount,
1710 state.texids + texcount);
1711 }
1712
1713 size = texcount * sizeof (*state.texids);
1714 state.texids = realloc (state.texids, size);
1715 if (!state.texids) {
1716 err (1, "realloc texids %" FMT_s, size);
1717 }
1718
1719 size = texcount * sizeof (*state.texowners);
1720 state.texowners = realloc (state.texowners, size);
1721 if (!state.texowners) {
1722 err (1, "realloc texowners %" FMT_s, size);
1723 }
1724 if (texcount > state.texcount) {
1725 int i;
1726
1727 glGenTextures (texcount - state.texcount,
1728 state.texids + state.texcount);
1729 for (i = state.texcount; i < texcount; ++i) {
1730 state.texowners[i].w = -1;
1731 state.texowners[i].slice = NULL;
1732 }
1733 }
1734 state.texcount = texcount;
1735 state.texindex = 0;
1736 }
1737
1738 static char *mbtoutf8 (char *s)
1739 {
1740 char *p, *r;
1741 wchar_t *tmp;
1742 size_t i, ret, len;
1743
1744 len = mbstowcs (NULL, s, strlen (s));
1745 if (len == 0) {
1746 return s;
1747 }
1748 else {
1749 if (len == (size_t) -1) {
1750 return s;
1751 }
1752 }
1753
1754 tmp = malloc (len * sizeof (wchar_t));
1755 if (!tmp) {
1756 return s;
1757 }
1758
1759 ret = mbstowcs (tmp, s, len);
1760 if (ret == (size_t) -1) {
1761 free (tmp);
1762 return s;
1763 }
1764
1765 len = 0;
1766 for (i = 0; i < ret; ++i) {
1767 len += fz_runelen (tmp[i]);
1768 }
1769
1770 p = r = malloc (len + 1);
1771 if (!r) {
1772 free (tmp);
1773 return s;
1774 }
1775
1776 for (i = 0; i < ret; ++i) {
1777 p += fz_runetochar (p, tmp[i]);
1778 }
1779 *p = 0;
1780 free (tmp);
1781 return r;
1782 }
1783
1784 CAMLprim value ml_mbtoutf8 (value s_v)
1785 {
1786 CAMLparam1 (s_v);
1787 CAMLlocal1 (ret_v);
1788 char *s, *r;
1789
1790 s = String_val (s_v);
1791 r = mbtoutf8 (s);
1792 if (r == s) {
1793 ret_v = s_v;
1794 }
1795 else {
1796 ret_v = caml_copy_string (r);
1797 free (r);
1798 }
1799 CAMLreturn (ret_v);
1800 }
1801
1802 static void * mainloop (void *unused)
1803 {
1804 char *p = NULL;
1805 int len, ret, oldlen = 0;
1806
1807 for (;;) {
1808 len = readlen ();
1809 if (len == 0) {
1810 errx (1, "readlen returned 0");
1811 }
1812
1813 if (oldlen < len + 1) {
1814 p = realloc (p, len + 1);
1815 if (!p) {
1816 err (1, "realloc %d failed", len + 1);
1817 }
1818 oldlen = len + 1;
1819 }
1820 readdata (p, len);
1821 p[len] = 0;
1822
1823 if (!strncmp ("open", p, 4)) {
1824 int wthack, off, ok = 0;
1825 char *password;
1826 char *filename;
1827 char *utf8filename;
1828 size_t filenamelen;
1829
1830 ret = sscanf (p + 5, " %d %d %n", &wthack, &state.cxack, &off);
1831 if (ret != 2) {
1832 errx (1, "malformed open `%.*s' ret=%d", len, p, ret);
1833 }
1834
1835 filename = p + 5 + off;
1836 filenamelen = strlen (filename);
1837 password = filename + filenamelen + 1;
1838
1839 lock ("open");
1840 fz_try (state.ctx) {
1841 openxref (filename, password);
1842 ok = 1;
1843 }
1844 fz_catch (state.ctx) {
1845 utf8filename = mbtoutf8 (filename);
1846 printd ("msg Could not open %s", utf8filename);
1847 }
1848 if (ok) {
1849 pdfinfo ();
1850 initpdims ();
1851 }
1852 unlock ("open");
1853
1854 if (ok) {
1855 if (!wthack) {
1856 utf8filename = mbtoutf8 (filename);
1857 printd ("msg Opened %s (press h/F1 to get help)", utf8filename);
1858 if (utf8filename != filename) {
1859 free (utf8filename);
1860 }
1861 }
1862 state.needoutline = 1;
1863 }
1864 }
1865 else if (!strncmp ("cs", p, 2)) {
1866 int i, colorspace;
1867
1868 ret = sscanf (p + 2, " %d", &colorspace);
1869 if (ret != 1) {
1870 errx (1, "malformed cs `%.*s' ret=%d", len, p, ret);
1871 }
1872 lock ("cs");
1873 set_tex_params (colorspace);
1874 for (i = 0; i < state.texcount; ++i) {
1875 state.texowners[i].w = -1;
1876 state.texowners[i].slice = NULL;
1877 }
1878 unlock ("cs");
1879 }
1880 else if (!strncmp ("freepage", p, 8)) {
1881 void *ptr;
1882
1883 ret = sscanf (p + 8, " %" FMT_ptr, FMT_ptr_cast (&ptr));
1884 if (ret != 1) {
1885 errx (1, "malformed freepage `%.*s' ret=%d", len, p, ret);
1886 }
1887 freepage (ptr);
1888 }
1889 else if (!strncmp ("freetile", p, 8)) {
1890 void *ptr;
1891
1892 ret = sscanf (p + 8, " %" FMT_ptr, FMT_ptr_cast (&ptr));
1893 if (ret != 1) {
1894 errx (1, "malformed freetile `%.*s' ret=%d", len, p, ret);
1895 }
1896 freetile (ptr);
1897 }
1898 else if (!strncmp ("search", p, 6)) {
1899 int icase, pageno, y, ret, len2, forward;
1900 char *pattern;
1901 regex_t re;
1902
1903 ret = sscanf (p + 6, " %d %d %d %d,%n",
1904 &icase, &pageno, &y, &forward, &len2);
1905 if (ret != 4) {
1906 errx (1, "malformed search `%s' ret=%d", p, ret);
1907 }
1908
1909 pattern = p + 6 + len2;
1910 ret = regcomp (&re, pattern,
1911 REG_EXTENDED | (icase ? REG_ICASE : 0));
1912 if (ret) {
1913 char errbuf[80];
1914 size_t size;
1915
1916 size = regerror (ret, &re, errbuf, sizeof (errbuf));
1917 printd ("msg regcomp failed `%.*s'", (int) size, errbuf);
1918 }
1919 else {
1920 search (&re, pageno, y, forward);
1921 regfree (&re);
1922 }
1923 }
1924 else if (!strncmp ("geometry", p, 8)) {
1925 int w, h, fitmodel;
1926
1927 printd ("clear");
1928 ret = sscanf (p + 8, " %d %d %d", &w, &h, &fitmodel);
1929 if (ret != 3) {
1930 errx (1, "malformed geometry `%.*s' ret=%d", len, p, ret);
1931 }
1932
1933 lock ("geometry");
1934 state.h = h;
1935 if (w != state.w) {
1936 int i;
1937 state.w = w;
1938 for (i = 0; i < state.texcount; ++i) {
1939 state.texowners[i].slice = NULL;
1940 }
1941 }
1942 state.fitmodel = fitmodel;
1943 layout ();
1944 process_outline ();
1945
1946 state.gen++;
1947 unlock ("geometry");
1948 printd ("continue %d", state.pagecount);
1949 }
1950 else if (!strncmp ("reqlayout", p, 9)) {
1951 char *nameddest;
1952 int rotate, fitmodel, off, h;
1953
1954 printd ("clear");
1955 ret = sscanf (p + 9, " %d %d %d %n",
1956 &rotate, &fitmodel, &h, &off);
1957 if (ret != 3) {
1958 errx (1, "bad reqlayout line `%.*s' ret=%d", len, p, ret);
1959 }
1960 lock ("reqlayout");
1961 if (state.rotate != rotate || state.fitmodel != fitmodel) {
1962 state.gen += 1;
1963 }
1964 state.rotate = rotate;
1965 state.fitmodel = fitmodel;
1966 state.h = h;
1967 layout ();
1968 process_outline ();
1969
1970 nameddest = p + 9 + off;
1971 if (state.type == DPDF && nameddest && *nameddest) {
1972 struct anchor a;
1973 fz_link_dest dest;
1974 pdf_obj *needle, *obj;
1975
1976 needle = pdf_new_string (state.u.pdf, nameddest,
1977 strlen (nameddest));
1978 obj = pdf_lookup_dest (state.u.pdf, needle);
1979 if (obj) {
1980 dest = pdf_parse_link_dest (state.u.pdf, FZ_LINK_GOTO, obj);
1981
1982 a = desttoanchor (&dest);
1983 if (a.n >= 0) {
1984 printd ("a %d %d %d", a.n, a.x, a.y);
1985 }
1986 else {
1987 printd ("emsg failed to parse destination `%s'\n",
1988 nameddest);
1989 }
1990 }
1991 else {
1992 printd ("emsg destination `%s' not found\n",
1993 nameddest);
1994 }
1995 pdf_drop_obj (needle);
1996 }
1997
1998 state.gen++;
1999 unlock ("reqlayout");
2000 printd ("continue %d", state.pagecount);
2001 }
2002 else if (!strncmp ("page", p, 4)) {
2003 double a, b;
2004 struct page *page;
2005 int pageno, pindex, ret;
2006
2007 ret = sscanf (p + 4, " %d %d", &pageno, &pindex);
2008 if (ret != 2) {
2009 errx (1, "bad page line `%.*s' ret=%d", len, p, ret);
2010 }
2011
2012 lock ("page");
2013 a = now ();
2014 page = loadpage (pageno, pindex);
2015 b = now ();
2016 unlock ("page");
2017
2018 printd ("page %" FMT_ptr " %f", FMT_ptr_cast2 (page), b - a);
2019 }
2020 else if (!strncmp ("tile", p, 4)) {
2021 int x, y, w, h, ret;
2022 struct page *page;
2023 struct tile *tile;
2024 double a, b;
2025 void *data;
2026
2027 ret = sscanf (p + 4, " %" FMT_ptr " %d %d %d %d %" FMT_ptr,
2028 FMT_ptr_cast (&page), &x, &y, &w, &h, &data);
2029 if (ret != 6) {
2030 errx (1, "bad tile line `%.*s' ret=%d", len, p, ret);
2031 }
2032
2033 lock ("tile");
2034 a = now ();
2035 tile = rendertile (page, x, y, w, h, data);
2036 b = now ();
2037 unlock ("tile");
2038
2039 printd ("tile %d %d %" FMT_ptr " %u %f",
2040 x, y,
2041 FMT_ptr_cast2 (tile),
2042 tile->w * tile->h * tile->pixmap->n,
2043 b - a);
2044 }
2045 else if (!strncmp ("settrim", p, 7)) {
2046 fz_irect fuzz;
2047 int trimmargins;
2048
2049 ret = sscanf (p + 7, " %d %d %d %d %d",
2050 &trimmargins, &fuzz.x0, &fuzz.y0, &fuzz.x1, &fuzz.y1);
2051 if (ret != 5) {
2052 errx (1, "malformed settrim `%.*s' ret=%d", len, p, ret);
2053 }
2054 printd ("clear");
2055 lock ("settrim");
2056 state.trimmargins = trimmargins;
2057 state.needoutline = 1;
2058 if (memcmp (&fuzz, &state.trimfuzz, sizeof (fuzz))) {
2059 state.trimanew = 1;
2060 state.trimfuzz = fuzz;
2061 }
2062 state.pagedimcount = 0;
2063 free (state.pagedims);
2064 state.pagedims = NULL;
2065 initpdims ();
2066 layout ();
2067 process_outline ();
2068 unlock ("settrim");
2069 printd ("continue %d", state.pagecount);
2070 }
2071 else if (!strncmp ("sliceh", p, 6)) {
2072 int h;
2073
2074 ret = sscanf (p + 6, " %d", &h);
2075 if (ret != 1) {
2076 errx (1, "malformed sliceh `%.*s' ret=%d", len, p, ret);
2077 }
2078 if (h != state.sliceheight) {
2079 int i;
2080
2081 state.sliceheight = h;
2082 for (i = 0; i < state.texcount; ++i) {
2083 state.texowners[i].w = -1;
2084 state.texowners[i].h = -1;
2085 state.texowners[i].slice = NULL;
2086 }
2087 }
2088 }
2089 else if (!strncmp ("interrupt", p, 9)) {
2090 printd ("vmsg interrupted");
2091 }
2092 else {
2093 errx (1, "unknown command %.*s", len, p);
2094 }
2095 }
2096 return 0;
2097 }
2098
2099 CAMLprim value ml_realloctexts (value texcount_v)
2100 {
2101 CAMLparam1 (texcount_v);
2102 int ok;
2103
2104 if (trylock ("ml_realloctexts")) {
2105 ok = 0;
2106 goto done;
2107 }
2108 realloctexts (Int_val (texcount_v));
2109 ok = 1;
2110 unlock ("ml_realloctexts");
2111
2112 done:
2113 CAMLreturn (Val_bool (ok));
2114 }
2115
2116 static void recti (int x0, int y0, int x1, int y1)
2117 {
2118 GLfloat *v = state.vertices;
2119
2120 glVertexPointer (2, GL_FLOAT, 0, v);
2121 v[0] = x0; v[1] = y0;
2122 v[2] = x1; v[3] = y0;
2123 v[4] = x0; v[5] = y1;
2124 v[6] = x1; v[7] = y1;
2125 glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
2126 }
2127
2128 static void showsel (struct page *page, int ox, int oy)
2129 {
2130 int seen = 0;
2131 fz_irect bbox;
2132 fz_rect rect;
2133 fz_text_line *line;
2134 fz_page_block *pageb;
2135 fz_text_block *block;
2136 struct mark first, last;
2137 unsigned char selcolor[] = {15,15,15,140};
2138
2139 first = page->fmark;
2140 last = page->lmark;
2141
2142 if (!first.span || !last.span) return;
2143
2144 glEnable (GL_BLEND);
2145 glBlendFunc (GL_SRC_ALPHA, GL_SRC_ALPHA);
2146 glColor4ubv (selcolor);
2147
2148 ox += state.pagedims[page->pdimno].bounds.x0;
2149 oy += state.pagedims[page->pdimno].bounds.y0;
2150 for (pageb = page->text->blocks;
2151 pageb < page->text->blocks + page->text->len;
2152 ++pageb) {
2153 if (pageb->type != FZ_PAGE_BLOCK_TEXT) continue;
2154 block = pageb->u.text;
2155
2156 for (line = block->lines;
2157 line < block->lines + block->len;
2158 ++line) {
2159 fz_text_span *span;
2160 rect = fz_empty_rect;
2161
2162 for (span = line->first_span; span; span = span->next) {
2163 int i, j, k;
2164 bbox.x0 = bbox.y0 = bbox.x1 = bbox.y1 = 0;
2165
2166 j = 0;
2167 k = span->len - 1;
2168
2169 if (span == page->fmark.span && span == page->lmark.span) {
2170 seen = 1;
2171 j = MIN (first.i, last.i);
2172 k = MAX (first.i, last.i);
2173 }
2174 else {
2175 if (span == first.span) {
2176 seen = 1;
2177 j = first.i;
2178 }
2179 else if (span == last.span) {
2180 seen = 1;
2181 k = last.i;
2182 }
2183 }
2184
2185 if (seen) {
2186 for (i = j; i <= k; ++i) {
2187 fz_rect bbox;
2188 fz_union_rect (&rect,
2189 fz_text_char_bbox (&bbox, span, i));
2190 }
2191 fz_round_rect (&bbox, &rect);
2192 lprintf ("%d %d %d %d oy=%d ox=%d\n",
2193 bbox.x0,
2194 bbox.y0,
2195 bbox.x1,
2196 bbox.y1,
2197 oy, ox);
2198
2199 recti (bbox.x0 + ox, bbox.y0 + oy,
2200 bbox.x1 + ox, bbox.y1 + oy);
2201 if (span == last.span) {
2202 goto done;
2203 }
2204 rect = fz_empty_rect;
2205 }
2206 }
2207 }
2208 }
2209 done:
2210 glDisable (GL_BLEND);
2211 }
2212
2213 #include "glfont.c"
2214
2215 static void highlightlinks (struct page *page, int xoff, int yoff)
2216 {
2217 fz_matrix ctm, tm, pm;
2218 fz_link *link, *links;
2219 GLfloat *texcoords = state.texcoords;
2220 GLfloat *vertices = state.vertices;
2221
2222 switch (page->type) {
2223 case DPDF:
2224 links = page->u.pdfpage->links;
2225 break;
2226
2227 case DXPS:
2228 links = page->u.xpspage->links;
2229 break;
2230
2231 default:
2232 return;
2233 }
2234
2235 glEnable (GL_TEXTURE_1D);
2236 glEnable (GL_BLEND);
2237 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2238 glBindTexture (GL_TEXTURE_1D, state.stid);
2239
2240 xoff -= state.pagedims[page->pdimno].bounds.x0;
2241 yoff -= state.pagedims[page->pdimno].bounds.y0;
2242 fz_translate (&tm, xoff, yoff);
2243 pm = pagectm (page);
2244 fz_concat (&ctm, &pm, &tm);
2245
2246 glTexCoordPointer (1, GL_FLOAT, 0, texcoords);
2247 glVertexPointer (2, GL_FLOAT, 0, vertices);
2248
2249 for (link = links; link; link = link->next) {
2250 fz_point p1, p2, p3, p4;
2251
2252 p1.x = link->rect.x0;
2253 p1.y = link->rect.y0;
2254
2255 p2.x = link->rect.x1;
2256 p2.y = link->rect.y0;
2257
2258 p3.x = link->rect.x1;
2259 p3.y = link->rect.y1;
2260
2261 p4.x = link->rect.x0;
2262 p4.y = link->rect.y1;
2263
2264 fz_transform_point (&p1, &ctm);
2265 fz_transform_point (&p2, &ctm);
2266 fz_transform_point (&p3, &ctm);
2267 fz_transform_point (&p4, &ctm);
2268
2269 switch (link->dest.kind) {
2270 case FZ_LINK_GOTO: glColor3ub (255, 0, 0); break;
2271 case FZ_LINK_URI: glColor3ub (0, 0, 255); break;
2272 case FZ_LINK_LAUNCH: glColor3ub (0, 255, 0); break;
2273 default: glColor3ub (0, 0, 0); break;
2274 }
2275
2276 {
2277 float w, h, s, t;
2278
2279 w = p2.x - p1.x;
2280 h = p2.y - p1.y;
2281 t = sqrtf (w*w + h*h) * .25f;
2282
2283 w = p3.x - p2.x;
2284 h = p3.y - p2.y;
2285 s = sqrtf (w*w + h*h) * .25f;
2286
2287 texcoords[0] = 0; vertices[0] = p1.x; vertices[1] = p1.y;
2288 texcoords[1] = t; vertices[2] = p2.x; vertices[3] = p2.y;
2289
2290 texcoords[2] = 0; vertices[4] = p2.x; vertices[5] = p2.y;
2291 texcoords[3] = s; vertices[6] = p3.x; vertices[7] = p3.y;
2292
2293 texcoords[4] = 0; vertices[8] = p3.x; vertices[9] = p3.y;
2294 texcoords[5] = t; vertices[10] = p4.x; vertices[11] = p4.y;
2295
2296 texcoords[6] = 0; vertices[12] = p4.x; vertices[13] = p4.y;
2297 texcoords[7] = s; vertices[14] = p1.x; vertices[15] = p1.y;
2298 }
2299 glDrawArrays (GL_LINES, 0, 8);
2300 }
2301
2302 glDisable (GL_BLEND);
2303 glDisable (GL_TEXTURE_1D);
2304 }
2305
2306 static int compareslinks (const void *l, const void *r)
2307 {
2308 struct slink const *ls = l;
2309 struct slink const *rs = r;
2310 if (ls->bbox.y0 == rs->bbox.y0) {
2311 return rs->bbox.x0 - rs->bbox.x0;
2312 }
2313 return ls->bbox.y0 - rs->bbox.y0;
2314 }
2315
2316 static void droptext (struct page *page)
2317 {
2318 if (page->text) {
2319 fz_free_text_page (state.ctx, page->text);
2320 page->fmark.i = -1;
2321 page->lmark.i = -1;
2322 page->fmark.span = NULL;
2323 page->lmark.span = NULL;
2324 page->text = NULL;
2325 }
2326 if (page->sheet) {
2327 fz_free_text_sheet (state.ctx, page->sheet);
2328 page->sheet = NULL;
2329 }
2330 }
2331
2332 static void dropslinks (struct page *page)
2333 {
2334 if (page->slinks) {
2335 free (page->slinks);
2336 page->slinks = NULL;
2337 page->slinkcount = 0;
2338 }
2339 }
2340
2341 static void ensureslinks (struct page *page)
2342 {
2343 fz_matrix ctm;
2344 int i, count = 0;
2345 size_t slinksize = sizeof (*page->slinks);
2346 fz_link *link, *links;
2347
2348 if (state.gen != page->sgen) {
2349 dropslinks (page);
2350 page->sgen = state.gen;
2351 }
2352 if (page->slinks) return;
2353
2354 switch (page->type) {
2355 case DPDF:
2356 links = page->u.pdfpage->links;
2357 trimctm (page->u.pdfpage, page->pdimno);
2358 fz_concat (&ctm,
2359 &state.pagedims[page->pdimno].tctm,
2360 &state.pagedims[page->pdimno].ctm);
2361 break;
2362
2363 case DXPS:
2364 links = page->u.xpspage->links;
2365 ctm = state.pagedims[page->pdimno].ctm;
2366 break;
2367
2368 default:
2369 return;
2370 }
2371
2372 for (link = links; link; link = link->next) {
2373 count++;
2374 }
2375 if (count > 0) {
2376 page->slinkcount = count;
2377 page->slinks = calloc (count, slinksize);
2378 if (!page->slinks) {
2379 err (1, "realloc slinks %d", count);
2380 }
2381
2382 for (i = 0, link = links; link; ++i, link = link->next) {
2383 fz_rect rect;
2384
2385 rect = link->rect;
2386 fz_transform_rect (&rect, &ctm);
2387 page->slinks[i].link = link;
2388 fz_round_rect (&page->slinks[i].bbox, &rect);
2389 }
2390 qsort (page->slinks, count, slinksize, compareslinks);
2391 }
2392 }
2393
2394 /* slightly tweaked fmt_ulong by D.J. Bernstein */
2395 static void fmt_linkn (char *s, unsigned int u)
2396 {
2397 unsigned int len; unsigned int q;
2398 int zma = 'z' - 'a' + 1;
2399 len = 1; q = u;
2400 while (q > zma - 1) { ++len; q /= zma; }
2401 if (s) {
2402 s += len;
2403 do { *--s = 'a' + (u % zma) - (u < zma && len > 1); u /= zma; } while(u);
2404 /* handles u == 0 */
2405 }
2406 s[len] = 0;
2407 }
2408
2409 static void highlightslinks (struct page *page, int xoff, int yoff,
2410 int noff, char *targ, int tlen, int hfsize)
2411 {
2412 int i;
2413 char buf[40];
2414 struct slink *slink;
2415 double x0, y0, x1, y1, w;
2416
2417 ensureslinks (page);
2418 glColor3ub (0xc3, 0xb0, 0x91);
2419 for (i = 0; i < page->slinkcount; ++i) {
2420 fmt_linkn (buf, i + noff);
2421 if (!tlen || !strncmp (targ, buf, tlen)) {
2422 slink = &page->slinks[i];
2423
2424 x0 = slink->bbox.x0 + xoff - 5;
2425 y1 = slink->bbox.y0 + yoff - 5;
2426 y0 = y1 + 10 + hfsize;
2427 w = measure_string (state.face, hfsize, buf);
2428 x1 = x0 + w + 10;
2429 recti (x0, y0, x1, y1);
2430 }
2431 }
2432
2433 glEnable (GL_BLEND);
2434 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2435 glEnable (GL_TEXTURE_2D);
2436 glColor3ub (0, 0, 0);
2437 for (i = 0; i < page->slinkcount; ++i) {
2438 fmt_linkn (buf, i + noff);
2439 if (!tlen || !strncmp (targ, buf, tlen)) {
2440 slink = &page->slinks[i];
2441
2442 x0 = slink->bbox.x0 + xoff;
2443 y0 = slink->bbox.y0 + yoff + hfsize;
2444 draw_string (state.face, hfsize, x0, y0, buf);
2445 }
2446 }
2447 glDisable (GL_TEXTURE_2D);
2448 glDisable (GL_BLEND);
2449 }
2450
2451 static void uploadslice (struct tile *tile, struct slice *slice)
2452 {
2453 int offset;
2454 struct slice *slice1;
2455 unsigned char *texdata;
2456
2457 offset = 0;
2458 for (slice1 = tile->slices; slice != slice1; slice1++) {
2459 offset += slice1->h * tile->w * tile->pixmap->n;
2460 }
2461 if (slice->texindex != -1 && slice->texindex < state.texcount
2462 && state.texowners[slice->texindex].slice == slice) {
2463 glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
2464 }
2465 else {
2466 int subimage = 0;
2467 int texindex = state.texindex++ % state.texcount;
2468
2469 if (state.texowners[texindex].w == tile->w) {
2470 if (state.texowners[texindex].h >= slice->h) {
2471 subimage = 1;
2472 }
2473 else {
2474 state.texowners[texindex].h = slice->h;
2475 }
2476 }
2477 else {
2478 state.texowners[texindex].h = slice->h;
2479 }
2480
2481 state.texowners[texindex].w = tile->w;
2482 state.texowners[texindex].slice = slice;
2483 slice->texindex = texindex;
2484
2485 glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[texindex]);
2486 if (tile->pbo) {
2487 state.glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB, tile->pbo->id);
2488 texdata = 0;
2489 }
2490 else {
2491 texdata = tile->pixmap->samples;
2492 }
2493 if (subimage) {
2494 glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB,
2495 0,
2496 0,
2497 0,
2498 tile->w,
2499 slice->h,
2500 state.texform,
2501 state.texty,
2502 texdata+offset
2503 );
2504 }
2505 else {
2506 glTexImage2D (GL_TEXTURE_RECTANGLE_ARB,
2507 0,
2508 state.texiform,
2509 tile->w,
2510 slice->h,
2511 0,
2512 state.texform,
2513 state.texty,
2514 texdata+offset
2515 );
2516 }
2517 if (tile->pbo) {
2518 state.glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB, 0);
2519 }
2520 }
2521 }
2522
2523 CAMLprim value ml_begintiles (value unit_v)
2524 {
2525 CAMLparam1 (unit_v);
2526 glEnable (GL_TEXTURE_RECTANGLE_ARB);
2527 glTexCoordPointer (2, GL_FLOAT, 0, state.texcoords);
2528 glVertexPointer (2, GL_FLOAT, 0, state.vertices);
2529 CAMLreturn (unit_v);
2530 }
2531
2532 CAMLprim value ml_endtiles (value unit_v)
2533 {
2534 CAMLparam1 (unit_v);
2535 glDisable (GL_TEXTURE_RECTANGLE_ARB);
2536 CAMLreturn (unit_v);
2537 }
2538
2539 CAMLprim value ml_drawtile (value args_v, value ptr_v)
2540 {
2541 CAMLparam2 (args_v, ptr_v);
2542 int dispx = Int_val (Field (args_v, 0));
2543 int dispy = Int_val (Field (args_v, 1));
2544 int dispw = Int_val (Field (args_v, 2));
2545 int disph = Int_val (Field (args_v, 3));
2546 int tilex = Int_val (Field (args_v, 4));
2547 int tiley = Int_val (Field (args_v, 5));
2548 char *s = String_val (ptr_v);
2549 struct tile *tile = parse_pointer ("ml_drawtile", s);
2550 int slicey, firstslice;
2551 struct slice *slice;
2552 GLfloat *texcoords = state.texcoords;
2553 GLfloat *vertices = state.vertices;
2554
2555 firstslice = tiley / tile->sliceheight;
2556 slice = &tile->slices[firstslice];
2557 slicey = tiley % tile->sliceheight;
2558
2559 while (disph > 0) {
2560 int dh;
2561
2562 dh = slice->h - slicey;
2563 dh = MIN (disph, dh);
2564 uploadslice (tile, slice);
2565
2566 texcoords[0] = tilex; texcoords[1] = slicey;
2567 texcoords[2] = tilex+dispw; texcoords[3] = slicey;
2568 texcoords[4] = tilex; texcoords[5] = slicey+dh;
2569 texcoords[6] = tilex+dispw; texcoords[7] = slicey+dh;
2570
2571 vertices[0] = dispx; vertices[1] = dispy;
2572 vertices[2] = dispx+dispw; vertices[3] = dispy;
2573 vertices[4] = dispx; vertices[5] = dispy+dh;
2574 vertices[6] = dispx+dispw; vertices[7] = dispy+dh;
2575
2576 glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
2577 dispy += dh;
2578 disph -= dh;
2579 slice++;
2580 ARSERT (!(slice - tile->slices >= tile->slicecount && disph > 0));
2581 slicey = 0;
2582 }
2583 CAMLreturn (Val_unit);
2584 }
2585
2586 CAMLprim value ml_postprocess (value ptr_v, value hlinks_v,
2587 value xoff_v, value yoff_v,
2588 value li_v)
2589 {
2590 CAMLparam5 (ptr_v, hlinks_v, xoff_v, yoff_v, li_v);
2591 int xoff = Int_val (xoff_v);
2592 int yoff = Int_val (yoff_v);
2593 int noff = Int_val (Field (li_v, 0));
2594 char *targ = String_val (Field (li_v, 1));
2595 int tlen = caml_string_length (Field (li_v, 1));
2596 int hfsize = Int_val (Field (li_v, 2));
2597 char *s = String_val (ptr_v);
2598 int hlmask = Int_val (hlinks_v);
2599 struct page *page = parse_pointer ("ml_postprocess", s);
2600
2601 if (!page->u.ptr) {
2602 /* deal with loadpage failed pages */
2603 goto done;
2604 }
2605
2606 if (hlmask & 1) highlightlinks (page, xoff, yoff);
2607 if (trylock ("ml_postprocess")) {
2608 noff = 0;
2609 goto done;
2610 }
2611 if (hlmask & 2) {
2612 highlightslinks (page, xoff, yoff, noff, targ, tlen, hfsize);
2613 noff = page->slinkcount;
2614 }
2615 if (page->tgen == state.gen) {
2616 showsel (page, xoff, yoff);
2617 }
2618 unlock ("ml_postprocess");
2619
2620 done:
2621 CAMLreturn (Val_int (noff));
2622 }
2623
2624 static fz_link *getlink (struct page *page, int x, int y)
2625 {
2626 fz_point p;
2627 fz_matrix ctm;
2628 const fz_matrix *tctm;
2629 fz_link *link, *links;
2630
2631 switch (page->type) {
2632 case DPDF:
2633 trimctm (page->u.pdfpage, page->pdimno);
2634 tctm = &state.pagedims[page->pdimno].tctm;
2635 links = page->u.pdfpage->links;
2636 break;
2637
2638 case DXPS:
2639 tctm = &fz_identity;
2640 links = page->u.xpspage->links;
2641 break;
2642
2643 default:
2644 return NULL;
2645 }
2646 p.x = x;
2647 p.y = y;
2648
2649 fz_concat (&ctm, tctm, &state.pagedims[page->pdimno].ctm);
2650 fz_invert_matrix (&ctm, &ctm);
2651 fz_transform_point (&p, &ctm);
2652
2653 for (link = links; link; link = link->next) {
2654 if (p.x >= link->rect.x0 && p.x <= link->rect.x1) {
2655 if (p.y >= link->rect.y0 && p.y <= link->rect.y1) {
2656 return link;
2657 }
2658 }
2659 }
2660 return NULL;
2661 }
2662
2663 static void ensuretext (struct page *page)
2664 {
2665 if (state.gen != page->tgen) {
2666 droptext (page);
2667 page->tgen = state.gen;
2668 }
2669 if (!page->text) {
2670 fz_matrix ctm;
2671 fz_device *tdev;
2672
2673 page->text = fz_new_text_page (state.ctx);
2674 page->sheet = fz_new_text_sheet (state.ctx);
2675 tdev = fz_new_text_device (state.ctx, page->sheet, page->text);
2676 ctm = pagectm (page);
2677 fz_begin_page (tdev, &fz_infinite_rect, &ctm);
2678 fz_run_display_list (page->dlist, tdev, &ctm, &fz_infinite_rect, NULL);
2679 qsort (page->text->blocks, page->text->len,
2680 sizeof (*page->text->blocks), compareblocks);
2681 fz_end_page (tdev);
2682 fz_free_device (tdev);
2683 }
2684 }
2685
2686 CAMLprim value ml_find_page_with_links (value start_page_v, value dir_v)
2687 {
2688 CAMLparam2 (start_page_v, dir_v);
2689 CAMLlocal1 (ret_v);
2690 int i, dir = Int_val (dir_v);
2691 int start_page = Int_val (start_page_v);
2692 int end_page = dir > 0 ? state.pagecount : -1;
2693
2694 ret_v = Val_int (0);
2695 if (!(state.type == DPDF || state.type == DXPS)) {
2696 goto done;
2697 }
2698
2699 lock ("ml_findpage_with_links");
2700 for (i = start_page + dir; i != end_page; i += dir) {
2701 int found;
2702
2703 switch (state.type) {
2704 case DPDF:
2705 {
2706 pdf_page *page = NULL;
2707
2708 fz_try (state.ctx) {
2709 page = pdf_load_page (state.u.pdf, i);
2710 found = !!page->links;
2711 }
2712 fz_catch (state.ctx) {
2713 found = 0;
2714 }
2715 if (page) {
2716 freepdfpage (page);
2717 }
2718 }
2719 break;
2720 case DXPS:
2721 {
2722 xps_page *page = xps_load_page (state.u.xps, i);
2723 found = !!page->links;
2724 freexpspage (page);
2725 }
2726 break;
2727
2728 default:
2729 ARSERT (0 && "invalid document type");
2730 }
2731
2732 if (found) {
2733 ret_v = caml_alloc_small (1, 1);
2734 Field (ret_v, 0) = Val_int (i);
2735 goto unlock;
2736 }
2737 }
2738 unlock:
2739 unlock ("ml_findpage_with_links");
2740
2741 done:
2742 CAMLreturn (ret_v);
2743 }
2744
2745 enum { dir_first, dir_last };
2746 enum { dir_first_visible, dir_left, dir_right, dir_down, dir_up };
2747
2748 CAMLprim value ml_findlink (value ptr_v, value dir_v)
2749 {
2750 CAMLparam2 (ptr_v, dir_v);
2751 CAMLlocal2 (ret_v, pos_v);
2752 struct page *page;
2753 int dirtag, i, slinkindex;
2754 struct slink *found = NULL ,*slink;
2755 char *s = String_val (ptr_v);
2756
2757 page = parse_pointer ("ml_findlink", s);
2758 ret_v = Val_int (0);
2759 if (trylock ("ml_findlink")) {
2760 goto done;
2761 }
2762
2763 ensureslinks (page);
2764
2765 if (Is_block (dir_v)) {
2766 dirtag = Tag_val (dir_v);
2767 switch (dirtag) {
2768 case dir_first_visible:
2769 {
2770 int x0, y0, dir, first_index, last_index;
2771
2772 pos_v = Field (dir_v, 0);
2773 x0 = Int_val (Field (pos_v, 0));
2774 y0 = Int_val (Field (pos_v, 1));
2775 dir = Int_val (Field (pos_v, 2));
2776
2777 if (dir >= 0) {
2778 dir = 1;
2779 first_index = 0;
2780 last_index = page->slinkcount;
2781 }
2782 else {
2783 first_index = page->slinkcount - 1;
2784 last_index = -1;
2785 }
2786
2787 for (i = first_index; i != last_index; i += dir) {
2788 slink = &page->slinks[i];
2789 if (slink->bbox.y0 >= y0 && slink->bbox.x0 >= x0) {
2790 found = slink;
2791 break;
2792 }
2793 }
2794 }
2795 break;
2796
2797 case dir_left:
2798 slinkindex = Int_val (Field (dir_v, 0));
2799 found = &page->slinks[slinkindex];
2800 for (i = slinkindex - 1; i >= 0; --i) {
2801 slink = &page->slinks[i];
2802 if (slink->bbox.x0 < found->bbox.x0) {
2803 found = slink;
2804 break;
2805 }
2806 }
2807 break;
2808
2809 case dir_right:
2810 slinkindex = Int_val (Field (dir_v, 0));
2811 found = &page->slinks[slinkindex];
2812 for (i = slinkindex + 1; i < page->slinkcount; ++i) {
2813 slink = &page->slinks[i];
2814 if (slink->bbox.x0 > found->bbox.x0) {
2815 found = slink;
2816 break;
2817 }
2818 }
2819 break;
2820
2821 case dir_down:
2822 slinkindex = Int_val (Field (dir_v, 0));
2823 found = &page->slinks[slinkindex];
2824 for (i = slinkindex + 1; i < page->slinkcount; ++i) {
2825 slink = &page->slinks[i];
2826 if (slink->bbox.y0 >= found->bbox.y0) {
2827 found = slink;
2828 break;
2829 }
2830 }
2831 break;
2832
2833 case dir_up:
2834 slinkindex = Int_val (Field (dir_v, 0));
2835 found = &page->slinks[slinkindex];
2836 for (i = slinkindex - 1; i >= 0; --i) {
2837 slink = &page->slinks[i];
2838 if (slink->bbox.y0 <= found->bbox.y0) {
2839 found = slink;
2840 break;
2841 }
2842 }
2843 break;
2844 }
2845 }
2846 else {
2847 dirtag = Int_val (dir_v);
2848 switch (dirtag) {
2849 case dir_first:
2850 found = page->slinks;
2851 break;
2852
2853 case dir_last:
2854 if (page->slinks) {
2855 found = page->slinks + (page->slinkcount - 1);
2856 }
2857 break;
2858 }
2859 }
2860 if (found) {
2861 ret_v = caml_alloc_small (2, 1);
2862 Field (ret_v, 0) = Val_int (found - page->slinks);
2863 }
2864
2865 unlock ("ml_findlink");
2866 done:
2867 CAMLreturn (ret_v);
2868 }
2869
2870 enum { uuri, ugoto, utext, uunexpected,
2871 ulaunch, unamed, uremote, uremotedest };
2872
2873 #define LINKTOVAL \
2874 { \
2875 int pageno; \
2876 \
2877 switch (link->dest.kind) { \
2878 case FZ_LINK_GOTO: \
2879 { \
2880 fz_point p; \
2881 \
2882 pageno = link->dest.ld.gotor.page; \
2883 p.x = 0; \
2884 p.y = 0; \
2885 \
2886 if (link->dest.ld.gotor.flags & fz_link_flag_t_valid) { \
2887 p.y = link->dest.ld.gotor.lt.y; \
2888 fz_transform_point (&p, &pdim->lctm); \
2889 } \
2890 tup_v = caml_alloc_tuple (2); \
2891 ret_v = caml_alloc_small (1, ugoto); \
2892 Field (tup_v, 0) = Val_int (pageno); \
2893 Field (tup_v, 1) = Val_int (p.y); \
2894 Field (ret_v, 0) = tup_v; \
2895 } \
2896 break; \
2897 \
2898 case FZ_LINK_URI: \
2899 str_v = caml_copy_string (link->dest.ld.uri.uri); \
2900 ret_v = caml_alloc_small (1, uuri); \
2901 Field (ret_v, 0) = str_v; \
2902 break; \
2903 \
2904 case FZ_LINK_LAUNCH: \
2905 str_v = caml_copy_string (link->dest.ld.launch.file_spec); \
2906 ret_v = caml_alloc_small (1, ulaunch); \
2907 Field (ret_v, 0) = str_v; \
2908 break; \
2909 \
2910 case FZ_LINK_NAMED: \
2911 str_v = caml_copy_string (link->dest.ld.named.named); \
2912 ret_v = caml_alloc_small (1, unamed); \
2913 Field (ret_v, 0) = str_v; \
2914 break; \
2915 \
2916 case FZ_LINK_GOTOR: \
2917 { \
2918 int rty; \
2919 \
2920 str_v = caml_copy_string (link->dest.ld.gotor.file_spec); \
2921 pageno = link->dest.ld.gotor.page; \
2922 if (pageno == -1) { \
2923 gr_v = caml_copy_string (link->dest.ld.gotor.dest); \
2924 rty = uremotedest; \
2925 } \
2926 else { \
2927 gr_v = Val_int (pageno); \
2928 rty = uremote; \
2929 } \
2930 tup_v = caml_alloc_tuple (2); \
2931 ret_v = caml_alloc_small (1, rty); \
2932 Field (tup_v, 0) = str_v; \
2933 Field (tup_v, 1) = gr_v; \
2934 Field (ret_v, 0) = tup_v; \
2935 } \
2936 break; \
2937 \
2938 default: \
2939 { \
2940 char buf[80]; \
2941 \
2942 snprintf (buf, sizeof (buf), \
2943 "unhandled link kind %d", link->dest.kind); \
2944 str_v = caml_copy_string (buf); \
2945 ret_v = caml_alloc_small (1, uunexpected); \
2946 Field (ret_v, 0) = str_v; \
2947 } \
2948 break; \
2949 } \
2950 }
2951
2952 CAMLprim value ml_getlink (value ptr_v, value n_v)
2953 {
2954 CAMLparam2 (ptr_v, n_v);
2955 CAMLlocal4 (ret_v, tup_v, str_v, gr_v);
2956 fz_link *link;
2957 struct page *page;
2958 struct pagedim *pdim;
2959 char *s = String_val (ptr_v);
2960
2961 ret_v = Val_int (0);
2962 if (trylock ("ml_getlink")) {
2963 goto done;
2964 }
2965
2966 page = parse_pointer ("ml_getlink", s);
2967 ensureslinks (page);
2968 pdim = &state.pagedims[page->pdimno];
2969 link = page->slinks[Int_val (n_v)].link;
2970 LINKTOVAL;
2971
2972 unlock ("ml_getlink");
2973 done:
2974 CAMLreturn (ret_v);
2975 }
2976
2977 CAMLprim value ml_getlinkcount (value ptr_v)
2978 {
2979 CAMLparam1 (ptr_v);
2980 struct page *page;
2981 char *s = String_val (ptr_v);
2982
2983 page = parse_pointer ("ml_getlinkcount", s);
2984 CAMLreturn (Val_int (page->slinkcount));
2985 }
2986
2987 CAMLprim value ml_getlinkrect (value ptr_v, value n_v)
2988 {
2989 CAMLparam2 (ptr_v, n_v);
2990 CAMLlocal1 (ret_v);
2991 struct page *page;
2992 struct slink *slink;
2993 char *s = String_val (ptr_v);
2994
2995 page = parse_pointer ("ml_getlinkrect", s);
2996 ret_v = caml_alloc_tuple (4);
2997 if (trylock ("ml_getlinkrect")) {
2998 Field (ret_v, 0) = Val_int (0);
2999 Field (ret_v, 1) = Val_int (0);
3000 Field (ret_v, 2) = Val_int (0);
3001 Field (ret_v, 3) = Val_int (0);
3002 goto done;
3003 }
3004 ensureslinks (page);
3005
3006 slink = &page->slinks[Int_val (n_v)];
3007 Field (ret_v, 0) = Val_int (slink->bbox.x0);
3008 Field (ret_v, 1) = Val_int (slink->bbox.y0);
3009 Field (ret_v, 2) = Val_int (slink->bbox.x1);
3010 Field (ret_v, 3) = Val_int (slink->bbox.y1);
3011 unlock ("ml_getlinkrect");
3012
3013 done:
3014 CAMLreturn (ret_v);
3015 }
3016
3017 CAMLprim value ml_whatsunder (value ptr_v, value x_v, value y_v)
3018 {
3019 CAMLparam3 (ptr_v, x_v, y_v);
3020 CAMLlocal4 (ret_v, tup_v, str_v, gr_v);
3021 fz_link *link;
3022 struct page *page;
3023 char *s = String_val (ptr_v);
3024 int x = Int_val (x_v), y = Int_val (y_v);
3025 struct pagedim *pdim;
3026
3027 ret_v = Val_int (0);
3028 if (trylock ("ml_whatsunder")) {
3029 goto done;
3030 }
3031
3032 page = parse_pointer ("ml_whatsunder", s);
3033 pdim = &state.pagedims[page->pdimno];
3034 x += pdim->bounds.x0;
3035 y += pdim->bounds.y0;
3036 link = getlink (page, x, y);
3037 if (link) {
3038 LINKTOVAL;
3039 }
3040 else {
3041 fz_rect *b;
3042 fz_page_block *pageb;
3043 fz_text_block *block;
3044
3045 ensuretext (page);
3046 for (pageb = page->text->blocks;
3047 pageb < page->text->blocks + page->text->len;
3048 ++pageb) {
3049 fz_text_line *line;
3050 if (pageb->type != FZ_PAGE_BLOCK_TEXT) continue;
3051 block = pageb->u.text;
3052
3053 b = &block->bbox;
3054 if (!(x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1))
3055 continue;
3056
3057 for (line = block->lines;
3058 line < block->lines + block->len;
3059 ++line) {
3060 fz_text_span *span;
3061
3062 b = &line->bbox;
3063 if (!(x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1))
3064 continue;
3065
3066 for (span = line->first_span; span; span = span->next) {
3067 int charnum;
3068
3069 b = &span->bbox;
3070 if (!(x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1))
3071 continue;
3072
3073 for (charnum = 0; charnum < span->len; ++charnum) {
3074 fz_rect bbox;
3075 fz_text_char_bbox (&bbox, span, charnum);
3076 b = &bbox;
3077
3078 if (x >= b->x0 && x <= b->x1
3079 && y >= b->y0 && y <= b->y1) {
3080 fz_text_style *style = span->text->style;
3081 const char *n2 =
3082 style->font && style->font->name
3083 ? style->font->name
3084 : "Span has no font name"
3085 ;
3086 FT_FaceRec *face = style->font->ft_face;
3087 if (face && face->family_name) {
3088 char *s;
3089 char *n1 = face->family_name;
3090 size_t l1 = strlen (n1);
3091 size_t l2 = strlen (n2);
3092
3093 if (l1 != l2 || memcmp (n1, n2, l1)) {
3094 s = malloc (l1 + l2 + 2);
3095 if (s) {
3096 memcpy (s, n2, l2);
3097 s[l2] = '=';
3098 memcpy (s + l2 + 1, n1, l1 + 1);
3099 str_v = caml_copy_string (s);
3100 free (s);
3101 }
3102 }
3103 }
3104 if (str_v == 0) {
3105 str_v = caml_copy_string (n2);
3106 }
3107 ret_v = caml_alloc_small (1, utext);
3108 Field (ret_v, 0) = str_v;
3109 goto unlock;
3110 }
3111 }
3112 }
3113 }
3114 }
3115 }
3116 unlock:
3117 unlock ("ml_whatsunder");
3118
3119 done:
3120 CAMLreturn (ret_v);
3121 }
3122
3123 enum { mark_page, mark_block, mark_line, mark_word };
3124
3125 static int uninteresting (int c)
3126 {
3127 return c == ' ' || c == '\n' || c == '\t' || c == '\n' || c == '\r'
3128 || ispunct (c);
3129 }
3130
3131 CAMLprim value ml_clearmark (value ptr_v)
3132 {
3133 CAMLparam1 (ptr_v);
3134 char *s = String_val (ptr_v);
3135 struct page *page;
3136
3137 if (trylock ("ml_clearmark")) {
3138 goto done;
3139 }
3140
3141 page = parse_pointer ("ml_clearmark", s);
3142 page->fmark.span = NULL;
3143 page->lmark.span = NULL;
3144 page->fmark.i = 0;
3145 page->lmark.i = 0;
3146
3147 unlock ("ml_clearmark");
3148 done:
3149 CAMLreturn (Val_unit);
3150 }
3151
3152 CAMLprim value ml_markunder (value ptr_v, value x_v, value y_v, value mark_v)
3153 {
3154 CAMLparam4 (ptr_v, x_v, y_v, mark_v);
3155 CAMLlocal1 (ret_v);
3156 fz_rect *b;
3157 struct page *page;
3158 fz_text_line *line;
3159 fz_page_block *pageb;
3160 fz_text_block *block;
3161 struct pagedim *pdim;
3162 int mark = Int_val (mark_v);
3163 char *s = String_val (ptr_v);
3164 int x = Int_val (x_v), y = Int_val (y_v);
3165
3166 ret_v = Val_bool (0);
3167 if (trylock ("ml_markunder")) {
3168 goto done;
3169 }
3170
3171 page = parse_pointer ("ml_markunder", s);
3172 pdim = &state.pagedims[page->pdimno];
3173
3174 ensuretext (page);
3175
3176 if (mark == mark_page) {
3177 int i;
3178 fz_page_block *pb1 = NULL, *pb2 = NULL;
3179
3180 for (i = 0; i < page->text->len; ++i) {
3181 if (page->text->blocks[i].type == FZ_PAGE_BLOCK_TEXT) {
3182 pb1 = &page->text->blocks[i];
3183 break;
3184 }
3185 }
3186 if (!pb1) goto unlock;
3187
3188 for (i = page->text->len - 1; i >= 0; --i) {
3189 if (page->text->blocks[i].type == FZ_PAGE_BLOCK_TEXT) {
3190 pb2 = &page->text->blocks[i];
3191 break;
3192 }
3193 }
3194 if (!pb2) goto unlock;
3195
3196 block = pb1->u.text;
3197
3198 page->fmark.i = 0;
3199 page->fmark.span = block->lines->first_span;
3200
3201 block = pb2->u.text;
3202 line = &block->lines[block->len - 1];
3203 page->lmark.i = line->last_span->len - 1;
3204 page->lmark.span = line->last_span;
3205 ret_v = Val_bool (1);
3206 goto unlock;
3207 }
3208
3209 x += pdim->bounds.x0;
3210 y += pdim->bounds.y0;
3211
3212 for (pageb = page->text->blocks;
3213 pageb < page->text->blocks + page->text->len;
3214 ++pageb) {
3215 if (pageb->type != FZ_PAGE_BLOCK_TEXT) continue;
3216 block = pageb->u.text;
3217
3218 b = &block->bbox;
3219 if (!(x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1))
3220 continue;
3221
3222 if (mark == mark_block) {
3223 page->fmark.i = 0;
3224 page->fmark.span = block->lines->first_span;
3225
3226 line = &block->lines[block->len - 1];
3227 page->lmark.i = line->last_span->len - 1;
3228 page->lmark.span = line->last_span;
3229 ret_v = Val_bool (1);
3230 goto unlock;
3231 }
3232
3233 for (line = block->lines;
3234 line < block->lines + block->len;
3235 ++line) {
3236 fz_text_span *span;
3237
3238 b = &line->bbox;
3239 if (!(x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1))
3240 continue;
3241
3242 if (mark == mark_line) {
3243 page->fmark.i = 0;
3244 page->fmark.span = line->first_span;
3245
3246 page->lmark.i = line->last_span->len - 1;
3247 page->lmark.span = line->last_span;
3248 ret_v = Val_bool (1);
3249 goto unlock;
3250 }
3251
3252 for (span = line->first_span; span; span = span->next) {
3253 int charnum;
3254
3255 b = &span->bbox;
3256 if (!(x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1))
3257 continue;
3258
3259 for (charnum = 0; charnum < span->len; ++charnum) {
3260 fz_rect bbox;
3261 fz_text_char_bbox (&bbox, span, charnum);
3262 b = &bbox;
3263
3264 if (x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1) {
3265 /* unicode ftw */
3266 int charnum2, charnum3 = -1, charnum4 = -1;
3267
3268 if (uninteresting (span->text[charnum].c)) goto unlock;
3269
3270 for (charnum2 = charnum; charnum2 >= 0; --charnum2) {
3271 if (uninteresting (span->text[charnum2].c)) {
3272 charnum3 = charnum2 + 1;
3273 break;
3274 }
3275 }
3276 if (charnum3 == -1) charnum3 = 0;
3277
3278 for (charnum2 = charnum + 1;
3279 charnum2 < span->len;
3280 ++charnum2) {
3281 if (uninteresting (span->text[charnum2].c)) break;
3282 charnum4 = charnum2;
3283 }
3284 if (charnum4 == -1) goto unlock;
3285
3286 page->fmark.i = charnum3;
3287 page->fmark.span = span;
3288
3289 page->lmark.i = charnum4;
3290 page->lmark.span = span;
3291 ret_v = Val_bool (1);
3292 goto unlock;
3293 }
3294 }
3295 }
3296 }
3297 }
3298 unlock:
3299 if (!Bool_val (ret_v)) {
3300 page->fmark.span = NULL;
3301 page->lmark.span = NULL;
3302 page->fmark.i = 0;
3303 page->lmark.i = 0;
3304 }
3305 unlock ("ml_markunder");
3306
3307 done:
3308 CAMLreturn (ret_v);
3309 }
3310
3311 CAMLprim value ml_rectofblock (value ptr_v, value x_v, value y_v)
3312 {
3313 CAMLparam3 (ptr_v, x_v, y_v);
3314 CAMLlocal2 (ret_v, res_v);
3315 fz_rect *b = NULL;
3316 struct page *page;
3317 fz_page_block *pageb;
3318 struct pagedim *pdim;
3319 char *s = String_val (ptr_v);
3320 int x = Int_val (x_v), y = Int_val (y_v);
3321
3322 ret_v = Val_int (0);
3323 if (trylock ("ml_rectofblock")) {
3324 goto done;
3325 }
3326
3327 page = parse_pointer ("ml_rectofblock", s);
3328 pdim = &state.pagedims[page->pdimno];
3329 x += pdim->bounds.x0;
3330 y += pdim->bounds.y0;
3331
3332 ensuretext (page);
3333
3334 for (pageb = page->text->blocks;
3335 pageb < page->text->blocks + page->text->len;
3336 ++pageb) {
3337 switch (pageb->type) {
3338 case FZ_PAGE_BLOCK_TEXT:
3339 b = &pageb->u.text->bbox;
3340 break;
3341
3342 case FZ_PAGE_BLOCK_IMAGE:
3343 b = &pageb->u.image->bbox;
3344 break;
3345
3346 default:
3347 continue;
3348 }
3349
3350 if (x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1)
3351 break;
3352 b = NULL;
3353 }
3354 if (b) {
3355 res_v = caml_alloc_small (4 * Double_wosize, Double_array_tag);
3356 ret_v = caml_alloc_small (1, 1);
3357 Store_double_field (res_v, 0, b->x0);
3358 Store_double_field (res_v, 1, b->x1);
3359 Store_double_field (res_v, 2, b->y0);
3360 Store_double_field (res_v, 3, b->y1);
3361 Field (ret_v, 0) = res_v;
3362 }
3363 unlock ("ml_rectofblock");
3364
3365 done:
3366 CAMLreturn (ret_v);
3367 }
3368
3369 CAMLprim value ml_seltext (value ptr_v, value rect_v)
3370 {
3371 CAMLparam2 (ptr_v, rect_v);
3372 fz_rect b;
3373 struct page *page;
3374 struct pagedim *pdim;
3375 char *s = String_val (ptr_v);
3376 int i, x0, x1, y0, y1, fi, li;
3377 fz_text_line *line;
3378 fz_page_block *pageb;
3379 fz_text_block *block;
3380 fz_text_span *span, *fspan, *lspan;
3381
3382 if (trylock ("ml_seltext")) {
3383 goto done;
3384 }
3385
3386 page = parse_pointer ("ml_seltext", s);
3387 ensuretext (page);
3388
3389 pdim = &state.pagedims[page->pdimno];
3390 x0 = Int_val (Field (rect_v, 0)) + pdim->bounds.x0;
3391 y0 = Int_val (Field (rect_v, 1)) + pdim->bounds.y0;
3392 x1 = Int_val (Field (rect_v, 2)) + pdim->bounds.x0;
3393 y1 = Int_val (Field (rect_v, 3)) + pdim->bounds.y0;
3394
3395 if (y0 > y1) {
3396 int t = y0;
3397 y0 = y1;
3398 y1 = t;
3399 x0 = x1;
3400 x1 = t;
3401 }
3402
3403 if (0) {
3404 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
3405 glColor3ub (128, 128, 128);
3406 recti (x0, y0, x1, y1);
3407 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
3408 }
3409
3410 fi = page->fmark.i;
3411 fspan = page->fmark.span;
3412
3413 li = page->lmark.i;
3414 lspan = page->lmark.span;
3415
3416 for (pageb = page->text->blocks;
3417 pageb < page->text->blocks + page->text->len;
3418 ++pageb) {
3419 if (pageb->type != FZ_PAGE_BLOCK_TEXT) continue;
3420 block = pageb->u.text;
3421 for (line = block->lines;
3422 line < block->lines + block->len;
3423 ++line) {
3424 fz_text_span *span;
3425
3426 for (span = line->first_span; span; span = span->next) {
3427 for (i = 0; i < span->len; ++i) {
3428 int selected = 0;
3429
3430 fz_text_char_bbox (&b, span, i);
3431
3432 if (x0 >= b.x0 && x0 <= b.x1
3433 && y0 >= b.y0 && y0 <= b.y1) {
3434 fspan = span;
3435 fi = i;
3436 selected = 1;
3437 }
3438 if (x1 >= b.x0 && x1 <= b.x1
3439 && y1 >= b.y0 && y1 <= b.y1) {
3440 lspan = span;
3441 li = i;
3442 selected = 1;
3443 }
3444 if (0 && selected) {
3445 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
3446 glColor3ub (128, 128, 128);
3447 recti (b.x0, b.y0, b.x1, b.y1);
3448 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
3449 }
3450 }
3451 }
3452 }
3453 }
3454 if (x1 < x0 && fspan == lspan) {
3455 i = fi;
3456 span = fspan;
3457
3458 fi = li;
3459 fspan = lspan;
3460
3461 li = i;
3462 lspan = span;
3463 }
3464
3465 page->fmark.i = fi;
3466 page->fmark.span = fspan;
3467
3468 page->lmark.i = li;
3469 page->lmark.span = lspan;
3470
3471 unlock ("ml_seltext");
3472
3473 done:
3474 CAMLreturn (Val_unit);
3475 }
3476
3477 static int UNUSED_ATTR pipespan (FILE *f, fz_text_span *span, int a, int b)
3478 {
3479 char buf[4];
3480 int i, len, ret;
3481
3482 for (i = a; i <= b; ++i) {
3483 len = fz_runetochar (buf, span->text[i].c);
3484 ret = fwrite (buf, len, 1, f);
3485
3486 if (ret != 1) {
3487 fprintf (stderr, "failed to write %d bytes ret=%d: %s\n",
3488 len, ret, strerror (errno));
3489 return -1;
3490 }
3491 }
3492 return 0;
3493 }
3494
3495 #ifdef __CYGWIN__
3496 value ml_popen (value UNUSED_ATTR u1, value UNUSED_ATTR u2)
3497 {
3498 caml_failwith ("ml_popen not implemented under Cygwin");
3499 }
3500 #else
3501 CAMLprim value ml_popen (value command_v, value fds_v)
3502 {
3503 CAMLparam2 (command_v, fds_v);
3504 CAMLlocal2 (l_v, tup_v);
3505 int ret;
3506 char *msg = NULL;
3507 value earg_v = Nothing;
3508 posix_spawnattr_t attr;
3509 posix_spawn_file_actions_t fa;
3510 char *argv[] = { "/bin/sh", "-c", String_val (command_v), NULL };
3511
3512 if ((ret = posix_spawn_file_actions_init (&fa)) != 0) {
3513 unix_error (ret, "posix_spawn_file_actions_init", Nothing);
3514 }
3515
3516 if ((ret = posix_spawnattr_init (&attr)) != 0) {
3517 msg = "posix_spawnattr_init";
3518 goto fail1;
3519 }
3520
3521 #ifdef POSIX_SPAWN_USEVFORK
3522 if ((ret = posix_spawnattr_setflags (&attr, POSIX_SPAWN_USEVFORK)) != 0) {
3523 msg = "posix_spawnattr_setflags POSIX_SPAWN_USEVFORK";
3524 goto fail;
3525 }
3526 #endif
3527
3528 for (l_v = fds_v; l_v != Val_int (0); l_v = Field (l_v, 1)) {
3529 int fd1, fd2;
3530
3531 tup_v = Field (l_v, 0);
3532 fd1 = Int_val (Field (tup_v, 0));
3533 fd2 = Int_val (Field (tup_v, 1));
3534 if (fd2 < 0) {
3535 if ((ret = posix_spawn_file_actions_addclose (&fa, fd1)) != 0) {
3536 msg = "posix_spawn_file_actions_addclose";
3537 earg_v = tup_v;
3538 goto fail;
3539 }
3540 }
3541 else {
3542 if ((ret = posix_spawn_file_actions_adddup2 (&fa, fd1, fd2)) != 0) {
3543 msg = "posix_spawn_file_actions_adddup2";
3544 earg_v = tup_v;
3545 goto fail;
3546 }
3547 }
3548 }
3549
3550 if ((ret = posix_spawn (NULL, "/bin/sh", &fa, &attr, argv, environ))) {
3551 msg = "posix_spawn";
3552 goto fail;
3553 }
3554
3555 fail:
3556 if ((ret = posix_spawnattr_destroy (&attr)) != 0) {
3557 fprintf (stderr, "posix_spawnattr_destroy: %s\n", strerror (ret));
3558 }
3559
3560 fail1:
3561 if ((ret = posix_spawn_file_actions_destroy (&fa)) != 0) {
3562 fprintf (stderr, "posix_spawn_file_actions_destroy: %s\n",
3563 strerror (ret));
3564 }
3565
3566 if (msg)
3567 unix_error (ret, msg, earg_v);
3568
3569 CAMLreturn (Val_unit);
3570 }
3571 #endif
3572
3573 CAMLprim value ml_hassel (value ptr_v)
3574 {
3575 CAMLparam1 (ptr_v);
3576 CAMLlocal1 (ret_v);
3577 struct page *page;
3578 char *s = String_val (ptr_v);
3579
3580 ret_v = Val_bool (0);
3581 if (trylock ("ml_hassel")) {
3582 goto done;
3583 }
3584
3585 page = parse_pointer ("ml_hassel", s);
3586 ret_v = Val_bool (page->fmark.span && page->lmark.span);
3587 unlock ("ml_hassel");
3588 done:
3589 CAMLreturn (ret_v);
3590 }
3591
3592 CAMLprim value ml_copysel (value fd_v, value ptr_v)
3593 {
3594 CAMLparam2 (fd_v, ptr_v);
3595 FILE *f;
3596 int seen = 0;
3597 struct page *page;
3598 fz_text_line *line;
3599 fz_page_block *pageb;
3600 fz_text_block *block;
3601 int fd = Int_val (fd_v);
3602 char *s = String_val (ptr_v);
3603
3604 if (trylock ("ml_copysel")) {
3605 goto done;
3606 }
3607
3608 page = parse_pointer ("ml_copysel", s);
3609
3610 if (!page->fmark.span || !page->lmark.span) {
3611 fprintf (stderr, "nothing to copy on page %d\n", page->pageno);
3612 goto unlock;
3613 }
3614
3615 f = fdopen (fd, "w");
3616 if (!f) {
3617 fprintf (stderr, "failed to fdopen sel pipe (from fd %d): %s\n",
3618 fd, strerror (errno));
3619 f = stdout;
3620 }
3621
3622 for (pageb = page->text->blocks;
3623 pageb < page->text->blocks + page->text->len;
3624 ++pageb) {
3625 if (pageb->type != FZ_PAGE_BLOCK_TEXT) continue;
3626 block = pageb->u.text;
3627 for (line = block->lines;
3628 line < block->lines + block->len;
3629 ++line) {
3630 fz_text_span *span;
3631
3632 for (span = line->first_span; span; span = span->next) {
3633 int a, b;
3634
3635 seen |= span == page->fmark.span || span == page->lmark.span;
3636 a = span == page->fmark.span ? page->fmark.i : 0;
3637 b = span == page->lmark.span ? page->lmark.i : span->len - 1;
3638
3639 if (seen) {
3640 if (pipespan (f, span, a, b)) {
3641 goto close;
3642 }
3643 if (span == page->lmark.span) {
3644 goto close;
3645 }
3646 if (span == line->last_span) {
3647 if (putc ('\n', f) == EOF) {
3648 fprintf (stderr,
3649 "failed break line on sel pipe: %s\n",
3650 strerror (errno));
3651 goto close;
3652 }
3653 }
3654 }
3655 }
3656 }
3657 }
3658 close:
3659 if (f != stdout) {
3660 int ret = fclose (f);
3661 fd = -1;
3662 if (ret == -1) {
3663 if (errno != ECHILD) {
3664 fprintf (stderr, "failed to close sel pipe: %s\n",
3665 strerror (errno));
3666 }
3667 }
3668 }
3669 unlock:
3670 unlock ("ml_copysel");
3671
3672 done:
3673 if (fd >= 0) {
3674 if (close (fd)) {
3675 fprintf (stderr, "failed to close sel pipe: %s\n",
3676 strerror (errno));
3677 }
3678 }
3679 CAMLreturn (Val_unit);
3680 }
3681
3682 CAMLprim value ml_getpdimrect (value pagedimno_v)
3683 {
3684 CAMLparam1 (pagedimno_v);
3685 CAMLlocal1 (ret_v);
3686 int pagedimno = Int_val (pagedimno_v);
3687 fz_rect box;
3688
3689 ret_v = caml_alloc_small (4 * Double_wosize, Double_array_tag);
3690 if (trylock ("ml_getpdimrect")) {
3691 box = fz_empty_rect;
3692 }
3693 else {
3694 box = state.pagedims[pagedimno].mediabox;
3695 unlock ("ml_getpdimrect");
3696 }
3697
3698 Store_double_field (ret_v, 0, box.x0);
3699 Store_double_field (ret_v, 1, box.x1);
3700 Store_double_field (ret_v, 2, box.y0);
3701 Store_double_field (ret_v, 3, box.y1);
3702
3703 CAMLreturn (ret_v);
3704 }
3705
3706 CAMLprim value ml_zoom_for_height (value winw_v, value winh_v,
3707 value dw_v, value cols_v)
3708 {
3709 CAMLparam3 (winw_v, winh_v, dw_v);
3710 CAMLlocal1 (ret_v);
3711 int i;
3712 double zoom = -1.;
3713 double maxh = 0.0;
3714 struct pagedim *p;
3715 double winw = Int_val (winw_v);
3716 double winh = Int_val (winh_v);
3717 double dw = Int_val (dw_v);
3718 double cols = Int_val (cols_v);
3719 double pw = 1.0, ph = 1.0;
3720
3721 if (trylock ("ml_zoom_for_height")) {
3722 goto done;
3723 }
3724
3725 for (i = 0, p = state.pagedims; i < state.pagedimcount; ++i, ++p) {
3726 double w = p->pagebox.x1 / cols;
3727 double h = p->pagebox.y1;
3728 if (h > maxh) {
3729 maxh = h;
3730 ph = h;
3731 if (state.fitmodel != FitProportional) pw = w;
3732 }
3733 if ((state.fitmodel == FitProportional) && w > pw) pw = w;
3734 }
3735
3736 zoom = (((winh / ph) * pw) + dw) / winw;
3737 unlock ("ml_zoom_for_height");
3738 done:
3739 ret_v = caml_copy_double (zoom);
3740 CAMLreturn (ret_v);
3741 }
3742
3743 CAMLprim value ml_draw_string (value pt_v, value x_v, value y_v, value string_v)
3744 {
3745 CAMLparam4 (pt_v, x_v, y_v, string_v);
3746 CAMLlocal1 (ret_v);
3747 int pt = Int_val(pt_v);
3748 int x = Int_val (x_v);
3749 int y = Int_val (y_v);
3750 double w;
3751
3752 w = draw_string (state.face, pt, x, y, String_val (string_v));
3753 ret_v = caml_copy_double (w);
3754 CAMLreturn (ret_v);
3755 }
3756
3757 CAMLprim value ml_measure_string (value pt_v, value string_v)
3758 {
3759 CAMLparam2 (pt_v, string_v);
3760 CAMLlocal1 (ret_v);
3761 int pt = Int_val (pt_v);
3762 double w;
3763
3764 w = measure_string (state.face, pt, String_val (string_v));
3765 ret_v = caml_copy_double (w);
3766 CAMLreturn (ret_v);
3767 }
3768
3769 CAMLprim value ml_getpagebox (value opaque_v)
3770 {
3771 CAMLparam1 (opaque_v);
3772 CAMLlocal1 (ret_v);
3773 fz_rect rect;
3774 fz_irect bbox;
3775 fz_matrix ctm;
3776 fz_device *dev;
3777 char *s = String_val (opaque_v);
3778 struct page *page = parse_pointer ("ml_getpagebox", s);
3779
3780 ret_v = caml_alloc_tuple (4);
3781 dev = fz_new_bbox_device (state.ctx, &rect);
3782 dev->hints |= FZ_IGNORE_SHADE;
3783
3784 switch (page->type) {
3785 case DPDF:
3786 ctm = pagectm (page);
3787 pdf_run_page (state.u.pdf, page->u.pdfpage, dev, &ctm, NULL);
3788 break;
3789
3790 case DXPS:
3791 ctm = pagectm (page);
3792 xps_run_page (state.u.xps, page->u.xpspage, dev, &ctm, NULL);
3793 break;
3794
3795 default:
3796 rect = fz_infinite_rect;
3797 break;
3798 }
3799
3800 fz_free_device (dev);
3801 fz_round_rect (&bbox, &rect);
3802 Field (ret_v, 0) = Val_int (bbox.x0);
3803 Field (ret_v, 1) = Val_int (bbox.y0);
3804 Field (ret_v, 2) = Val_int (bbox.x1);
3805 Field (ret_v, 3) = Val_int (bbox.y1);
3806
3807 CAMLreturn (ret_v);
3808 }
3809
3810 CAMLprim value ml_setaalevel (value level_v)
3811 {
3812 CAMLparam1 (level_v);
3813
3814 state.aalevel = Int_val (level_v);
3815 CAMLreturn (Val_unit);
3816 }
3817
3818 #undef pixel
3819 #include <X11/Xlib.h>
3820 #include <GL/glx.h>
3821
3822 static struct {
3823 Display *dpy;
3824 GLXContext ctx;
3825 GLXDrawable drawable;
3826 } glx;
3827
3828 #include "keysym2ucs.c"
3829
3830 CAMLprim value ml_keysymtoutf8 (value keysym_v)
3831 {
3832 CAMLparam1 (keysym_v);
3833 CAMLlocal1 (str_v);
3834 KeySym keysym = Int_val (keysym_v);
3835 Rune rune;
3836 int len;
3837 char buf[5];
3838
3839 rune = keysym2ucs (keysym);
3840 len = fz_runetochar (buf, rune);
3841 buf[len] = 0;
3842 str_v = caml_copy_string (buf);
3843 CAMLreturn (str_v);
3844 }
3845
3846 CAMLprim value ml_glx (value win_v)
3847 {
3848 CAMLparam1 (win_v);
3849 XVisualInfo *visual;
3850 int screen, wid = Int_val (win_v);
3851 int attributes[] = { GLX_RGBA, GLX_DOUBLEBUFFER, None };
3852
3853 glx.dpy = XOpenDisplay (NULL);
3854 if (!glx.dpy) {
3855 caml_failwith ("XOpenDisplay");
3856 }
3857
3858 screen = DefaultScreen (glx.dpy);
3859 visual = glXChooseVisual (glx.dpy, screen, attributes);
3860 if (!visual) {
3861 XCloseDisplay (glx.dpy);
3862 glx.dpy = NULL;
3863 caml_failwith ("glXChooseVisual");
3864 }
3865
3866 glx.ctx = glXCreateContext (glx.dpy, visual, NULL, True);
3867 XFree (visual);
3868 if (!glx.ctx) {
3869 XCloseDisplay (glx.dpy);
3870 glx.dpy = NULL;
3871 caml_failwith ("glXCreateContext");
3872 }
3873
3874 if (!glXMakeCurrent (glx.dpy, wid, glx.ctx)) {
3875 glXDestroyContext (glx.dpy, glx.ctx);
3876 XCloseDisplay (glx.dpy);
3877 glx.dpy = NULL;
3878 glx.ctx = NULL;
3879 caml_failwith ("glXMakeCurrent");
3880 }
3881 glx.drawable = wid;
3882 CAMLreturn (Val_unit);
3883 }
3884
3885 CAMLprim value ml_swapb (value unit_v)
3886 {
3887 CAMLparam1 (unit_v);
3888 glXSwapBuffers (glx.dpy, glx.drawable);
3889 CAMLreturn (Val_unit);
3890 }
3891
3892 CAMLprim value ml_glxsync (value unit_v)
3893 {
3894 CAMLparam1 (unit_v);
3895 if (glx.dpy && glx.ctx) {
3896 glXWaitX ();
3897 glXWaitGL ();
3898 }
3899 CAMLreturn (Val_unit);
3900 }
3901
3902 enum { piunknown, pilinux, piosx, pisun, pifreebsd,
3903 pidragonflybsd, piopenbsd, pinetbsd, picygwin };
3904
3905 CAMLprim value ml_platform (value unit_v)
3906 {
3907 CAMLparam1 (unit_v);
3908 int platid = piunknown;
3909
3910 #if defined __linux__
3911 platid = pilinux;
3912 #elif defined __CYGWIN__
3913 platid = picygwin;
3914 #elif defined __DragonFly__
3915 platid = pidragonflybsd;
3916 #elif defined __FreeBSD__
3917 platid = pifreebsd;
3918 #elif defined __OpenBSD__
3919 platid = piopenbsd;
3920 #elif defined __NetBSD__
3921 platid = pinetbsd;
3922 #elif defined __sun__
3923 platid = pisun;
3924 #elif defined __APPLE__
3925 platid = piosx;
3926 #endif
3927 CAMLreturn (Val_int (platid));
3928 }
3929
3930 CAMLprim value ml_cloexec (value fd_v)
3931 {
3932 CAMLparam1 (fd_v);
3933 int fd = Int_val (fd_v);
3934
3935 if (fcntl (fd, F_SETFD, FD_CLOEXEC, 1)) {
3936 uerror ("fcntl", Nothing);
3937 }
3938 CAMLreturn (Val_unit);
3939 }
3940
3941 CAMLprim value ml_getpbo (value w_v, value h_v, value cs_v)
3942 {
3943 CAMLparam2 (w_v, h_v);
3944 CAMLlocal1 (ret_v);
3945 struct pbo *pbo;
3946 int w = Int_val (w_v);
3947 int h = Int_val (h_v);
3948 int cs = Int_val (cs_v);
3949
3950 if (state.pbo_usable) {
3951 pbo = calloc (sizeof (*pbo), 1);
3952 if (!pbo) {
3953 err (1, "calloc pbo");
3954 }
3955
3956 switch (cs) {
3957 case 0:
3958 case 1:
3959 pbo->size = w*h*4;
3960 break;
3961 case 2:
3962 pbo->size = w*h*2;
3963 break;
3964 default:
3965 errx (1, "ml_getpbo: invalid colorspace %d", cs);
3966 }
3967
3968 state.glGenBuffersARB (1, &pbo->id);
3969 state.glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB, pbo->id);
3970 state.glBufferDataARB (GL_PIXEL_UNPACK_BUFFER_ARB, pbo->size,
3971 NULL, GL_STREAM_DRAW);
3972 pbo->ptr = state.glMapBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB,
3973 GL_READ_WRITE);
3974 state.glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB, 0);
3975 if (!pbo->ptr) {
3976 fprintf (stderr, "glMapBufferARB failed: %#x\n", glGetError ());
3977 state.glDeleteBuffersARB (1, &pbo->id);
3978 free (pbo);
3979 ret_v = caml_copy_string ("0");
3980 }
3981 else {
3982 int res;
3983 char *s;
3984
3985 res = snprintf (NULL, 0, "%" FMT_ptr, pbo);
3986 if (res < 0) {
3987 err (1, "snprintf %" FMT_ptr " failed", pbo);
3988 }
3989 s = malloc (res+1);
3990 if (!s) {
3991 err (1, "malloc %d bytes failed", res+1);
3992 }
3993 res = sprintf (s, "%" FMT_ptr, pbo);
3994 if (res < 0) {
3995 err (1, "sprintf %" FMT_ptr " failed", pbo);
3996 }
3997 ret_v = caml_copy_string (s);
3998 free (s);
3999 }
4000 }
4001 else {
4002 ret_v = caml_copy_string ("0");
4003 }
4004 CAMLreturn (ret_v);
4005 }
4006
4007 CAMLprim value ml_freepbo (value s_v)
4008 {
4009 CAMLparam1 (s_v);
4010 char *s = String_val (s_v);
4011 struct tile *tile = parse_pointer ("ml_freepbo", s);
4012
4013 if (tile->pbo) {
4014 state.glDeleteBuffersARB (1, &tile->pbo->id);
4015 tile->pbo->id = -1;
4016 tile->pbo->ptr = NULL;
4017 tile->pbo->size = -1;
4018 }
4019 CAMLreturn (Val_unit);
4020 }
4021
4022 CAMLprim value ml_unmappbo (value s_v)
4023 {
4024 CAMLparam1 (s_v);
4025 char *s = String_val (s_v);
4026 struct tile *tile = parse_pointer ("ml_unmappbo", s);
4027
4028 if (tile->pbo) {
4029 state.glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB, tile->pbo->id);
4030 if (state.glUnmapBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB) == GL_FALSE) {
4031 errx (1, "glUnmapBufferARB failed: %#x\n", glGetError ());
4032 }
4033 tile->pbo->ptr = NULL;
4034 state.glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB, 0);
4035 }
4036 CAMLreturn (Val_unit);
4037 }
4038
4039 static void setuppbo (void)
4040 {
4041 #define GGPA(n) (*(void (**) ()) &state.n = glXGetProcAddress ((GLubyte *) #n))
4042 state.pbo_usable = GGPA (glBindBufferARB)
4043 && GGPA (glUnmapBufferARB)
4044 && GGPA (glMapBufferARB)
4045 && GGPA (glBufferDataARB)
4046 && GGPA (glGenBuffersARB)
4047 && GGPA (glDeleteBuffersARB);
4048 #undef GGPA
4049 }
4050
4051 CAMLprim value ml_pbo_usable (value unit_v)
4052 {
4053 CAMLparam1 (unit_v);
4054 CAMLreturn (Val_bool (state.pbo_usable));
4055 }
4056
4057 CAMLprim value ml_unproject (value ptr_v, value x_v, value y_v)
4058 {
4059 CAMLparam3 (ptr_v, x_v, y_v);
4060 CAMLlocal2 (ret_v, tup_v);
4061 struct page *page;
4062 char *s = String_val (ptr_v);
4063 int x = Int_val (x_v), y = Int_val (y_v);
4064 struct pagedim *pdim;
4065 fz_point p;
4066 fz_matrix ctm;
4067
4068 page = parse_pointer ("ml_unproject", s);
4069 pdim = &state.pagedims[page->pdimno];
4070
4071 ret_v = Val_int (0);
4072 if (trylock ("ml_unproject")) {
4073 goto done;
4074 }
4075
4076 switch (page->type) {
4077 case DPDF:
4078 trimctm (page->u.pdfpage, page->pdimno);
4079 break;
4080
4081 default:
4082 break;
4083 }
4084 p.x = x + pdim->bounds.x0;
4085 p.y = y + pdim->bounds.y0;
4086
4087 fz_concat (&ctm, &pdim->tctm, &pdim->ctm);
4088 fz_invert_matrix (&ctm, &ctm);
4089 fz_transform_point (&p, &ctm);
4090
4091 tup_v = caml_alloc_tuple (2);
4092 ret_v = caml_alloc_small (1, 1);
4093 Field (tup_v, 0) = Val_int (p.x);
4094 Field (tup_v, 1) = Val_int (p.y);
4095 Field (ret_v, 0) = tup_v;
4096
4097 unlock ("ml_unproject");
4098 done:
4099 CAMLreturn (ret_v);
4100 }
4101
4102 static void makestippletex (void)
4103 {
4104 const char pixels[] = "\xff\xff\0\0";
4105 glGenTextures (1, &state.stid);
4106 glBindTexture (GL_TEXTURE_1D, state.stid);
4107 glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
4108 glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
4109 glTexImage1D (
4110 GL_TEXTURE_1D,
4111 0,
4112 GL_ALPHA,
4113 4,
4114 0,
4115 GL_ALPHA,
4116 GL_UNSIGNED_BYTE,
4117 pixels
4118 );
4119 }
4120
4121 CAMLprim value ml_fz_version (value unit_v)
4122 {
4123 return caml_copy_string (FZ_VERSION);
4124 }
4125
4126 #ifdef USE_FONTCONFIG
4127 static struct {
4128 int inited;
4129 FcConfig *config;
4130 } fc;
4131
4132 static fz_font *fc_load_system_font_func (fz_context *ctx,
4133 const char *name,
4134 int bold,
4135 int italic,
4136 int needs_exact_metrics)
4137 {
4138 char *buf;
4139 size_t i, size;
4140 fz_font *font;
4141 FcChar8 *path;
4142 FcResult result;
4143 FcPattern *pat, *pat1;
4144
4145 lprintf ("looking up %s bold:%d italic:%d needs_exact_metrics:%d\n",
4146 name, bold, italic, needs_exact_metrics);
4147 if (!fc.inited) {
4148 fc.inited = 1;
4149 fc.config = FcInitLoadConfigAndFonts ();
4150 if (!fc.config) {
4151 lprintf ("FcInitLoadConfigAndFonts failed\n");
4152 return NULL;
4153 }
4154 }
4155 if (!fc.config) return NULL;
4156
4157 size = strlen (name);
4158 if (bold) size += sizeof (":bold") - 1;
4159 if (italic) size += sizeof (":italic") - 1;
4160 size += 1;
4161
4162 buf = malloc (size);
4163 if (!buf) {
4164 err (1, "malloc %zu failed", size);
4165 }
4166
4167 strcpy (buf, name);
4168 if (bold && italic) {
4169 strcat (buf, ":bold:italic");
4170 }
4171 else {
4172 if (bold) strcat (buf, ":bold");
4173 if (italic) strcat (buf, ":italic");
4174 }
4175 for (i = 0; i < size; ++i) {
4176 if (buf[i] == ',' || buf[i] == '-') buf[i] = ':';
4177 }
4178
4179 lprintf ("fcbuf=%s\n", buf);
4180 pat = FcNameParse ((FcChar8 *) buf);
4181 if (!pat) {
4182 printd ("emsg FcNameParse failed\n");
4183 free (buf);
4184 return NULL;
4185 }
4186
4187 if (!FcConfigSubstitute (fc.config, pat, FcMatchPattern)) {
4188 printd ("emsg FcConfigSubstitute failed\n");
4189 free (buf);
4190 return NULL;
4191 }
4192 FcDefaultSubstitute (pat);
4193
4194 pat1 = FcFontMatch (fc.config, pat, &result);
4195 if (!pat1) {
4196 printd ("emsg FcFontMatch failed\n");
4197 FcPatternDestroy (pat);
4198 free (buf);
4199 return NULL;
4200 }
4201
4202 if (FcPatternGetString (pat1, FC_FILE, 0, &path) != FcResultMatch) {
4203 printd ("emsg FcPatternGetString failed\n");
4204 FcPatternDestroy (pat);
4205 FcPatternDestroy (pat1);
4206 free (buf);
4207 return NULL;
4208 }
4209
4210 #if 0
4211 printd ("emsg name=%s path=%s\n", name, path);
4212 #endif
4213 font = fz_new_font_from_file (ctx, name, (char *) path, 0, 0);
4214 FcPatternDestroy (pat);
4215 FcPatternDestroy (pat1);
4216 free (buf);
4217 return font;
4218 }
4219 #endif
4220
4221 CAMLprim value ml_init (value pipe_v, value params_v)
4222 {
4223 CAMLparam2 (pipe_v, params_v);
4224 CAMLlocal2 (trim_v, fuzz_v);
4225 int ret;
4226 int texcount;
4227 char *fontpath;
4228 int colorspace;
4229 int mustoresize;
4230 int haspboext;
4231 struct sigaction sa;
4232
4233 state.cr = Int_val (Field (pipe_v, 0));
4234 state.cw = Int_val (Field (pipe_v, 1));
4235 state.rotate = Int_val (Field (params_v, 0));
4236 state.fitmodel = Int_val (Field (params_v, 1));
4237 trim_v = Field (params_v, 2);
4238 texcount = Int_val (Field (params_v, 3));
4239 state.sliceheight = Int_val (Field (params_v, 4));
4240 mustoresize = Int_val (Field (params_v, 5));
4241 colorspace = Int_val (Field (params_v, 6));
4242 fontpath = String_val (Field (params_v, 7));
4243
4244 state.trimcachepath = strdup (String_val (Field (params_v, 8)));
4245 if (!state.trimcachepath) {
4246 fprintf (stderr, "failed to strdup trimcachepath: %s\n",
4247 strerror (errno));
4248 }
4249 haspboext = Bool_val (Field (params_v, 9));
4250
4251 state.ctx = fz_new_context (NULL, NULL, mustoresize);
4252
4253 #ifdef USE_FONTCONFIG
4254 fz_install_load_system_font_funcs (state.ctx, fc_load_system_font_func, NULL);
4255 #endif
4256
4257 state.trimmargins = Bool_val (Field (trim_v, 0));
4258 fuzz_v = Field (trim_v, 1);
4259 state.trimfuzz.x0 = Int_val (Field (fuzz_v, 0));
4260 state.trimfuzz.y0 = Int_val (Field (fuzz_v, 1));
4261 state.trimfuzz.x1 = Int_val (Field (fuzz_v, 2));
4262 state.trimfuzz.y1 = Int_val (Field (fuzz_v, 3));
4263
4264 set_tex_params (colorspace);
4265
4266 if (*fontpath) {
4267 #ifndef USE_FONTCONFIG
4268 state.face = load_font (fontpath);
4269 #else
4270 FcChar8 *path;
4271 FcResult result;
4272 char *buf = fontpath;
4273 FcPattern *pat, *pat1;
4274
4275 fc.inited = 1;
4276 fc.config = FcInitLoadConfigAndFonts ();
4277 if (!fc.config) {
4278 errx (1, "FcInitLoadConfigAndFonts failed");
4279 }
4280
4281 pat = FcNameParse ((FcChar8 *) buf);
4282 if (!pat) {
4283 errx (1, "FcNameParse failed");
4284 }
4285
4286 if (!FcConfigSubstitute (fc.config, pat, FcMatchPattern)) {
4287 errx (1, "FcConfigSubstitute failed");
4288 }
4289 FcDefaultSubstitute (pat);
4290
4291 pat1 = FcFontMatch (fc.config, pat, &result);
4292 if (!pat1) {
4293 errx (1, "FcFontMatch failed");
4294 }
4295
4296 if (FcPatternGetString (pat1, FC_FILE, 0, &path) != FcResultMatch) {
4297 errx (1, "FcPatternGetString failed");
4298 }
4299
4300 state.face = load_font ((char *) path);
4301 FcPatternDestroy (pat);
4302 FcPatternDestroy (pat1);
4303 #endif
4304 }
4305 else {
4306 unsigned int len;
4307 void *base = pdf_lookup_substitute_font (0, 0, 0, 0, &len);
4308
4309 state.face = load_builtin_font (base, len);
4310 }
4311 if (!state.face) _exit (1);
4312
4313 realloctexts (texcount);
4314
4315 if (haspboext) {
4316 setuppbo ();
4317 }
4318
4319 makestippletex ();
4320
4321 #ifdef __CYGWIN__
4322 sa.sa_handler = SIG_IGN;
4323 sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
4324 #else
4325 sa.sa_handler = SIG_DFL;
4326 sa.sa_flags = SA_RESTART | SA_NOCLDSTOP | SA_NOCLDWAIT;
4327 #endif
4328 if (sigemptyset (&sa.sa_mask)) {
4329 err (1, "sigemptyset");
4330 }
4331 if (sigaction (SIGCHLD, &sa, NULL)) {
4332 err (1, "sigaction");
4333 }
4334
4335 ret = pthread_create (&state.thread, NULL, mainloop, NULL);
4336 if (ret) {
4337 errx (1, "pthread_create: %s", strerror (ret));
4338 }
4339
4340 CAMLreturn (Val_unit);
4341 }
PDF pager