?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid possible confusion
[llpp.git] / link.c
blobb8094a961ff08f4c1fee4b1ac896cceb0c7ec117
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;
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 openxref (filename, password);
1841 pdfinfo ();
1842 initpdims ();
1843 unlock ("open");
1844
1845 if (!wthack) {
1846 utf8filename = mbtoutf8 (filename);
1847 printd ("msg Opened %s (press h/F1 to get help)", utf8filename);
1848 if (utf8filename != filename) {
1849 free (utf8filename);
1850 }
1851 }
1852 state.needoutline = 1;
1853 }
1854 else if (!strncmp ("cs", p, 2)) {
1855 int i, colorspace;
1856
1857 ret = sscanf (p + 2, " %d", &colorspace);
1858 if (ret != 1) {
1859 errx (1, "malformed cs `%.*s' ret=%d", len, p, ret);
1860 }
1861 lock ("cs");
1862 set_tex_params (colorspace);
1863 for (i = 0; i < state.texcount; ++i) {
1864 state.texowners[i].w = -1;
1865 state.texowners[i].slice = NULL;
1866 }
1867 unlock ("cs");
1868 }
1869 else if (!strncmp ("freepage", p, 8)) {
1870 void *ptr;
1871
1872 ret = sscanf (p + 8, " %" FMT_ptr, FMT_ptr_cast (&ptr));
1873 if (ret != 1) {
1874 errx (1, "malformed freepage `%.*s' ret=%d", len, p, ret);
1875 }
1876 freepage (ptr);
1877 }
1878 else if (!strncmp ("freetile", p, 8)) {
1879 void *ptr;
1880
1881 ret = sscanf (p + 8, " %" FMT_ptr, FMT_ptr_cast (&ptr));
1882 if (ret != 1) {
1883 errx (1, "malformed freetile `%.*s' ret=%d", len, p, ret);
1884 }
1885 freetile (ptr);
1886 }
1887 else if (!strncmp ("search", p, 6)) {
1888 int icase, pageno, y, ret, len2, forward;
1889 char *pattern;
1890 regex_t re;
1891
1892 ret = sscanf (p + 6, " %d %d %d %d,%n",
1893 &icase, &pageno, &y, &forward, &len2);
1894 if (ret != 4) {
1895 errx (1, "malformed search `%s' ret=%d", p, ret);
1896 }
1897
1898 pattern = p + 6 + len2;
1899 ret = regcomp (&re, pattern,
1900 REG_EXTENDED | (icase ? REG_ICASE : 0));
1901 if (ret) {
1902 char errbuf[80];
1903 size_t size;
1904
1905 size = regerror (ret, &re, errbuf, sizeof (errbuf));
1906 printd ("msg regcomp failed `%.*s'", (int) size, errbuf);
1907 }
1908 else {
1909 search (&re, pageno, y, forward);
1910 regfree (&re);
1911 }
1912 }
1913 else if (!strncmp ("geometry", p, 8)) {
1914 int w, h, fitmodel;
1915
1916 printd ("clear");
1917 ret = sscanf (p + 8, " %d %d %d", &w, &h, &fitmodel);
1918 if (ret != 3) {
1919 errx (1, "malformed geometry `%.*s' ret=%d", len, p, ret);
1920 }
1921
1922 lock ("geometry");
1923 state.h = h;
1924 if (w != state.w) {
1925 int i;
1926 state.w = w;
1927 for (i = 0; i < state.texcount; ++i) {
1928 state.texowners[i].slice = NULL;
1929 }
1930 }
1931 state.fitmodel = fitmodel;
1932 layout ();
1933 process_outline ();
1934
1935 state.gen++;
1936 unlock ("geometry");
1937 printd ("continue %d", state.pagecount);
1938 }
1939 else if (!strncmp ("reqlayout", p, 9)) {
1940 char *nameddest;
1941 int rotate, fitmodel, off, h;
1942
1943 printd ("clear");
1944 ret = sscanf (p + 9, " %d %d %d %n",
1945 &rotate, &fitmodel, &h, &off);
1946 if (ret != 3) {
1947 errx (1, "bad reqlayout line `%.*s' ret=%d", len, p, ret);
1948 }
1949 lock ("reqlayout");
1950 if (state.rotate != rotate || state.fitmodel != fitmodel) {
1951 state.gen += 1;
1952 }
1953 state.rotate = rotate;
1954 state.fitmodel = fitmodel;
1955 state.h = h;
1956 layout ();
1957 process_outline ();
1958
1959 nameddest = p + 9 + off;
1960 if (state.type == DPDF && nameddest && *nameddest) {
1961 struct anchor a;
1962 fz_link_dest dest;
1963 pdf_obj *needle, *obj;
1964
1965 needle = pdf_new_string (state.u.pdf, nameddest,
1966 strlen (nameddest));
1967 obj = pdf_lookup_dest (state.u.pdf, needle);
1968 if (obj) {
1969 dest = pdf_parse_link_dest (state.u.pdf, FZ_LINK_GOTO, obj);
1970
1971 a = desttoanchor (&dest);
1972 if (a.n >= 0) {
1973 printd ("a %d %d %d", a.n, a.x, a.y);
1974 }
1975 else {
1976 printd ("emsg failed to parse destination `%s'\n",
1977 nameddest);
1978 }
1979 }
1980 else {
1981 printd ("emsg destination `%s' not found\n",
1982 nameddest);
1983 }
1984 pdf_drop_obj (needle);
1985 }
1986
1987 state.gen++;
1988 unlock ("reqlayout");
1989 printd ("continue %d", state.pagecount);
1990 }
1991 else if (!strncmp ("page", p, 4)) {
1992 double a, b;
1993 struct page *page;
1994 int pageno, pindex, ret;
1995
1996 ret = sscanf (p + 4, " %d %d", &pageno, &pindex);
1997 if (ret != 2) {
1998 errx (1, "bad page line `%.*s' ret=%d", len, p, ret);
1999 }
2000
2001 lock ("page");
2002 a = now ();
2003 page = loadpage (pageno, pindex);
2004 b = now ();
2005 unlock ("page");
2006
2007 printd ("page %" FMT_ptr " %f", FMT_ptr_cast2 (page), b - a);
2008 }
2009 else if (!strncmp ("tile", p, 4)) {
2010 int x, y, w, h, ret;
2011 struct page *page;
2012 struct tile *tile;
2013 double a, b;
2014 void *data;
2015
2016 ret = sscanf (p + 4, " %" FMT_ptr " %d %d %d %d %" FMT_ptr,
2017 FMT_ptr_cast (&page), &x, &y, &w, &h, &data);
2018 if (ret != 6) {
2019 errx (1, "bad tile line `%.*s' ret=%d", len, p, ret);
2020 }
2021
2022 lock ("tile");
2023 a = now ();
2024 tile = rendertile (page, x, y, w, h, data);
2025 b = now ();
2026 unlock ("tile");
2027
2028 printd ("tile %d %d %" FMT_ptr " %u %f",
2029 x, y,
2030 FMT_ptr_cast2 (tile),
2031 tile->w * tile->h * tile->pixmap->n,
2032 b - a);
2033 }
2034 else if (!strncmp ("settrim", p, 7)) {
2035 fz_irect fuzz;
2036 int trimmargins;
2037
2038 ret = sscanf (p + 7, " %d %d %d %d %d",
2039 &trimmargins, &fuzz.x0, &fuzz.y0, &fuzz.x1, &fuzz.y1);
2040 if (ret != 5) {
2041 errx (1, "malformed settrim `%.*s' ret=%d", len, p, ret);
2042 }
2043 printd ("clear");
2044 lock ("settrim");
2045 state.trimmargins = trimmargins;
2046 state.needoutline = 1;
2047 if (memcmp (&fuzz, &state.trimfuzz, sizeof (fuzz))) {
2048 state.trimanew = 1;
2049 state.trimfuzz = fuzz;
2050 }
2051 state.pagedimcount = 0;
2052 free (state.pagedims);
2053 state.pagedims = NULL;
2054 initpdims ();
2055 layout ();
2056 process_outline ();
2057 unlock ("settrim");
2058 printd ("continue %d", state.pagecount);
2059 }
2060 else if (!strncmp ("sliceh", p, 6)) {
2061 int h;
2062
2063 ret = sscanf (p + 6, " %d", &h);
2064 if (ret != 1) {
2065 errx (1, "malformed sliceh `%.*s' ret=%d", len, p, ret);
2066 }
2067 if (h != state.sliceheight) {
2068 int i;
2069
2070 state.sliceheight = h;
2071 for (i = 0; i < state.texcount; ++i) {
2072 state.texowners[i].w = -1;
2073 state.texowners[i].h = -1;
2074 state.texowners[i].slice = NULL;
2075 }
2076 }
2077 }
2078 else if (!strncmp ("interrupt", p, 9)) {
2079 printd ("vmsg interrupted");
2080 }
2081 else {
2082 errx (1, "unknown command %.*s", len, p);
2083 }
2084 }
2085 return 0;
2086 }
2087
2088 CAMLprim value ml_realloctexts (value texcount_v)
2089 {
2090 CAMLparam1 (texcount_v);
2091 int ok;
2092
2093 if (trylock ("ml_realloctexts")) {
2094 ok = 0;
2095 goto done;
2096 }
2097 realloctexts (Int_val (texcount_v));
2098 ok = 1;
2099 unlock ("ml_realloctexts");
2100
2101 done:
2102 CAMLreturn (Val_bool (ok));
2103 }
2104
2105 static void recti (int x0, int y0, int x1, int y1)
2106 {
2107 GLfloat *v = state.vertices;
2108
2109 glVertexPointer (2, GL_FLOAT, 0, v);
2110 v[0] = x0; v[1] = y0;
2111 v[2] = x1; v[3] = y0;
2112 v[4] = x0; v[5] = y1;
2113 v[6] = x1; v[7] = y1;
2114 glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
2115 }
2116
2117 static void showsel (struct page *page, int ox, int oy)
2118 {
2119 int seen = 0;
2120 fz_irect bbox;
2121 fz_rect rect;
2122 fz_text_line *line;
2123 fz_page_block *pageb;
2124 fz_text_block *block;
2125 struct mark first, last;
2126
2127 first = page->fmark;
2128 last = page->lmark;
2129
2130 if (!first.span || !last.span) return;
2131
2132 glEnable (GL_BLEND);
2133 glBlendFunc (GL_SRC_ALPHA, GL_SRC_ALPHA);
2134 glColor4f (0.5f, 0.5f, 0.0f, 0.6f);
2135
2136 ox += state.pagedims[page->pdimno].bounds.x0;
2137 oy += state.pagedims[page->pdimno].bounds.y0;
2138 for (pageb = page->text->blocks;
2139 pageb < page->text->blocks + page->text->len;
2140 ++pageb) {
2141 if (pageb->type != FZ_PAGE_BLOCK_TEXT) continue;
2142 block = pageb->u.text;
2143
2144 for (line = block->lines;
2145 line < block->lines + block->len;
2146 ++line) {
2147 fz_text_span *span;
2148 rect = fz_empty_rect;
2149
2150 for (span = line->first_span; span; span = span->next) {
2151 int i, j, k;
2152 bbox.x0 = bbox.y0 = bbox.x1 = bbox.y1 = 0;
2153
2154 j = 0;
2155 k = span->len - 1;
2156
2157 if (span == page->fmark.span && span == page->lmark.span) {
2158 seen = 1;
2159 j = MIN (first.i, last.i);
2160 k = MAX (first.i, last.i);
2161 }
2162 else {
2163 if (span == first.span) {
2164 seen = 1;
2165 j = first.i;
2166 }
2167 else if (span == last.span) {
2168 seen = 1;
2169 k = last.i;
2170 }
2171 }
2172
2173 if (seen) {
2174 for (i = j; i <= k; ++i) {
2175 fz_rect bbox;
2176 fz_union_rect (&rect,
2177 fz_text_char_bbox (&bbox, span, i));
2178 }
2179 fz_round_rect (&bbox, &rect);
2180 lprintf ("%d %d %d %d oy=%d ox=%d\n",
2181 bbox.x0,
2182 bbox.y0,
2183 bbox.x1,
2184 bbox.y1,
2185 oy, ox);
2186
2187 recti (bbox.x0 + ox, bbox.y0 + oy,
2188 bbox.x1 + ox, bbox.y1 + oy);
2189 if (span == last.span) {
2190 goto done;
2191 }
2192 rect = fz_empty_rect;
2193 }
2194 }
2195 }
2196 }
2197 done:
2198 glDisable (GL_BLEND);
2199 }
2200
2201 #include "glfont.c"
2202
2203 static void highlightlinks (struct page *page, int xoff, int yoff)
2204 {
2205 fz_matrix ctm, tm, pm;
2206 fz_link *link, *links;
2207 GLfloat *texcoords = state.texcoords;
2208 GLfloat *vertices = state.vertices;
2209
2210 switch (page->type) {
2211 case DPDF:
2212 links = page->u.pdfpage->links;
2213 break;
2214
2215 case DXPS:
2216 links = page->u.xpspage->links;
2217 break;
2218
2219 default:
2220 return;
2221 }
2222
2223 glEnable (GL_TEXTURE_1D);
2224 glEnable (GL_BLEND);
2225 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2226 glBindTexture (GL_TEXTURE_1D, state.stid);
2227
2228 xoff -= state.pagedims[page->pdimno].bounds.x0;
2229 yoff -= state.pagedims[page->pdimno].bounds.y0;
2230 fz_translate (&tm, xoff, yoff);
2231 pm = pagectm (page);
2232 fz_concat (&ctm, &pm, &tm);
2233
2234 glTexCoordPointer (1, GL_FLOAT, 0, texcoords);
2235 glVertexPointer (2, GL_FLOAT, 0, vertices);
2236
2237 for (link = links; link; link = link->next) {
2238 fz_point p1, p2, p3, p4;
2239
2240 p1.x = link->rect.x0;
2241 p1.y = link->rect.y0;
2242
2243 p2.x = link->rect.x1;
2244 p2.y = link->rect.y0;
2245
2246 p3.x = link->rect.x1;
2247 p3.y = link->rect.y1;
2248
2249 p4.x = link->rect.x0;
2250 p4.y = link->rect.y1;
2251
2252 fz_transform_point (&p1, &ctm);
2253 fz_transform_point (&p2, &ctm);
2254 fz_transform_point (&p3, &ctm);
2255 fz_transform_point (&p4, &ctm);
2256
2257 switch (link->dest.kind) {
2258 case FZ_LINK_GOTO: glColor3ub (255, 0, 0); break;
2259 case FZ_LINK_URI: glColor3ub (0, 0, 255); break;
2260 case FZ_LINK_LAUNCH: glColor3ub (0, 255, 0); break;
2261 default: glColor3ub (0, 0, 0); break;
2262 }
2263
2264 {
2265 float w, h, s, t;
2266
2267 w = p2.x - p1.x;
2268 h = p2.y - p1.y;
2269 t = sqrtf (w*w + h*h) * .25f;
2270
2271 w = p3.x - p2.x;
2272 h = p3.y - p2.y;
2273 s = sqrtf (w*w + h*h) * .25f;
2274
2275 texcoords[0] = 0; vertices[0] = p1.x; vertices[1] = p1.y;
2276 texcoords[1] = t; vertices[2] = p2.x; vertices[3] = p2.y;
2277
2278 texcoords[2] = 0; vertices[4] = p2.x; vertices[5] = p2.y;
2279 texcoords[3] = s; vertices[6] = p3.x; vertices[7] = p3.y;
2280
2281 texcoords[4] = 0; vertices[8] = p3.x; vertices[9] = p3.y;
2282 texcoords[5] = t; vertices[10] = p4.x; vertices[11] = p4.y;
2283
2284 texcoords[6] = 0; vertices[12] = p4.x; vertices[13] = p4.y;
2285 texcoords[7] = s; vertices[14] = p1.x; vertices[15] = p1.y;
2286 }
2287 glDrawArrays (GL_LINES, 0, 8);
2288 }
2289
2290 glDisable (GL_BLEND);
2291 glDisable (GL_TEXTURE_1D);
2292 }
2293
2294 static int compareslinks (const void *l, const void *r)
2295 {
2296 struct slink const *ls = l;
2297 struct slink const *rs = r;
2298 if (ls->bbox.y0 == rs->bbox.y0) {
2299 return rs->bbox.x0 - rs->bbox.x0;
2300 }
2301 return ls->bbox.y0 - rs->bbox.y0;
2302 }
2303
2304 static void droptext (struct page *page)
2305 {
2306 if (page->text) {
2307 fz_free_text_page (state.ctx, page->text);
2308 page->fmark.i = -1;
2309 page->lmark.i = -1;
2310 page->fmark.span = NULL;
2311 page->lmark.span = NULL;
2312 page->text = NULL;
2313 }
2314 if (page->sheet) {
2315 fz_free_text_sheet (state.ctx, page->sheet);
2316 page->sheet = NULL;
2317 }
2318 }
2319
2320 static void dropslinks (struct page *page)
2321 {
2322 if (page->slinks) {
2323 free (page->slinks);
2324 page->slinks = NULL;
2325 page->slinkcount = 0;
2326 }
2327 }
2328
2329 static void ensureslinks (struct page *page)
2330 {
2331 fz_matrix ctm;
2332 int i, count = 0;
2333 size_t slinksize = sizeof (*page->slinks);
2334 fz_link *link, *links;
2335
2336 if (state.gen != page->sgen) {
2337 dropslinks (page);
2338 page->sgen = state.gen;
2339 }
2340 if (page->slinks) return;
2341
2342 switch (page->type) {
2343 case DPDF:
2344 links = page->u.pdfpage->links;
2345 trimctm (page->u.pdfpage, page->pdimno);
2346 fz_concat (&ctm,
2347 &state.pagedims[page->pdimno].tctm,
2348 &state.pagedims[page->pdimno].ctm);
2349 break;
2350
2351 case DXPS:
2352 links = page->u.xpspage->links;
2353 ctm = state.pagedims[page->pdimno].ctm;
2354 break;
2355
2356 default:
2357 return;
2358 }
2359
2360 for (link = links; link; link = link->next) {
2361 count++;
2362 }
2363 if (count > 0) {
2364 page->slinkcount = count;
2365 page->slinks = calloc (count, slinksize);
2366 if (!page->slinks) {
2367 err (1, "realloc slinks %d", count);
2368 }
2369
2370 for (i = 0, link = links; link; ++i, link = link->next) {
2371 fz_rect rect;
2372
2373 rect = link->rect;
2374 fz_transform_rect (&rect, &ctm);
2375 page->slinks[i].link = link;
2376 fz_round_rect (&page->slinks[i].bbox, &rect);
2377 }
2378 qsort (page->slinks, count, slinksize, compareslinks);
2379 }
2380 }
2381
2382 /* slightly tweaked fmt_ulong by D.J. Bernstein */
2383 static void fmt_linkn (char *s, unsigned int u)
2384 {
2385 unsigned int len; unsigned int q;
2386 int zma = 'z' - 'a' + 1;
2387 len = 1; q = u;
2388 while (q > zma - 1) { ++len; q /= zma; }
2389 if (s) {
2390 s += len;
2391 do { *--s = 'a' + (u % zma) - (u < zma && len > 1); u /= zma; } while(u);
2392 /* handles u == 0 */
2393 }
2394 s[len] = 0;
2395 }
2396
2397 static void highlightslinks (struct page *page, int xoff, int yoff,
2398 int noff, char *targ, int tlen, int hfsize)
2399 {
2400 int i;
2401 char buf[40];
2402 struct slink *slink;
2403 double x0, y0, x1, y1, w;
2404
2405 ensureslinks (page);
2406 glColor3ub (0xc3, 0xb0, 0x91);
2407 for (i = 0; i < page->slinkcount; ++i) {
2408 fmt_linkn (buf, i + noff);
2409 if (!tlen || !strncmp (targ, buf, tlen)) {
2410 slink = &page->slinks[i];
2411
2412 x0 = slink->bbox.x0 + xoff - 5;
2413 y1 = slink->bbox.y0 + yoff - 5;
2414 y0 = y1 + 10 + hfsize;
2415 w = measure_string (state.face, hfsize, buf);
2416 x1 = x0 + w + 10;
2417 recti (x0, y0, x1, y1);
2418 }
2419 }
2420
2421 glEnable (GL_BLEND);
2422 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2423 glEnable (GL_TEXTURE_2D);
2424 glColor3ub (0, 0, 0);
2425 for (i = 0; i < page->slinkcount; ++i) {
2426 fmt_linkn (buf, i + noff);
2427 if (!tlen || !strncmp (targ, buf, tlen)) {
2428 slink = &page->slinks[i];
2429
2430 x0 = slink->bbox.x0 + xoff;
2431 y0 = slink->bbox.y0 + yoff + hfsize;
2432 draw_string (state.face, hfsize, x0, y0, buf);
2433 }
2434 }
2435 glDisable (GL_TEXTURE_2D);
2436 glDisable (GL_BLEND);
2437 }
2438
2439 static void uploadslice (struct tile *tile, struct slice *slice)
2440 {
2441 int offset;
2442 struct slice *slice1;
2443 unsigned char *texdata;
2444
2445 offset = 0;
2446 for (slice1 = tile->slices; slice != slice1; slice1++) {
2447 offset += slice1->h * tile->w * tile->pixmap->n;
2448 }
2449 if (slice->texindex != -1 && slice->texindex < state.texcount
2450 && state.texowners[slice->texindex].slice == slice) {
2451 glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
2452 }
2453 else {
2454 int subimage = 0;
2455 int texindex = state.texindex++ % state.texcount;
2456
2457 if (state.texowners[texindex].w == tile->w) {
2458 if (state.texowners[texindex].h >= slice->h) {
2459 subimage = 1;
2460 }
2461 else {
2462 state.texowners[texindex].h = slice->h;
2463 }
2464 }
2465 else {
2466 state.texowners[texindex].h = slice->h;
2467 }
2468
2469 state.texowners[texindex].w = tile->w;
2470 state.texowners[texindex].slice = slice;
2471 slice->texindex = texindex;
2472
2473 glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[texindex]);
2474 if (tile->pbo) {
2475 state.glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB, tile->pbo->id);
2476 texdata = 0;
2477 }
2478 else {
2479 texdata = tile->pixmap->samples;
2480 }
2481 if (subimage) {
2482 glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB,
2483 0,
2484 0,
2485 0,
2486 tile->w,
2487 slice->h,
2488 state.texform,
2489 state.texty,
2490 texdata+offset
2491 );
2492 }
2493 else {
2494 glTexImage2D (GL_TEXTURE_RECTANGLE_ARB,
2495 0,
2496 state.texiform,
2497 tile->w,
2498 slice->h,
2499 0,
2500 state.texform,
2501 state.texty,
2502 texdata+offset
2503 );
2504 }
2505 if (tile->pbo) {
2506 state.glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB, 0);
2507 }
2508 }
2509 }
2510
2511 CAMLprim value ml_begintiles (value unit_v)
2512 {
2513 CAMLparam1 (unit_v);
2514 glEnable (GL_TEXTURE_RECTANGLE_ARB);
2515 glTexCoordPointer (2, GL_FLOAT, 0, state.texcoords);
2516 glVertexPointer (2, GL_FLOAT, 0, state.vertices);
2517 CAMLreturn (unit_v);
2518 }
2519
2520 CAMLprim value ml_endtiles (value unit_v)
2521 {
2522 CAMLparam1 (unit_v);
2523 glDisable (GL_TEXTURE_RECTANGLE_ARB);
2524 CAMLreturn (unit_v);
2525 }
2526
2527 CAMLprim value ml_drawtile (value args_v, value ptr_v)
2528 {
2529 CAMLparam2 (args_v, ptr_v);
2530 int dispx = Int_val (Field (args_v, 0));
2531 int dispy = Int_val (Field (args_v, 1));
2532 int dispw = Int_val (Field (args_v, 2));
2533 int disph = Int_val (Field (args_v, 3));
2534 int tilex = Int_val (Field (args_v, 4));
2535 int tiley = Int_val (Field (args_v, 5));
2536 char *s = String_val (ptr_v);
2537 struct tile *tile = parse_pointer ("ml_drawtile", s);
2538 int slicey, firstslice;
2539 struct slice *slice;
2540 GLfloat *texcoords = state.texcoords;
2541 GLfloat *vertices = state.vertices;
2542
2543 firstslice = tiley / tile->sliceheight;
2544 slice = &tile->slices[firstslice];
2545 slicey = tiley % tile->sliceheight;
2546
2547 while (disph > 0) {
2548 int dh;
2549
2550 dh = slice->h - slicey;
2551 dh = MIN (disph, dh);
2552 uploadslice (tile, slice);
2553
2554 texcoords[0] = tilex; texcoords[1] = slicey;
2555 texcoords[2] = tilex+dispw; texcoords[3] = slicey;
2556 texcoords[4] = tilex; texcoords[5] = slicey+dh;
2557 texcoords[6] = tilex+dispw; texcoords[7] = slicey+dh;
2558
2559 vertices[0] = dispx; vertices[1] = dispy;
2560 vertices[2] = dispx+dispw; vertices[3] = dispy;
2561 vertices[4] = dispx; vertices[5] = dispy+dh;
2562 vertices[6] = dispx+dispw; vertices[7] = dispy+dh;
2563
2564 glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
2565 dispy += dh;
2566 disph -= dh;
2567 slice++;
2568 ARSERT (!(slice - tile->slices >= tile->slicecount && disph > 0));
2569 slicey = 0;
2570 }
2571 CAMLreturn (Val_unit);
2572 }
2573
2574 CAMLprim value ml_postprocess (value ptr_v, value hlinks_v,
2575 value xoff_v, value yoff_v,
2576 value li_v)
2577 {
2578 CAMLparam5 (ptr_v, hlinks_v, xoff_v, yoff_v, li_v);
2579 int xoff = Int_val (xoff_v);
2580 int yoff = Int_val (yoff_v);
2581 int noff = Int_val (Field (li_v, 0));
2582 char *targ = String_val (Field (li_v, 1));
2583 int tlen = caml_string_length (Field (li_v, 1));
2584 int hfsize = Int_val (Field (li_v, 2));
2585 char *s = String_val (ptr_v);
2586 int hlmask = Int_val (hlinks_v);
2587 struct page *page = parse_pointer ("ml_postprocess", s);
2588
2589 if (!page->u.ptr) {
2590 /* deal with loadpage failed pages */
2591 goto done;
2592 }
2593
2594 if (hlmask & 1) highlightlinks (page, xoff, yoff);
2595 if (trylock ("ml_postprocess")) {
2596 noff = 0;
2597 goto done;
2598 }
2599 if (hlmask & 2) {
2600 highlightslinks (page, xoff, yoff, noff, targ, tlen, hfsize);
2601 noff = page->slinkcount;
2602 }
2603 if (page->tgen == state.gen) {
2604 showsel (page, xoff, yoff);
2605 }
2606 unlock ("ml_postprocess");
2607
2608 done:
2609 CAMLreturn (Val_int (noff));
2610 }
2611
2612 static fz_link *getlink (struct page *page, int x, int y)
2613 {
2614 fz_point p;
2615 fz_matrix ctm;
2616 const fz_matrix *tctm;
2617 fz_link *link, *links;
2618
2619 switch (page->type) {
2620 case DPDF:
2621 trimctm (page->u.pdfpage, page->pdimno);
2622 tctm = &state.pagedims[page->pdimno].tctm;
2623 links = page->u.pdfpage->links;
2624 break;
2625
2626 case DXPS:
2627 tctm = &fz_identity;
2628 links = page->u.xpspage->links;
2629 break;
2630
2631 default:
2632 return NULL;
2633 }
2634 p.x = x;
2635 p.y = y;
2636
2637 fz_concat (&ctm, tctm, &state.pagedims[page->pdimno].ctm);
2638 fz_invert_matrix (&ctm, &ctm);
2639 fz_transform_point (&p, &ctm);
2640
2641 for (link = links; link; link = link->next) {
2642 if (p.x >= link->rect.x0 && p.x <= link->rect.x1) {
2643 if (p.y >= link->rect.y0 && p.y <= link->rect.y1) {
2644 return link;
2645 }
2646 }
2647 }
2648 return NULL;
2649 }
2650
2651 static void ensuretext (struct page *page)
2652 {
2653 if (state.gen != page->tgen) {
2654 droptext (page);
2655 page->tgen = state.gen;
2656 }
2657 if (!page->text) {
2658 fz_matrix ctm;
2659 fz_device *tdev;
2660
2661 page->text = fz_new_text_page (state.ctx);
2662 page->sheet = fz_new_text_sheet (state.ctx);
2663 tdev = fz_new_text_device (state.ctx, page->sheet, page->text);
2664 ctm = pagectm (page);
2665 fz_begin_page (tdev, &fz_infinite_rect, &ctm);
2666 fz_run_display_list (page->dlist, tdev, &ctm, &fz_infinite_rect, NULL);
2667 qsort (page->text->blocks, page->text->len,
2668 sizeof (*page->text->blocks), compareblocks);
2669 fz_end_page (tdev);
2670 fz_free_device (tdev);
2671 }
2672 }
2673
2674 CAMLprim value ml_find_page_with_links (value start_page_v, value dir_v)
2675 {
2676 CAMLparam2 (start_page_v, dir_v);
2677 CAMLlocal1 (ret_v);
2678 int i, dir = Int_val (dir_v);
2679 int start_page = Int_val (start_page_v);
2680 int end_page = dir > 0 ? state.pagecount : -1;
2681
2682 ret_v = Val_int (0);
2683 if (!(state.type == DPDF || state.type == DXPS)) {
2684 goto done;
2685 }
2686
2687 lock ("ml_findpage_with_links");
2688 for (i = start_page + dir; i != end_page; i += dir) {
2689 int found;
2690
2691 switch (state.type) {
2692 case DPDF:
2693 {
2694 pdf_page *page = NULL;
2695
2696 fz_try (state.ctx) {
2697 page = pdf_load_page (state.u.pdf, i);
2698 found = !!page->links;
2699 }
2700 fz_catch (state.ctx) {
2701 found = 0;
2702 }
2703 if (page) {
2704 freepdfpage (page);
2705 }
2706 }
2707 break;
2708 case DXPS:
2709 {
2710 xps_page *page = xps_load_page (state.u.xps, i);
2711 found = !!page->links;
2712 freexpspage (page);
2713 }
2714 break;
2715
2716 default:
2717 ARSERT (0 && "invalid document type");
2718 }
2719
2720 if (found) {
2721 ret_v = caml_alloc_small (1, 1);
2722 Field (ret_v, 0) = Val_int (i);
2723 goto unlock;
2724 }
2725 }
2726 unlock:
2727 unlock ("ml_findpage_with_links");
2728
2729 done:
2730 CAMLreturn (ret_v);
2731 }
2732
2733 enum { dir_first, dir_last };
2734 enum { dir_first_visible, dir_left, dir_right, dir_down, dir_up };
2735
2736 CAMLprim value ml_findlink (value ptr_v, value dir_v)
2737 {
2738 CAMLparam2 (ptr_v, dir_v);
2739 CAMLlocal2 (ret_v, pos_v);
2740 struct page *page;
2741 int dirtag, i, slinkindex;
2742 struct slink *found = NULL ,*slink;
2743 char *s = String_val (ptr_v);
2744
2745 page = parse_pointer ("ml_findlink", s);
2746 ret_v = Val_int (0);
2747 if (trylock ("ml_findlink")) {
2748 goto done;
2749 }
2750
2751 ensureslinks (page);
2752
2753 if (Is_block (dir_v)) {
2754 dirtag = Tag_val (dir_v);
2755 switch (dirtag) {
2756 case dir_first_visible:
2757 {
2758 int x0, y0, dir, first_index, last_index;
2759
2760 pos_v = Field (dir_v, 0);
2761 x0 = Int_val (Field (pos_v, 0));
2762 y0 = Int_val (Field (pos_v, 1));
2763 dir = Int_val (Field (pos_v, 2));
2764
2765 if (dir >= 0) {
2766 dir = 1;
2767 first_index = 0;
2768 last_index = page->slinkcount;
2769 }
2770 else {
2771 first_index = page->slinkcount - 1;
2772 last_index = -1;
2773 }
2774
2775 for (i = first_index; i != last_index; i += dir) {
2776 slink = &page->slinks[i];
2777 if (slink->bbox.y0 >= y0 && slink->bbox.x0 >= x0) {
2778 found = slink;
2779 break;
2780 }
2781 }
2782 }
2783 break;
2784
2785 case dir_left:
2786 slinkindex = Int_val (Field (dir_v, 0));
2787 found = &page->slinks[slinkindex];
2788 for (i = slinkindex - 1; i >= 0; --i) {
2789 slink = &page->slinks[i];
2790 if (slink->bbox.x0 < found->bbox.x0) {
2791 found = slink;
2792 break;
2793 }
2794 }
2795 break;
2796
2797 case dir_right:
2798 slinkindex = Int_val (Field (dir_v, 0));
2799 found = &page->slinks[slinkindex];
2800 for (i = slinkindex + 1; i < page->slinkcount; ++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_down:
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.y0 >= found->bbox.y0) {
2815 found = slink;
2816 break;
2817 }
2818 }
2819 break;
2820
2821 case dir_up:
2822 slinkindex = Int_val (Field (dir_v, 0));
2823 found = &page->slinks[slinkindex];
2824 for (i = slinkindex - 1; i >= 0; --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 }
2834 else {
2835 dirtag = Int_val (dir_v);
2836 switch (dirtag) {
2837 case dir_first:
2838 found = page->slinks;
2839 break;
2840
2841 case dir_last:
2842 if (page->slinks) {
2843 found = page->slinks + (page->slinkcount - 1);
2844 }
2845 break;
2846 }
2847 }
2848 if (found) {
2849 ret_v = caml_alloc_small (2, 1);
2850 Field (ret_v, 0) = Val_int (found - page->slinks);
2851 }
2852
2853 unlock ("ml_findlink");
2854 done:
2855 CAMLreturn (ret_v);
2856 }
2857
2858 enum { uuri, ugoto, utext, uunexpected,
2859 ulaunch, unamed, uremote, uremotedest };
2860
2861 #define LINKTOVAL \
2862 { \
2863 int pageno; \
2864 \
2865 switch (link->dest.kind) { \
2866 case FZ_LINK_GOTO: \
2867 { \
2868 fz_point p; \
2869 \
2870 pageno = link->dest.ld.gotor.page; \
2871 p.x = 0; \
2872 p.y = 0; \
2873 \
2874 if (link->dest.ld.gotor.flags & fz_link_flag_t_valid) { \
2875 p.y = link->dest.ld.gotor.lt.y; \
2876 fz_transform_point (&p, &pdim->lctm); \
2877 } \
2878 tup_v = caml_alloc_tuple (2); \
2879 ret_v = caml_alloc_small (1, ugoto); \
2880 Field (tup_v, 0) = Val_int (pageno); \
2881 Field (tup_v, 1) = Val_int (p.y); \
2882 Field (ret_v, 0) = tup_v; \
2883 } \
2884 break; \
2885 \
2886 case FZ_LINK_URI: \
2887 str_v = caml_copy_string (link->dest.ld.uri.uri); \
2888 ret_v = caml_alloc_small (1, uuri); \
2889 Field (ret_v, 0) = str_v; \
2890 break; \
2891 \
2892 case FZ_LINK_LAUNCH: \
2893 str_v = caml_copy_string (link->dest.ld.launch.file_spec); \
2894 ret_v = caml_alloc_small (1, ulaunch); \
2895 Field (ret_v, 0) = str_v; \
2896 break; \
2897 \
2898 case FZ_LINK_NAMED: \
2899 str_v = caml_copy_string (link->dest.ld.named.named); \
2900 ret_v = caml_alloc_small (1, unamed); \
2901 Field (ret_v, 0) = str_v; \
2902 break; \
2903 \
2904 case FZ_LINK_GOTOR: \
2905 { \
2906 int rty; \
2907 \
2908 str_v = caml_copy_string (link->dest.ld.gotor.file_spec); \
2909 pageno = link->dest.ld.gotor.page; \
2910 if (pageno == -1) { \
2911 gr_v = caml_copy_string (link->dest.ld.gotor.dest); \
2912 rty = uremotedest; \
2913 } \
2914 else { \
2915 gr_v = Val_int (pageno); \
2916 rty = uremote; \
2917 } \
2918 tup_v = caml_alloc_tuple (2); \
2919 ret_v = caml_alloc_small (1, rty); \
2920 Field (tup_v, 0) = str_v; \
2921 Field (tup_v, 1) = gr_v; \
2922 Field (ret_v, 0) = tup_v; \
2923 } \
2924 break; \
2925 \
2926 default: \
2927 { \
2928 char buf[80]; \
2929 \
2930 snprintf (buf, sizeof (buf), \
2931 "unhandled link kind %d", link->dest.kind); \
2932 str_v = caml_copy_string (buf); \
2933 ret_v = caml_alloc_small (1, uunexpected); \
2934 Field (ret_v, 0) = str_v; \
2935 } \
2936 break; \
2937 } \
2938 }
2939
2940 CAMLprim value ml_getlink (value ptr_v, value n_v)
2941 {
2942 CAMLparam2 (ptr_v, n_v);
2943 CAMLlocal4 (ret_v, tup_v, str_v, gr_v);
2944 fz_link *link;
2945 struct page *page;
2946 struct pagedim *pdim;
2947 char *s = String_val (ptr_v);
2948
2949 ret_v = Val_int (0);
2950 if (trylock ("ml_getlink")) {
2951 goto done;
2952 }
2953
2954 page = parse_pointer ("ml_getlink", s);
2955 ensureslinks (page);
2956 pdim = &state.pagedims[page->pdimno];
2957 link = page->slinks[Int_val (n_v)].link;
2958 LINKTOVAL;
2959
2960 unlock ("ml_getlink");
2961 done:
2962 CAMLreturn (ret_v);
2963 }
2964
2965 CAMLprim value ml_getlinkcount (value ptr_v)
2966 {
2967 CAMLparam1 (ptr_v);
2968 struct page *page;
2969 char *s = String_val (ptr_v);
2970
2971 page = parse_pointer ("ml_getlinkcount", s);
2972 CAMLreturn (Val_int (page->slinkcount));
2973 }
2974
2975 CAMLprim value ml_getlinkrect (value ptr_v, value n_v)
2976 {
2977 CAMLparam2 (ptr_v, n_v);
2978 CAMLlocal1 (ret_v);
2979 struct page *page;
2980 struct slink *slink;
2981 char *s = String_val (ptr_v);
2982
2983 page = parse_pointer ("ml_getlinkrect", s);
2984 ret_v = caml_alloc_tuple (4);
2985 if (trylock ("ml_getlinkrect")) {
2986 Field (ret_v, 0) = Val_int (0);
2987 Field (ret_v, 1) = Val_int (0);
2988 Field (ret_v, 2) = Val_int (0);
2989 Field (ret_v, 3) = Val_int (0);
2990 goto done;
2991 }
2992 ensureslinks (page);
2993
2994 slink = &page->slinks[Int_val (n_v)];
2995 Field (ret_v, 0) = Val_int (slink->bbox.x0);
2996 Field (ret_v, 1) = Val_int (slink->bbox.y0);
2997 Field (ret_v, 2) = Val_int (slink->bbox.x1);
2998 Field (ret_v, 3) = Val_int (slink->bbox.y1);
2999 unlock ("ml_getlinkrect");
3000
3001 done:
3002 CAMLreturn (ret_v);
3003 }
3004
3005 CAMLprim value ml_whatsunder (value ptr_v, value x_v, value y_v)
3006 {
3007 CAMLparam3 (ptr_v, x_v, y_v);
3008 CAMLlocal4 (ret_v, tup_v, str_v, gr_v);
3009 fz_link *link;
3010 struct page *page;
3011 char *s = String_val (ptr_v);
3012 int x = Int_val (x_v), y = Int_val (y_v);
3013 struct pagedim *pdim;
3014
3015 ret_v = Val_int (0);
3016 if (trylock ("ml_whatsunder")) {
3017 goto done;
3018 }
3019
3020 page = parse_pointer ("ml_whatsunder", s);
3021 pdim = &state.pagedims[page->pdimno];
3022 x += pdim->bounds.x0;
3023 y += pdim->bounds.y0;
3024 link = getlink (page, x, y);
3025 if (link) {
3026 LINKTOVAL;
3027 }
3028 else {
3029 fz_rect *b;
3030 fz_page_block *pageb;
3031 fz_text_block *block;
3032
3033 ensuretext (page);
3034 for (pageb = page->text->blocks;
3035 pageb < page->text->blocks + page->text->len;
3036 ++pageb) {
3037 fz_text_line *line;
3038 if (pageb->type != FZ_PAGE_BLOCK_TEXT) continue;
3039 block = pageb->u.text;
3040
3041 b = &block->bbox;
3042 if (!(x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1))
3043 continue;
3044
3045 for (line = block->lines;
3046 line < block->lines + block->len;
3047 ++line) {
3048 fz_text_span *span;
3049
3050 b = &line->bbox;
3051 if (!(x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1))
3052 continue;
3053
3054 for (span = line->first_span; span; span = span->next) {
3055 int charnum;
3056
3057 b = &span->bbox;
3058 if (!(x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1))
3059 continue;
3060
3061 for (charnum = 0; charnum < span->len; ++charnum) {
3062 fz_rect bbox;
3063 fz_text_char_bbox (&bbox, span, charnum);
3064 b = &bbox;
3065
3066 if (x >= b->x0 && x <= b->x1
3067 && y >= b->y0 && y <= b->y1) {
3068 fz_text_style *style = span->text->style;
3069 const char *n2 =
3070 style->font && style->font->name
3071 ? style->font->name
3072 : "Span has no font name"
3073 ;
3074 FT_FaceRec *face = style->font->ft_face;
3075 if (face && face->family_name) {
3076 char *s;
3077 char *n1 = face->family_name;
3078 size_t l1 = strlen (n1);
3079 size_t l2 = strlen (n2);
3080
3081 if (l1 != l2 || memcmp (n1, n2, l1)) {
3082 s = malloc (l1 + l2 + 2);
3083 if (s) {
3084 memcpy (s, n2, l2);
3085 s[l2] = '=';
3086 memcpy (s + l2 + 1, n1, l1 + 1);
3087 str_v = caml_copy_string (s);
3088 free (s);
3089 }
3090 }
3091 }
3092 if (str_v == 0) {
3093 str_v = caml_copy_string (n2);
3094 }
3095 ret_v = caml_alloc_small (1, utext);
3096 Field (ret_v, 0) = str_v;
3097 goto unlock;
3098 }
3099 }
3100 }
3101 }
3102 }
3103 }
3104 unlock:
3105 unlock ("ml_whatsunder");
3106
3107 done:
3108 CAMLreturn (ret_v);
3109 }
3110
3111 enum { mark_page, mark_block, mark_line, mark_word };
3112
3113 static int uninteresting (int c)
3114 {
3115 return c == ' ' || c == '\n' || c == '\t' || c == '\n' || c == '\r'
3116 || ispunct (c);
3117 }
3118
3119 CAMLprim value ml_clearmark (value ptr_v)
3120 {
3121 CAMLparam1 (ptr_v);
3122 char *s = String_val (ptr_v);
3123 struct page *page;
3124
3125 if (trylock ("ml_clearmark")) {
3126 goto done;
3127 }
3128
3129 page = parse_pointer ("ml_clearmark", s);
3130 page->fmark.span = NULL;
3131 page->lmark.span = NULL;
3132 page->fmark.i = 0;
3133 page->lmark.i = 0;
3134
3135 unlock ("ml_clearmark");
3136 done:
3137 CAMLreturn (Val_unit);
3138 }
3139
3140 CAMLprim value ml_markunder (value ptr_v, value x_v, value y_v, value mark_v)
3141 {
3142 CAMLparam4 (ptr_v, x_v, y_v, mark_v);
3143 CAMLlocal1 (ret_v);
3144 fz_rect *b;
3145 struct page *page;
3146 fz_text_line *line;
3147 fz_page_block *pageb;
3148 fz_text_block *block;
3149 struct pagedim *pdim;
3150 int mark = Int_val (mark_v);
3151 char *s = String_val (ptr_v);
3152 int x = Int_val (x_v), y = Int_val (y_v);
3153
3154 ret_v = Val_bool (0);
3155 if (trylock ("ml_markunder")) {
3156 goto done;
3157 }
3158
3159 page = parse_pointer ("ml_markunder", s);
3160 pdim = &state.pagedims[page->pdimno];
3161
3162 ensuretext (page);
3163
3164 if (mark == mark_page) {
3165 int i;
3166 fz_page_block *pb1 = NULL, *pb2 = NULL;
3167
3168 for (i = 0; i < page->text->len; ++i) {
3169 if (page->text->blocks[i].type == FZ_PAGE_BLOCK_TEXT) {
3170 pb1 = &page->text->blocks[i];
3171 break;
3172 }
3173 }
3174 if (!pb1) goto unlock;
3175
3176 for (i = page->text->len - 1; i >= 0; --i) {
3177 if (page->text->blocks[i].type == FZ_PAGE_BLOCK_TEXT) {
3178 pb2 = &page->text->blocks[i];
3179 break;
3180 }
3181 }
3182 if (!pb2) goto unlock;
3183
3184 block = pb1->u.text;
3185
3186 page->fmark.i = 0;
3187 page->fmark.span = block->lines->first_span;
3188
3189 block = pb2->u.text;
3190 line = &block->lines[block->len - 1];
3191 page->lmark.i = line->last_span->len - 1;
3192 page->lmark.span = line->last_span;
3193 ret_v = Val_bool (1);
3194 goto unlock;
3195 }
3196
3197 x += pdim->bounds.x0;
3198 y += pdim->bounds.y0;
3199
3200 for (pageb = page->text->blocks;
3201 pageb < page->text->blocks + page->text->len;
3202 ++pageb) {
3203 if (pageb->type != FZ_PAGE_BLOCK_TEXT) continue;
3204 block = pageb->u.text;
3205
3206 b = &block->bbox;
3207 if (!(x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1))
3208 continue;
3209
3210 if (mark == mark_block) {
3211 page->fmark.i = 0;
3212 page->fmark.span = block->lines->first_span;
3213
3214 line = &block->lines[block->len - 1];
3215 page->lmark.i = line->last_span->len - 1;
3216 page->lmark.span = line->last_span;
3217 ret_v = Val_bool (1);
3218 goto unlock;
3219 }
3220
3221 for (line = block->lines;
3222 line < block->lines + block->len;
3223 ++line) {
3224 fz_text_span *span;
3225
3226 b = &line->bbox;
3227 if (!(x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1))
3228 continue;
3229
3230 if (mark == mark_line) {
3231 page->fmark.i = 0;
3232 page->fmark.span = line->first_span;
3233
3234 page->lmark.i = line->last_span->len - 1;
3235 page->lmark.span = line->last_span;
3236 ret_v = Val_bool (1);
3237 goto unlock;
3238 }
3239
3240 for (span = line->first_span; span; span = span->next) {
3241 int charnum;
3242
3243 b = &span->bbox;
3244 if (!(x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1))
3245 continue;
3246
3247 for (charnum = 0; charnum < span->len; ++charnum) {
3248 fz_rect bbox;
3249 fz_text_char_bbox (&bbox, span, charnum);
3250 b = &bbox;
3251
3252 if (x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1) {
3253 /* unicode ftw */
3254 int charnum2, charnum3 = -1, charnum4 = -1;
3255
3256 if (uninteresting (span->text[charnum].c)) goto unlock;
3257
3258 for (charnum2 = charnum; charnum2 >= 0; --charnum2) {
3259 if (uninteresting (span->text[charnum2].c)) {
3260 charnum3 = charnum2 + 1;
3261 break;
3262 }
3263 }
3264 if (charnum3 == -1) charnum3 = 0;
3265
3266 for (charnum2 = charnum + 1;
3267 charnum2 < span->len;
3268 ++charnum2) {
3269 if (uninteresting (span->text[charnum2].c)) break;
3270 charnum4 = charnum2;
3271 }
3272 if (charnum4 == -1) goto unlock;
3273
3274 page->fmark.i = charnum3;
3275 page->fmark.span = span;
3276
3277 page->lmark.i = charnum4;
3278 page->lmark.span = span;
3279 ret_v = Val_bool (1);
3280 goto unlock;
3281 }
3282 }
3283 }
3284 }
3285 }
3286 unlock:
3287 if (!Bool_val (ret_v)) {
3288 page->fmark.span = NULL;
3289 page->lmark.span = NULL;
3290 page->fmark.i = 0;
3291 page->lmark.i = 0;
3292 }
3293 unlock ("ml_markunder");
3294
3295 done:
3296 CAMLreturn (ret_v);
3297 }
3298
3299 CAMLprim value ml_rectofblock (value ptr_v, value x_v, value y_v)
3300 {
3301 CAMLparam3 (ptr_v, x_v, y_v);
3302 CAMLlocal2 (ret_v, res_v);
3303 fz_rect *b = NULL;
3304 struct page *page;
3305 fz_page_block *pageb;
3306 struct pagedim *pdim;
3307 char *s = String_val (ptr_v);
3308 int x = Int_val (x_v), y = Int_val (y_v);
3309
3310 ret_v = Val_int (0);
3311 if (trylock ("ml_rectofblock")) {
3312 goto done;
3313 }
3314
3315 page = parse_pointer ("ml_rectofblock", s);
3316 pdim = &state.pagedims[page->pdimno];
3317 x += pdim->bounds.x0;
3318 y += pdim->bounds.y0;
3319
3320 ensuretext (page);
3321
3322 for (pageb = page->text->blocks;
3323 pageb < page->text->blocks + page->text->len;
3324 ++pageb) {
3325 switch (pageb->type) {
3326 case FZ_PAGE_BLOCK_TEXT:
3327 b = &pageb->u.text->bbox;
3328 break;
3329
3330 case FZ_PAGE_BLOCK_IMAGE:
3331 b = &pageb->u.image->bbox;
3332 break;
3333
3334 default:
3335 continue;
3336 }
3337
3338 if (x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1)
3339 break;
3340 b = NULL;
3341 }
3342 if (b) {
3343 res_v = caml_alloc_small (4 * Double_wosize, Double_array_tag);
3344 ret_v = caml_alloc_small (1, 1);
3345 Store_double_field (res_v, 0, b->x0);
3346 Store_double_field (res_v, 1, b->x1);
3347 Store_double_field (res_v, 2, b->y0);
3348 Store_double_field (res_v, 3, b->y1);
3349 Field (ret_v, 0) = res_v;
3350 }
3351 unlock ("ml_rectofblock");
3352
3353 done:
3354 CAMLreturn (ret_v);
3355 }
3356
3357 CAMLprim value ml_seltext (value ptr_v, value rect_v)
3358 {
3359 CAMLparam2 (ptr_v, rect_v);
3360 fz_rect b;
3361 struct page *page;
3362 struct pagedim *pdim;
3363 char *s = String_val (ptr_v);
3364 int i, x0, x1, y0, y1, fi, li;
3365 fz_text_line *line;
3366 fz_page_block *pageb;
3367 fz_text_block *block;
3368 fz_text_span *span, *fspan, *lspan;
3369
3370 if (trylock ("ml_seltext")) {
3371 goto done;
3372 }
3373
3374 page = parse_pointer ("ml_seltext", s);
3375 ensuretext (page);
3376
3377 pdim = &state.pagedims[page->pdimno];
3378 x0 = Int_val (Field (rect_v, 0)) + pdim->bounds.x0;
3379 y0 = Int_val (Field (rect_v, 1)) + pdim->bounds.y0;
3380 x1 = Int_val (Field (rect_v, 2)) + pdim->bounds.x0;
3381 y1 = Int_val (Field (rect_v, 3)) + pdim->bounds.y0;
3382
3383 if (y0 > y1) {
3384 int t = y0;
3385 y0 = y1;
3386 y1 = t;
3387 x0 = x1;
3388 x1 = t;
3389 }
3390
3391 if (0) {
3392 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
3393 glColor3ub (128, 128, 128);
3394 recti (x0, y0, x1, y1);
3395 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
3396 }
3397
3398 fi = page->fmark.i;
3399 fspan = page->fmark.span;
3400
3401 li = page->lmark.i;
3402 lspan = page->lmark.span;
3403
3404 for (pageb = page->text->blocks;
3405 pageb < page->text->blocks + page->text->len;
3406 ++pageb) {
3407 if (pageb->type != FZ_PAGE_BLOCK_TEXT) continue;
3408 block = pageb->u.text;
3409 for (line = block->lines;
3410 line < block->lines + block->len;
3411 ++line) {
3412 fz_text_span *span;
3413
3414 for (span = line->first_span; span; span = span->next) {
3415 for (i = 0; i < span->len; ++i) {
3416 int selected = 0;
3417
3418 fz_text_char_bbox (&b, span, i);
3419
3420 if (x0 >= b.x0 && x0 <= b.x1
3421 && y0 >= b.y0 && y0 <= b.y1) {
3422 fspan = span;
3423 fi = i;
3424 selected = 1;
3425 }
3426 if (x1 >= b.x0 && x1 <= b.x1
3427 && y1 >= b.y0 && y1 <= b.y1) {
3428 lspan = span;
3429 li = i;
3430 selected = 1;
3431 }
3432 if (0 && selected) {
3433 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
3434 glColor3ub (128, 128, 128);
3435 recti (b.x0, b.y0, b.x1, b.y1);
3436 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
3437 }
3438 }
3439 }
3440 }
3441 }
3442 if (x1 < x0 && fspan == lspan) {
3443 i = fi;
3444 span = fspan;
3445
3446 fi = li;
3447 fspan = lspan;
3448
3449 li = i;
3450 lspan = span;
3451 }
3452
3453 page->fmark.i = fi;
3454 page->fmark.span = fspan;
3455
3456 page->lmark.i = li;
3457 page->lmark.span = lspan;
3458
3459 unlock ("ml_seltext");
3460
3461 done:
3462 CAMLreturn (Val_unit);
3463 }
3464
3465 static int UNUSED_ATTR pipespan (FILE *f, fz_text_span *span, int a, int b)
3466 {
3467 char buf[4];
3468 int i, len, ret;
3469
3470 for (i = a; i <= b; ++i) {
3471 len = fz_runetochar (buf, span->text[i].c);
3472 ret = fwrite (buf, len, 1, f);
3473
3474 if (ret != 1) {
3475 fprintf (stderr, "failed to write %d bytes ret=%d: %s\n",
3476 len, ret, strerror (errno));
3477 return -1;
3478 }
3479 }
3480 return 0;
3481 }
3482
3483 #ifdef __CYGWIN__
3484 value ml_popen (value UNUSED_ATTR u1, value UNUSED_ATTR u2)
3485 {
3486 caml_failwith ("ml_popen not implemented under Cygwin");
3487 }
3488 #else
3489 CAMLprim value ml_popen (value command_v, value fds_v)
3490 {
3491 CAMLparam2 (command_v, fds_v);
3492 CAMLlocal2 (l_v, tup_v);
3493 int ret;
3494 char *msg = NULL;
3495 value earg_v = Nothing;
3496 posix_spawnattr_t attr;
3497 posix_spawn_file_actions_t fa;
3498 char *argv[] = { "/bin/sh", "-c", String_val (command_v), NULL };
3499
3500 if ((ret = posix_spawn_file_actions_init (&fa)) != 0) {
3501 unix_error (ret, "posix_spawn_file_actions_init", Nothing);
3502 }
3503
3504 if ((ret = posix_spawnattr_init (&attr)) != 0) {
3505 msg = "posix_spawnattr_init";
3506 goto fail1;
3507 }
3508
3509 #ifdef POSIX_SPAWN_USEVFORK
3510 if ((ret = posix_spawnattr_setflags (&attr, POSIX_SPAWN_USEVFORK)) != 0) {
3511 msg = "posix_spawnattr_setflags POSIX_SPAWN_USEVFORK";
3512 goto fail;
3513 }
3514 #endif
3515
3516 for (l_v = fds_v; l_v != Val_int (0); l_v = Field (l_v, 1)) {
3517 int fd1, fd2;
3518
3519 tup_v = Field (l_v, 0);
3520 fd1 = Int_val (Field (tup_v, 0));
3521 fd2 = Int_val (Field (tup_v, 1));
3522 if (fd2 < 0) {
3523 if ((ret = posix_spawn_file_actions_addclose (&fa, fd1)) != 0) {
3524 msg = "posix_spawn_file_actions_addclose";
3525 earg_v = tup_v;
3526 goto fail;
3527 }
3528 }
3529 else {
3530 if ((ret = posix_spawn_file_actions_adddup2 (&fa, fd1, fd2)) != 0) {
3531 msg = "posix_spawn_file_actions_adddup2";
3532 earg_v = tup_v;
3533 goto fail;
3534 }
3535 }
3536 }
3537
3538 if ((ret = posix_spawn (NULL, "/bin/sh", &fa, &attr, argv, environ))) {
3539 msg = "posix_spawn";
3540 goto fail;
3541 }
3542
3543 fail:
3544 if ((ret = posix_spawnattr_destroy (&attr)) != 0) {
3545 fprintf (stderr, "posix_spawnattr_destroy: %s\n", strerror (ret));
3546 }
3547
3548 fail1:
3549 if ((ret = posix_spawn_file_actions_destroy (&fa)) != 0) {
3550 fprintf (stderr, "posix_spawn_file_actions_destroy: %s\n",
3551 strerror (ret));
3552 }
3553
3554 if (msg)
3555 unix_error (ret, msg, earg_v);
3556
3557 CAMLreturn (Val_unit);
3558 }
3559 #endif
3560
3561 CAMLprim value ml_hassel (value ptr_v)
3562 {
3563 CAMLparam1 (ptr_v);
3564 CAMLlocal1 (ret_v);
3565 struct page *page;
3566 char *s = String_val (ptr_v);
3567
3568 ret_v = Val_bool (0);
3569 if (trylock ("ml_hassel")) {
3570 goto done;
3571 }
3572
3573 page = parse_pointer ("ml_hassel", s);
3574 ret_v = Val_bool (page->fmark.span && page->lmark.span);
3575 unlock ("ml_hassel");
3576 done:
3577 CAMLreturn (ret_v);
3578 }
3579
3580 CAMLprim value ml_copysel (value fd_v, value ptr_v)
3581 {
3582 CAMLparam2 (fd_v, ptr_v);
3583 FILE *f;
3584 int seen = 0;
3585 struct page *page;
3586 fz_text_line *line;
3587 fz_page_block *pageb;
3588 fz_text_block *block;
3589 int fd = Int_val (fd_v);
3590 char *s = String_val (ptr_v);
3591
3592 if (trylock ("ml_copysel")) {
3593 goto done;
3594 }
3595
3596 page = parse_pointer ("ml_copysel", s);
3597
3598 if (!page->fmark.span || !page->lmark.span) {
3599 fprintf (stderr, "nothing to copy on page %d\n", page->pageno);
3600 goto unlock;
3601 }
3602
3603 f = fdopen (fd, "w");
3604 if (!f) {
3605 fprintf (stderr, "failed to fdopen sel pipe (from fd %d): %s\n",
3606 fd, strerror (errno));
3607 f = stdout;
3608 }
3609
3610 for (pageb = page->text->blocks;
3611 pageb < page->text->blocks + page->text->len;
3612 ++pageb) {
3613 if (pageb->type != FZ_PAGE_BLOCK_TEXT) continue;
3614 block = pageb->u.text;
3615 for (line = block->lines;
3616 line < block->lines + block->len;
3617 ++line) {
3618 fz_text_span *span;
3619
3620 for (span = line->first_span; span; span = span->next) {
3621 int a, b;
3622
3623 seen |= span == page->fmark.span || span == page->lmark.span;
3624 a = span == page->fmark.span ? page->fmark.i : 0;
3625 b = span == page->lmark.span ? page->lmark.i : span->len - 1;
3626
3627 if (seen) {
3628 if (pipespan (f, span, a, b)) {
3629 goto close;
3630 }
3631 if (span == page->lmark.span) {
3632 goto close;
3633 }
3634 if (span == line->last_span) {
3635 if (putc ('\n', f) == EOF) {
3636 fprintf (stderr,
3637 "failed break line on sel pipe: %s\n",
3638 strerror (errno));
3639 goto close;
3640 }
3641 }
3642 }
3643 }
3644 }
3645 }
3646 close:
3647 if (f != stdout) {
3648 int ret = fclose (f);
3649 fd = -1;
3650 if (ret == -1) {
3651 if (errno != ECHILD) {
3652 fprintf (stderr, "failed to close sel pipe: %s\n",
3653 strerror (errno));
3654 }
3655 }
3656 }
3657 unlock:
3658 unlock ("ml_copysel");
3659
3660 done:
3661 if (fd >= 0) {
3662 if (close (fd)) {
3663 fprintf (stderr, "failed to close sel pipe: %s\n",
3664 strerror (errno));
3665 }
3666 }
3667 CAMLreturn (Val_unit);
3668 }
3669
3670 CAMLprim value ml_getpdimrect (value pagedimno_v)
3671 {
3672 CAMLparam1 (pagedimno_v);
3673 CAMLlocal1 (ret_v);
3674 int pagedimno = Int_val (pagedimno_v);
3675 fz_rect box;
3676
3677 ret_v = caml_alloc_small (4 * Double_wosize, Double_array_tag);
3678 if (trylock ("ml_getpdimrect")) {
3679 box = fz_empty_rect;
3680 }
3681 else {
3682 box = state.pagedims[pagedimno].mediabox;
3683 unlock ("ml_getpdimrect");
3684 }
3685
3686 Store_double_field (ret_v, 0, box.x0);
3687 Store_double_field (ret_v, 1, box.x1);
3688 Store_double_field (ret_v, 2, box.y0);
3689 Store_double_field (ret_v, 3, box.y1);
3690
3691 CAMLreturn (ret_v);
3692 }
3693
3694 CAMLprim value ml_zoom_for_height (value winw_v, value winh_v,
3695 value dw_v, value cols_v)
3696 {
3697 CAMLparam3 (winw_v, winh_v, dw_v);
3698 CAMLlocal1 (ret_v);
3699 int i;
3700 double zoom = -1.;
3701 double maxh = 0.0;
3702 struct pagedim *p;
3703 double winw = Int_val (winw_v);
3704 double winh = Int_val (winh_v);
3705 double dw = Int_val (dw_v);
3706 double cols = Int_val (cols_v);
3707 double pw = 1.0, ph = 1.0;
3708
3709 if (trylock ("ml_zoom_for_height")) {
3710 goto done;
3711 }
3712
3713 for (i = 0, p = state.pagedims; i < state.pagedimcount; ++i, ++p) {
3714 double w = p->pagebox.x1 / cols;
3715 double h = p->pagebox.y1;
3716 if (h > maxh) {
3717 maxh = h;
3718 ph = h;
3719 if (state.fitmodel != FitProportional) pw = w;
3720 }
3721 if ((state.fitmodel == FitProportional) && w > pw) pw = w;
3722 }
3723
3724 zoom = (((winh / ph) * pw) + dw) / winw;
3725 unlock ("ml_zoom_for_height");
3726 done:
3727 ret_v = caml_copy_double (zoom);
3728 CAMLreturn (ret_v);
3729 }
3730
3731 CAMLprim value ml_draw_string (value pt_v, value x_v, value y_v, value string_v)
3732 {
3733 CAMLparam4 (pt_v, x_v, y_v, string_v);
3734 CAMLlocal1 (ret_v);
3735 int pt = Int_val(pt_v);
3736 int x = Int_val (x_v);
3737 int y = Int_val (y_v);
3738 double w;
3739
3740 w = draw_string (state.face, pt, x, y, String_val (string_v));
3741 ret_v = caml_copy_double (w);
3742 CAMLreturn (ret_v);
3743 }
3744
3745 CAMLprim value ml_measure_string (value pt_v, value string_v)
3746 {
3747 CAMLparam2 (pt_v, string_v);
3748 CAMLlocal1 (ret_v);
3749 int pt = Int_val (pt_v);
3750 double w;
3751
3752 w = measure_string (state.face, pt, String_val (string_v));
3753 ret_v = caml_copy_double (w);
3754 CAMLreturn (ret_v);
3755 }
3756
3757 CAMLprim value ml_getpagebox (value opaque_v)
3758 {
3759 CAMLparam1 (opaque_v);
3760 CAMLlocal1 (ret_v);
3761 fz_rect rect;
3762 fz_irect bbox;
3763 fz_matrix ctm;
3764 fz_device *dev;
3765 char *s = String_val (opaque_v);
3766 struct page *page = parse_pointer ("ml_getpagebox", s);
3767
3768 ret_v = caml_alloc_tuple (4);
3769 dev = fz_new_bbox_device (state.ctx, &rect);
3770 dev->hints |= FZ_IGNORE_SHADE;
3771
3772 switch (page->type) {
3773 case DPDF:
3774 ctm = pagectm (page);
3775 pdf_run_page (state.u.pdf, page->u.pdfpage, dev, &ctm, NULL);
3776 break;
3777
3778 case DXPS:
3779 ctm = pagectm (page);
3780 xps_run_page (state.u.xps, page->u.xpspage, dev, &ctm, NULL);
3781 break;
3782
3783 default:
3784 rect = fz_infinite_rect;
3785 break;
3786 }
3787
3788 fz_free_device (dev);
3789 fz_round_rect (&bbox, &rect);
3790 Field (ret_v, 0) = Val_int (bbox.x0);
3791 Field (ret_v, 1) = Val_int (bbox.y0);
3792 Field (ret_v, 2) = Val_int (bbox.x1);
3793 Field (ret_v, 3) = Val_int (bbox.y1);
3794
3795 CAMLreturn (ret_v);
3796 }
3797
3798 CAMLprim value ml_setaalevel (value level_v)
3799 {
3800 CAMLparam1 (level_v);
3801
3802 state.aalevel = Int_val (level_v);
3803 CAMLreturn (Val_unit);
3804 }
3805
3806 #undef pixel
3807 #include <X11/Xlib.h>
3808 #include <GL/glx.h>
3809
3810 static struct {
3811 Display *dpy;
3812 GLXContext ctx;
3813 GLXDrawable drawable;
3814 } glx;
3815
3816 #include "keysym2ucs.c"
3817
3818 CAMLprim value ml_keysymtoutf8 (value keysym_v)
3819 {
3820 CAMLparam1 (keysym_v);
3821 CAMLlocal1 (str_v);
3822 KeySym keysym = Int_val (keysym_v);
3823 Rune rune;
3824 int len;
3825 char buf[5];
3826
3827 rune = keysym2ucs (keysym);
3828 len = fz_runetochar (buf, rune);
3829 buf[len] = 0;
3830 str_v = caml_copy_string (buf);
3831 CAMLreturn (str_v);
3832 }
3833
3834 CAMLprim value ml_glx (value win_v)
3835 {
3836 CAMLparam1 (win_v);
3837 XVisualInfo *visual;
3838 int screen, wid = Int_val (win_v);
3839 int attributes[] = { GLX_RGBA, GLX_DOUBLEBUFFER, None };
3840
3841 glx.dpy = XOpenDisplay (NULL);
3842 if (!glx.dpy) {
3843 caml_failwith ("XOpenDisplay");
3844 }
3845
3846 screen = DefaultScreen (glx.dpy);
3847 visual = glXChooseVisual (glx.dpy, screen, attributes);
3848 if (!visual) {
3849 XCloseDisplay (glx.dpy);
3850 glx.dpy = NULL;
3851 caml_failwith ("glXChooseVisual");
3852 }
3853
3854 glx.ctx = glXCreateContext (glx.dpy, visual, NULL, True);
3855 XFree (visual);
3856 if (!glx.ctx) {
3857 XCloseDisplay (glx.dpy);
3858 glx.dpy = NULL;
3859 caml_failwith ("glXCreateContext");
3860 }
3861
3862 if (!glXMakeCurrent (glx.dpy, wid, glx.ctx)) {
3863 glXDestroyContext (glx.dpy, glx.ctx);
3864 XCloseDisplay (glx.dpy);
3865 glx.dpy = NULL;
3866 glx.ctx = NULL;
3867 caml_failwith ("glXMakeCurrent");
3868 }
3869 glx.drawable = wid;
3870 CAMLreturn (Val_unit);
3871 }
3872
3873 CAMLprim value ml_swapb (value unit_v)
3874 {
3875 CAMLparam1 (unit_v);
3876 glXSwapBuffers (glx.dpy, glx.drawable);
3877 CAMLreturn (Val_unit);
3878 }
3879
3880 CAMLprim value ml_glxsync (value unit_v)
3881 {
3882 CAMLparam1 (unit_v);
3883 if (glx.dpy && glx.ctx) {
3884 glXWaitX ();
3885 glXWaitGL ();
3886 }
3887 CAMLreturn (Val_unit);
3888 }
3889
3890 enum { piunknown, pilinux, piosx, pisun, pifreebsd,
3891 pidragonflybsd, piopenbsd, pinetbsd, picygwin };
3892
3893 CAMLprim value ml_platform (value unit_v)
3894 {
3895 CAMLparam1 (unit_v);
3896 int platid = piunknown;
3897
3898 #if defined __linux__
3899 platid = pilinux;
3900 #elif defined __CYGWIN__
3901 platid = picygwin;
3902 #elif defined __DragonFly__
3903 platid = pidragonflybsd;
3904 #elif defined __FreeBSD__
3905 platid = pifreebsd;
3906 #elif defined __OpenBSD__
3907 platid = piopenbsd;
3908 #elif defined __NetBSD__
3909 platid = pinetbsd;
3910 #elif defined __sun__
3911 platid = pisun;
3912 #elif defined __APPLE__
3913 platid = piosx;
3914 #endif
3915 CAMLreturn (Val_int (platid));
3916 }
3917
3918 CAMLprim value ml_cloexec (value fd_v)
3919 {
3920 CAMLparam1 (fd_v);
3921 int fd = Int_val (fd_v);
3922
3923 if (fcntl (fd, F_SETFD, FD_CLOEXEC, 1)) {
3924 uerror ("fcntl", Nothing);
3925 }
3926 CAMLreturn (Val_unit);
3927 }
3928
3929 CAMLprim value ml_getpbo (value w_v, value h_v, value cs_v)
3930 {
3931 CAMLparam2 (w_v, h_v);
3932 CAMLlocal1 (ret_v);
3933 struct pbo *pbo;
3934 int w = Int_val (w_v);
3935 int h = Int_val (h_v);
3936 int cs = Int_val (cs_v);
3937
3938 if (state.pbo_usable) {
3939 pbo = calloc (sizeof (*pbo), 1);
3940 if (!pbo) {
3941 err (1, "calloc pbo");
3942 }
3943
3944 switch (cs) {
3945 case 0:
3946 case 1:
3947 pbo->size = w*h*4;
3948 break;
3949 case 2:
3950 pbo->size = w*h*2;
3951 break;
3952 default:
3953 errx (1, "ml_getpbo: invalid colorspace %d", cs);
3954 }
3955
3956 state.glGenBuffersARB (1, &pbo->id);
3957 state.glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB, pbo->id);
3958 state.glBufferDataARB (GL_PIXEL_UNPACK_BUFFER_ARB, pbo->size,
3959 NULL, GL_STREAM_DRAW);
3960 pbo->ptr = state.glMapBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB,
3961 GL_READ_WRITE);
3962 state.glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB, 0);
3963 if (!pbo->ptr) {
3964 fprintf (stderr, "glMapBufferARB failed: %#x\n", glGetError ());
3965 state.glDeleteBuffersARB (1, &pbo->id);
3966 free (pbo);
3967 ret_v = caml_copy_string ("0");
3968 }
3969 else {
3970 int res;
3971 char *s;
3972
3973 res = snprintf (NULL, 0, "%" FMT_ptr, pbo);
3974 if (res < 0) {
3975 err (1, "snprintf %" FMT_ptr " failed", pbo);
3976 }
3977 s = malloc (res+1);
3978 if (!s) {
3979 err (1, "malloc %d bytes failed", res+1);
3980 }
3981 res = sprintf (s, "%" FMT_ptr, pbo);
3982 if (res < 0) {
3983 err (1, "sprintf %" FMT_ptr " failed", pbo);
3984 }
3985 ret_v = caml_copy_string (s);
3986 free (s);
3987 }
3988 }
3989 else {
3990 ret_v = caml_copy_string ("0");
3991 }
3992 CAMLreturn (ret_v);
3993 }
3994
3995 CAMLprim value ml_freepbo (value s_v)
3996 {
3997 CAMLparam1 (s_v);
3998 char *s = String_val (s_v);
3999 struct tile *tile = parse_pointer ("ml_freepbo", s);
4000
4001 if (tile->pbo) {
4002 state.glDeleteBuffersARB (1, &tile->pbo->id);
4003 tile->pbo->id = -1;
4004 tile->pbo->ptr = NULL;
4005 tile->pbo->size = -1;
4006 }
4007 CAMLreturn (Val_unit);
4008 }
4009
4010 CAMLprim value ml_unmappbo (value s_v)
4011 {
4012 CAMLparam1 (s_v);
4013 char *s = String_val (s_v);
4014 struct tile *tile = parse_pointer ("ml_unmappbo", s);
4015
4016 if (tile->pbo) {
4017 state.glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB, tile->pbo->id);
4018 if (state.glUnmapBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB) == GL_FALSE) {
4019 errx (1, "glUnmapBufferARB failed: %#x\n", glGetError ());
4020 }
4021 tile->pbo->ptr = NULL;
4022 state.glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_ARB, 0);
4023 }
4024 CAMLreturn (Val_unit);
4025 }
4026
4027 static void setuppbo (void)
4028 {
4029 #define GGPA(n) (*(void (**) ()) &state.n = glXGetProcAddress ((GLubyte *) #n))
4030 state.pbo_usable = GGPA (glBindBufferARB)
4031 && GGPA (glUnmapBufferARB)
4032 && GGPA (glMapBufferARB)
4033 && GGPA (glBufferDataARB)
4034 && GGPA (glGenBuffersARB)
4035 && GGPA (glDeleteBuffersARB);
4036 #undef GGPA
4037 }
4038
4039 CAMLprim value ml_pbo_usable (value unit_v)
4040 {
4041 CAMLparam1 (unit_v);
4042 CAMLreturn (Val_bool (state.pbo_usable));
4043 }
4044
4045 CAMLprim value ml_unproject (value ptr_v, value x_v, value y_v)
4046 {
4047 CAMLparam3 (ptr_v, x_v, y_v);
4048 CAMLlocal2 (ret_v, tup_v);
4049 struct page *page;
4050 char *s = String_val (ptr_v);
4051 int x = Int_val (x_v), y = Int_val (y_v);
4052 struct pagedim *pdim;
4053 fz_point p;
4054 fz_matrix ctm;
4055
4056 page = parse_pointer ("ml_unproject", s);
4057 pdim = &state.pagedims[page->pdimno];
4058
4059 ret_v = Val_int (0);
4060 if (trylock ("ml_unproject")) {
4061 goto done;
4062 }
4063
4064 switch (page->type) {
4065 case DPDF:
4066 trimctm (page->u.pdfpage, page->pdimno);
4067 break;
4068
4069 default:
4070 break;
4071 }
4072 p.x = x + pdim->bounds.x0;
4073 p.y = y + pdim->bounds.y0;
4074
4075 fz_concat (&ctm, &pdim->tctm, &pdim->ctm);
4076 fz_invert_matrix (&ctm, &ctm);
4077 fz_transform_point (&p, &ctm);
4078
4079 tup_v = caml_alloc_tuple (2);
4080 ret_v = caml_alloc_small (1, 1);
4081 Field (tup_v, 0) = Val_int (p.x);
4082 Field (tup_v, 1) = Val_int (p.y);
4083 Field (ret_v, 0) = tup_v;
4084
4085 unlock ("ml_unproject");
4086 done:
4087 CAMLreturn (ret_v);
4088 }
4089
4090 static void makestippletex (void)
4091 {
4092 const char pixels[] = "\xff\xff\0\0";
4093 glGenTextures (1, &state.stid);
4094 glBindTexture (GL_TEXTURE_1D, state.stid);
4095 glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
4096 glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
4097 glTexImage1D (
4098 GL_TEXTURE_1D,
4099 0,
4100 GL_ALPHA,
4101 4,
4102 0,
4103 GL_ALPHA,
4104 GL_UNSIGNED_BYTE,
4105 pixels
4106 );
4107 }
4108
4109 CAMLprim value ml_fz_version (value unit_v)
4110 {
4111 return caml_copy_string (FZ_VERSION);
4112 }
4113
4114 #ifdef USE_FONTCONFIG
4115 static struct {
4116 int inited;
4117 FcConfig *config;
4118 } fc;
4119
4120 static fz_font *fc_load_system_font_func (fz_context *ctx,
4121 const char *name,
4122 int bold,
4123 int italic,
4124 int needs_exact_metrics)
4125 {
4126 char *buf;
4127 size_t i, size;
4128 fz_font *font;
4129 FcChar8 *path;
4130 FcResult result;
4131 FcPattern *pat, *pat1;
4132
4133 lprintf ("looking up %s bold:%d italic:%d needs_exact_metrics:%d\n",
4134 name, bold, italic, needs_exact_metrics);
4135 if (!fc.inited) {
4136 fc.inited = 1;
4137 fc.config = FcInitLoadConfigAndFonts ();
4138 if (!fc.config) {
4139 lprintf ("FcInitLoadConfigAndFonts failed\n");
4140 return NULL;
4141 }
4142 }
4143 if (!fc.config) return NULL;
4144
4145 size = strlen (name);
4146 if (bold) size += sizeof (":bold") - 1;
4147 if (italic) size += sizeof (":italic") - 1;
4148 size += 1;
4149
4150 buf = malloc (size);
4151 if (!buf) {
4152 err (1, "malloc %zu failed", size);
4153 }
4154
4155 strcpy (buf, name);
4156 if (bold && italic) {
4157 strcat (buf, ":bold:italic");
4158 }
4159 else {
4160 if (bold) strcat (buf, ":bold");
4161 if (italic) strcat (buf, ":italic");
4162 }
4163 for (i = 0; i < size; ++i) {
4164 if (buf[i] == ',' || buf[i] == '-') buf[i] = ':';
4165 }
4166
4167 lprintf ("fcbuf=%s\n", buf);
4168 pat = FcNameParse ((FcChar8 *) buf);
4169 if (!pat) {
4170 printd ("emsg FcNameParse failed\n");
4171 free (buf);
4172 return NULL;
4173 }
4174
4175 if (!FcConfigSubstitute (fc.config, pat, FcMatchPattern)) {
4176 printd ("emsg FcConfigSubstitute failed\n");
4177 free (buf);
4178 return NULL;
4179 }
4180 FcDefaultSubstitute (pat);
4181
4182 pat1 = FcFontMatch (fc.config, pat, &result);
4183 if (!pat1) {
4184 printd ("emsg FcFontMatch failed\n");
4185 FcPatternDestroy (pat);
4186 free (buf);
4187 return NULL;
4188 }
4189
4190 if (FcPatternGetString (pat1, FC_FILE, 0, &path) != FcResultMatch) {
4191 printd ("emsg FcPatternGetString failed\n");
4192 FcPatternDestroy (pat);
4193 FcPatternDestroy (pat1);
4194 free (buf);
4195 return NULL;
4196 }
4197
4198 #if 0
4199 printd ("emsg name=%s path=%s\n", name, path);
4200 #endif
4201 font = fz_new_font_from_file (ctx, name, (char *) path, 0, 0);
4202 FcPatternDestroy (pat);
4203 FcPatternDestroy (pat1);
4204 free (buf);
4205 return font;
4206 }
4207 #endif
4208
4209 CAMLprim value ml_init (value pipe_v, value params_v)
4210 {
4211 CAMLparam2 (pipe_v, params_v);
4212 CAMLlocal2 (trim_v, fuzz_v);
4213 int ret;
4214 int texcount;
4215 char *fontpath;
4216 int colorspace;
4217 int mustoresize;
4218 int haspboext;
4219 struct sigaction sa;
4220
4221 state.cr = Int_val (Field (pipe_v, 0));
4222 state.cw = Int_val (Field (pipe_v, 1));
4223 state.rotate = Int_val (Field (params_v, 0));
4224 state.fitmodel = Int_val (Field (params_v, 1));
4225 trim_v = Field (params_v, 2);
4226 texcount = Int_val (Field (params_v, 3));
4227 state.sliceheight = Int_val (Field (params_v, 4));
4228 mustoresize = Int_val (Field (params_v, 5));
4229 colorspace = Int_val (Field (params_v, 6));
4230 fontpath = String_val (Field (params_v, 7));
4231
4232 state.trimcachepath = strdup (String_val (Field (params_v, 8)));
4233 if (!state.trimcachepath) {
4234 fprintf (stderr, "failed to strdup trimcachepath: %s\n",
4235 strerror (errno));
4236 }
4237 haspboext = Bool_val (Field (params_v, 9));
4238
4239 state.ctx = fz_new_context (NULL, NULL, mustoresize);
4240
4241 #ifdef USE_FONTCONFIG
4242 fz_install_load_system_font_funcs (state.ctx, fc_load_system_font_func, NULL);
4243 #endif
4244
4245 state.trimmargins = Bool_val (Field (trim_v, 0));
4246 fuzz_v = Field (trim_v, 1);
4247 state.trimfuzz.x0 = Int_val (Field (fuzz_v, 0));
4248 state.trimfuzz.y0 = Int_val (Field (fuzz_v, 1));
4249 state.trimfuzz.x1 = Int_val (Field (fuzz_v, 2));
4250 state.trimfuzz.y1 = Int_val (Field (fuzz_v, 3));
4251
4252 set_tex_params (colorspace);
4253
4254 if (*fontpath) {
4255 #ifndef USE_FONTCONFIG
4256 state.face = load_font (fontpath);
4257 #else
4258 FcChar8 *path;
4259 FcResult result;
4260 char *buf = fontpath;
4261 FcPattern *pat, *pat1;
4262
4263 fc.inited = 1;
4264 fc.config = FcInitLoadConfigAndFonts ();
4265 if (!fc.config) {
4266 errx (1, "FcInitLoadConfigAndFonts failed");
4267 }
4268
4269 pat = FcNameParse ((FcChar8 *) buf);
4270 if (!pat) {
4271 errx (1, "FcNameParse failed");
4272 }
4273
4274 if (!FcConfigSubstitute (fc.config, pat, FcMatchPattern)) {
4275 errx (1, "FcConfigSubstitute failed");
4276 }
4277 FcDefaultSubstitute (pat);
4278
4279 pat1 = FcFontMatch (fc.config, pat, &result);
4280 if (!pat1) {
4281 errx (1, "FcFontMatch failed");
4282 }
4283
4284 if (FcPatternGetString (pat1, FC_FILE, 0, &path) != FcResultMatch) {
4285 errx (1, "FcPatternGetString failed");
4286 }
4287
4288 state.face = load_font ((char *) path);
4289 FcPatternDestroy (pat);
4290 FcPatternDestroy (pat1);
4291 #endif
4292 }
4293 else {
4294 unsigned int len;
4295 void *base = pdf_lookup_substitute_font (0, 0, 0, 0, &len);
4296
4297 state.face = load_builtin_font (base, len);
4298 }
4299 if (!state.face) _exit (1);
4300
4301 realloctexts (texcount);
4302
4303 if (haspboext) {
4304 setuppbo ();
4305 }
4306
4307 makestippletex ();
4308
4309 #ifdef __CYGWIN__
4310 sa.sa_handler = SIG_IGN;
4311 sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
4312 #else
4313 sa.sa_handler = SIG_DFL;
4314 sa.sa_flags = SA_RESTART | SA_NOCLDSTOP | SA_NOCLDWAIT;
4315 #endif
4316 if (sigemptyset (&sa.sa_mask)) {
4317 err (1, "sigemptyset");
4318 }
4319 if (sigaction (SIGCHLD, &sa, NULL)) {
4320 err (1, "sigaction");
4321 }
4322
4323 ret = pthread_create (&state.thread, NULL, mainloop, NULL);
4324 if (ret) {
4325 errx (1, "pthread_create: %s", strerror (ret));
4326 }
4327
4328 CAMLreturn (Val_unit);
4329 }
PDF pager