wok-next view gambas2/stuff/CPdfDocument.cpp @ rev 20160

cdrkit: receipt v2
author Pascal Bellard <pascal.bellard@slitaz.org>
date Wed Nov 01 17:19:39 2017 +0100 (2017-11-01)
parents
children
line source
1 /***************************************************************************
2
3 CPdfDocument.cpp
4
5 gb.pdf Component
6
7 (C) 2005-2007 Daniel Campos Fernández <dcamposf@gmail.com>
8
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 1, or (at your option)
13 any later version.
14
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 1, or (at your option)
18 any later version.
19
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
24
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28
29 ***************************************************************************/
30
31 #define __CPDFDOCUMENT_C
32
33 #include "CPdfDocument.h"
34
35 #include "gambas.h"
36 #include "main.h"
37
38 #include <stdio.h>
39 #include <stdint.h>
40 #include <math.h>
41
42 #include <PDFDoc.h>
43 #include <Stream.h>
44 #include <ErrorCodes.h>
45 #include <Page.h>
46 #include <Catalog.h>
47 #include <TextOutputDev.h>
48 #include <SplashOutputDev.h>
49 #include <splash/SplashBitmap.h>
50 #include <goo/GooList.h>
51 #include <Outline.h>
52 #include <Link.h>
53 #include <Gfx.h>
54
55 /*****************************************************************************
56
57 Translations from Poppler universe to Gambas universe
58
59 ******************************************************************************/
60 typedef struct
61 {
62 int32_t x0;
63 int32_t y0;
64 int32_t x1;
65 int32_t y1;
66 } FoundRect;
67
68 static void aux_return_string_info(void *_object, const char *key)
69 {
70 Object obj;
71 Object dst;
72 GooString *goo_value;
73 Dict *info_dict;
74 char *tmpstr;
75
76 THIS->doc->getDocInfo (&obj);
77 if (!obj.isDict()) { GB.ReturnNewZeroString(""); return; }
78
79 info_dict=obj.getDict();
80 info_dict->lookup ((char *)key, &dst);
81 if (!dst.isString ()) { GB.ReturnNewZeroString(""); }
82 else {
83 goo_value = dst.getString();
84
85 if (goo_value->hasUnicodeMarker())
86 {
87 GB.ConvString (&tmpstr,goo_value->getCString()+2,goo_value->getLength()-2,"UTF-16BE","UTF-8");
88 GB.ReturnNewZeroString(tmpstr);
89 }
90 else
91 GB.ReturnNewString(goo_value->getCString(),goo_value->getLength());
92 }
93 dst.free();
94 obj.free();
95 }
96
97 static void aux_return_date_info(void *_object, const char *key)
98 {
99 // TODO: Y2K effect
100 GB_DATE_SERIAL ds;
101 GB_DATE ret;
102 Object obj;
103 Object dst;
104 GooString *goo;
105 Dict *info_dict;
106 char *datestr=NULL,*tofree=NULL;
107 int nnum;
108
109 THIS->doc->getDocInfo (&obj);
110 if (!obj.isDict()) { GB.ReturnNull(); return; }
111
112 info_dict=obj.getDict();
113 info_dict->lookup ((char *)key, &dst);
114 if (!dst.isString ()) { GB.ReturnNull(); }
115 else {
116 goo = dst.getString();
117 if (goo->hasUnicodeMarker())
118 GB.ConvString (&datestr,goo->getCString()+2,goo->getLength()-2,"UTF-16BE","UTF-8");
119 else
120 {
121 GB.NewString(&datestr,goo->getCString(),goo->getLength());
122 tofree=datestr;
123 }
124
125 if (!datestr) { GB.ReturnNull(); }
126 else
127 {
128 if (datestr[0] == 'D' && datestr[1] == ':') datestr += 2;
129 nnum=sscanf(datestr, "%4hd%2hd%2hd%2hd%2hd%2hd",&ds.year, &ds.month, \
130 &ds.day, &ds.hour, &ds.min, &ds.sec);
131 if (nnum != 6) { GB.ReturnNull(); }
132 else
133 {
134 if (GB.MakeDate(&ds,&ret))
135 GB.ReturnNull();
136 else
137 GB.ReturnDate(&ret);
138 }
139 }
140
141 }
142
143 if (tofree) GB.FreeString(&tofree);
144 dst.free();
145 obj.free();
146 }
147
148 static void aux_return_unicode_string(Unicode *uni, int32_t len)
149 {
150 int32_t bc;
151 char *ret=NULL;
152
153 for (bc=0; bc<len; bc++)
154 GB.AddString(&ret,(const char*)&uni[bc],0);
155
156 GB.ReturnNewString(ret,0);
157 GB.FreeString(&ret);
158 }
159
160 static LinkDest *get_dest(LinkAction *act)
161 {
162 switch (act->getKind())
163 {
164 case actionGoTo: return ((LinkGoTo*)act)->getDest();
165 case actionGoToR: return ((LinkGoToR*)act)->getDest();
166 default: return 0;
167 }
168 }
169
170 static uint32_t aux_get_page_from_action(void *_object, LinkAction *act)
171 {
172 Ref pref;
173 LinkDest *dest = get_dest(act);
174 #if POPPLER_VERSION_0_6
175 GooString *name;
176 #else
177 UGooString *name;
178 #endif
179
180 if (!dest)
181 {
182 // try to use NamedDest to get dest
183 if (!act)
184 return 0;
185 if (act->getKind () == actionGoTo)
186 {
187 name = ((LinkGoTo*)act)->getNamedDest();
188 if (name)
189 dest = THIS->doc->findDest(name);
190 }
191 }
192
193 if (!dest)
194 return 0;
195
196 if (dest->isPageRef() )
197 {
198 pref= dest->getPageRef();
199 return THIS->doc->findPage(pref.num, pref.gen);
200 }
201 else
202 return dest->getPageNum();
203 }
204
205 static void aux_get_dimensions_from_action(LinkAction *act,int *left, int32_t *right, int32_t *top, int32_t *bottom)
206 {
207 LinkDest *dest = get_dest(act);
208 if (!dest)
209 {
210 if (left) *left=0;
211 if (right) *right=0;
212 if (top) *top=0;
213 if (bottom) *bottom=0;
214 return;
215 }
216
217 if (left) *left=(int32_t)dest->getLeft();
218 if (right) *right=(int32_t)dest->getRight();
219 if (top) *top=(int32_t)dest->getTop();
220 if (bottom) *bottom=(int32_t)dest->getBottom();
221 }
222
223 static double aux_get_zoom_from_action(LinkAction *act)
224 {
225 LinkDest *dest = get_dest(act);
226 if (dest)
227 return dest->getZoom();
228 else
229 return 1;
230 }
231
232 static char* aux_get_target_from_action(LinkAction *act)
233 {
234 char *vl=NULL;
235 char *uni=NULL;
236 GooString *tmp=NULL;
237
238 switch (act->getKind())
239 {
240 case actionGoToR:
241 tmp=((LinkGoToR*)act)->getFileName(); break;
242
243 case actionLaunch:
244 tmp=((LinkLaunch*)act)->getFileName(); break;
245
246 case actionURI:
247 tmp=((LinkURI*)act)->getURI(); break;
248
249 case actionNamed:
250 tmp=((LinkNamed*)act)->getName(); break;
251
252 case actionMovie:
253 #if POPPLER_VERSION_0_8
254 tmp=((LinkMovie*)act)->getAnnotTitle(); break;
255 #else
256 tmp=((LinkMovie*)act)->getTitle(); break;
257 #endif
258
259 default:
260 break;
261 }
262
263 if (!tmp) return NULL;
264
265 if (tmp->hasUnicodeMarker())
266 {
267 GB.ConvString (&uni,tmp->getCString()+2,tmp->getLength()-2,"UTF-16BE","UTF-8");
268 GB.AddString (&vl,uni,0);
269 }
270 else
271 GB.AddString(&vl,tmp->getCString(),tmp->getLength());
272
273
274 return vl;
275
276 }
277
278 /*****************************************************************************
279
280 PDF document
281
282 ******************************************************************************/
283
284
285 static void free_all(void *_object)
286 {
287 if (THIS->doc)
288 {
289 delete THIS->doc;
290 THIS->doc=NULL;
291 }
292
293 if (THIS->dev)
294 {
295 delete THIS->dev;
296 THIS->dev=NULL;
297 }
298
299 if (THIS->buf)
300 {
301 GB.ReleaseFile(&THIS->buf,THIS->len);
302 THIS->buf=NULL;
303 }
304
305 if (THIS->Found)
306 {
307 GB.FreeArray(POINTER(&THIS->Found));
308 THIS->Found=NULL;
309 }
310
311 if (THIS->links)
312 {
313 delete THIS->links;
314 THIS->links=NULL;
315 }
316
317 if (THIS->pindex)
318 {
319 GB.FreeArray(POINTER(&THIS->pindex));
320 GB.FreeArray(POINTER(&THIS->oldindex));
321 THIS->pindex=NULL;
322 THIS->oldindex=NULL;
323 }
324
325 THIS->index=NULL;
326 THIS->currpage=-1;
327 }
328
329 BEGIN_METHOD_VOID (PDFDOCUMENT_free)
330
331 free_all(_object);
332
333 END_METHOD
334
335 BEGIN_PROPERTY(PDFDOCUMENT_scale)
336
337 if (READ_PROPERTY){ GB.ReturnFloat(THIS->scale); return; }
338
339 if (VPROP(GB_FLOAT)>0) { THIS->scale = VPROP(GB_FLOAT); return; }
340
341 GB.Error("Zoom must be a positive value");
342
343 END_PROPERTY
344
345 BEGIN_PROPERTY(PDFDOCUMENT_rotation)
346
347 int32_t rot;
348
349 if (READ_PROPERTY)
350 {
351 GB.ReturnInteger(THIS->rotation);
352 return;
353 }
354
355 rot=VPROP(GB_INTEGER);
356
357 while (rot<0) rot+=360;
358 while (rot>=360) rot-=360;
359
360 switch (rot)
361 {
362 case 0:
363 case 90:
364 case 180:
365 case 270:
366 THIS->rotation = VPROP(GB_INTEGER);
367 break;
368 }
369
370 END_PROPERTY
371
372
373 int32_t open_document (void *_object, char *sfile, int32_t lfile)
374 {
375 SplashColor white;
376 PDFDoc *test;
377 MemStream *stream;
378 Object obj;
379 Outline *outline;
380 char *buf=NULL;
381 int32_t len=0;
382 int32_t ret;
383
384
385 if ( GB.LoadFile(sfile,lfile,&buf,&len) ) return -1;
386
387 obj.initNull();
388 stream=new MemStream(buf,0,(Guint)len,&obj);
389 test=new PDFDoc (stream,0,0);
390
391 if (!test->isOk())
392 {
393 GB.ReleaseFile(&buf,len);
394 ret=test->getErrorCode();
395 delete test;
396 test=NULL;
397 if (ret == errEncrypted) return -2;
398 return -3;
399 }
400
401 free_all(_object);
402
403 THIS->doc=test;
404 THIS->buf=buf;
405 THIS->len=len;
406
407 white[0] = 0xFF; white[1] = 0xFF; white[2] = 0xFF;
408 THIS->dev=new SplashOutputDev(splashModeRGB8, 3, gFalse, white);
409
410 #if POPPLER_VERSION_0_20
411 THIS->dev->startDoc(THIS->doc);
412 #else
413 THIS->dev->startDoc(THIS->doc->getXRef ());
414 #endif
415
416 outline=THIS->doc->getOutline();
417 if (outline) THIS->index=outline->getItems();
418
419 //if (THIS->index)
420 // if (!THIS->index->getLength()) THIS->index=NULL;
421
422 THIS->currindex=0;
423 THIS->currpage=-1;
424
425 return 0;
426
427 }
428
429
430 BEGIN_METHOD(PDFDOCUMENT_new, GB_STRING File)
431
432 THIS->scale = 1;
433 THIS->rotation = 0;
434
435 if (!MISSING(File))
436 {
437 switch (open_document( _object, STRING(File), LENGTH(File)) )
438 {
439 case -1: GB.Error("File not found"); return;
440 case -2: GB.Error("PDF is encrypted"); return;
441 case -3: GB.Error("Bad PDF File"); return;
442 }
443 }
444
445 END_METHOD
446
447 BEGIN_METHOD (PDFDOCUMENT_open, GB_STRING File;)
448
449 switch (open_document( _object, STRING(File), LENGTH(File)) )
450 {
451 case -1: GB.Error("File not found"); return;
452 case -2: GB.Error("PDF is encrypted"); return;
453 case -3: GB.Error("Bad PDF File"); return;
454 }
455
456 END_METHOD
457
458 BEGIN_METHOD_VOID(PDFDOCUMENT_close)
459
460 free_all(_object);
461
462 END_METHOD
463
464 BEGIN_METHOD(PDFDOCUMENT_get,GB_INTEGER index;)
465
466 if (!THIS->doc || (VARG(index)<1) || ( VARG(index)>THIS->doc->getNumPages() ) )
467 {
468 GB.Error("Invalid page number");
469 GB.ReturnNull();
470 return;
471 }
472
473 if (THIS->currpage != (uint32_t)VARG(index) )
474 {
475 if (THIS->Found)
476 {
477 GB.FreeArray(POINTER(&THIS->Found));
478 THIS->Found=NULL;
479 }
480
481 if (THIS->links)
482 {
483 delete THIS->links;
484 THIS->links=NULL;
485 }
486
487 THIS->page=THIS->doc->getCatalog()->getPage(VARG(index));
488 THIS->currpage=VARG(index);
489 }
490
491 RETURN_SELF();
492
493 END_METHOD
494
495 BEGIN_PROPERTY(PDFDOCUMENT_ready)
496
497 GB.ReturnBoolean( (bool)THIS->doc );
498
499 END_PROPERTY
500
501 BEGIN_PROPERTY(PDFDOCUMENT_count)
502
503 GB.ReturnInteger( (int32_t) (THIS->doc ? THIS->doc->getNumPages() : 0));
504
505 END_PROPERTY
506
507 BEGIN_PROPERTY(PDFDOCUMENT_info)
508
509 if (THIS->doc) RETURN_SELF();
510 else GB.ReturnNull();
511
512 END_PROPERTY
513
514 /*****************************************************************************
515
516 PDF document information
517
518 ******************************************************************************/
519
520 BEGIN_PROPERTY(PDFINFO_title)
521
522 aux_return_string_info(_object,"Title");
523
524 END_PROPERTY
525
526 BEGIN_PROPERTY(PDFINFO_format)
527
528 char ctx[16];
529 #if POPPLER_VERSION_0_11_3
530 snprintf(ctx, sizeof(ctx), "%.2g", THIS->doc->getPDFMajorVersion () + THIS->doc->getPDFMinorVersion() / 10.0);
531 #else
532 snprintf(ctx, sizeof(ctx), "%.2g", THIS->doc->getPDFVersion());
533 #endif
534 GB.ReturnNewZeroString(ctx);
535
536 END_PROPERTY
537
538 BEGIN_PROPERTY(PDFINFO_author)
539
540 aux_return_string_info(_object,"Author");
541
542 END_PROPERTY
543
544 BEGIN_PROPERTY(PDFINFO_subject)
545
546 aux_return_string_info(_object,"Subject");
547
548 END_PROPERTY
549
550 BEGIN_PROPERTY(PDFINFO_keywords)
551
552 aux_return_string_info(_object,"Keywords");
553
554 END_PROPERTY
555
556 BEGIN_PROPERTY(PDFINFO_creator)
557
558 aux_return_string_info(_object,"Creator");
559
560 END_PROPERTY
561
562 BEGIN_PROPERTY(PDFINFO_producer)
563
564 aux_return_string_info(_object,"Producer");
565
566 END_PROPERTY
567
568 BEGIN_PROPERTY(PDFINFO_linearized)
569
570 GB.ReturnBoolean(THIS->doc->isLinearized());
571
572 END_PROPERTY
573
574 BEGIN_PROPERTY(PDFINFO_layout)
575
576 Catalog *catalog;
577
578 catalog=THIS->doc->getCatalog();
579 if (!catalog) { GB.ReturnInteger(Catalog::pageLayoutNone); return; }
580 if (!catalog->isOk()) { GB.ReturnInteger(Catalog::pageLayoutNone); return; }
581
582 GB.ReturnInteger(catalog->getPageLayout());
583
584 END_PROPERTY
585
586 BEGIN_PROPERTY(PDFINFO_mode)
587
588 Catalog *catalog;
589
590 catalog=THIS->doc->getCatalog();
591 if (!catalog) { GB.ReturnInteger(Catalog::pageModeNone); return; }
592 if (!catalog->isOk()) { GB.ReturnInteger(Catalog::pageModeNone); return; }
593
594 GB.ReturnInteger(catalog->getPageMode());
595
596
597 END_PROPERTY
598
599 BEGIN_PROPERTY(PDFINFO_canprint)
600
601 GB.ReturnBoolean(THIS->doc->okToPrint());
602
603 END_PROPERTY
604
605 BEGIN_PROPERTY(PDFINFO_canmodify)
606
607 GB.ReturnBoolean(THIS->doc->okToChange());
608
609 END_PROPERTY
610
611 BEGIN_PROPERTY(PDFINFO_cancopy)
612
613 GB.ReturnBoolean(THIS->doc->okToCopy());
614
615 END_PROPERTY
616
617 BEGIN_PROPERTY(PDFINFO_canaddnotes)
618
619 GB.ReturnBoolean(THIS->doc->okToAddNotes());
620
621 END_PROPERTY
622
623 BEGIN_PROPERTY(PDFINFO_creation)
624
625 aux_return_date_info(_object,"CreationDate");
626
627 END_PROPERTY
628
629 BEGIN_PROPERTY(PDFINFO_modification)
630
631 aux_return_date_info(_object,"ModDate");
632
633 END_PROPERTY
634
635
636 /*****************************************************************************
637
638 PDF document index
639
640 ******************************************************************************/
641
642
643 BEGIN_PROPERTY(PDFDOCUMENT_has_index)
644
645 GB.ReturnBoolean(THIS->index && THIS->index->getLength());
646
647 END_PROPERTY
648
649 BEGIN_PROPERTY(PDFDOCUMENT_index)
650
651 if (!THIS->index) { GB.ReturnNull(); return; }
652
653 THIS->action=((OutlineItem*)THIS->index->get(THIS->currindex))->getAction();
654 RETURN_SELF();
655
656 END_PROPERTY
657
658 BEGIN_PROPERTY(PDFINDEX_count)
659
660 GB.ReturnInteger(THIS->index->getLength());
661
662 END_PROPERTY
663
664 BEGIN_PROPERTY(PDFINDEX_has_children)
665
666 OutlineItem *item;
667
668 item = (OutlineItem *)THIS->index->get (THIS->currindex);
669 GB.ReturnBoolean(item->getKids() && item->getKids()->getLength());
670
671 END_PROPERTY
672
673 BEGIN_PROPERTY(PDFINDEX_is_open)
674
675 OutlineItem *item;
676
677 item = (OutlineItem *)THIS->index->get (THIS->currindex);
678
679 if (READ_PROPERTY)
680 { GB.ReturnBoolean(item->isOpen()); return; }
681
682 if (VPROP(GB_INTEGER)) item->open();
683 else item->close();
684
685 END_PROPERTY
686
687 BEGIN_PROPERTY(PDFINDEX_title)
688
689 OutlineItem *item;
690
691 item = (OutlineItem *)THIS->index->get (THIS->currindex);
692 aux_return_unicode_string(item->getTitle(),item->getTitleLength());
693
694 END_PROPERTY
695
696
697 BEGIN_METHOD_VOID(PDFINDEX_root)
698
699 Outline *outline;
700
701 outline=THIS->doc->getOutline();
702 if (outline) THIS->index=outline->getItems();
703 THIS->currindex=0;
704 if (THIS->pindex) { GB.FreeArray(POINTER(&THIS->pindex)); THIS->pindex=NULL; }
705 if (THIS->oldindex) { GB.FreeArray(POINTER(&THIS->oldindex)); THIS->oldindex=NULL; }
706
707 END_METHOD
708
709 BEGIN_METHOD_VOID(PDFINDEX_prev)
710
711 if (!THIS->currindex) { GB.ReturnBoolean(true); return; }
712
713 THIS->currindex--;
714 GB.ReturnBoolean(false);
715
716 END_METHOD
717
718 BEGIN_METHOD_VOID(PDFINDEX_next)
719
720 if ( (THIS->currindex+1) >= (uint32_t)THIS->index->getLength() )
721 { GB.ReturnBoolean(true); return; }
722
723 THIS->currindex++;
724 GB.ReturnBoolean(false);
725
726 END_METHOD
727
728 BEGIN_METHOD_VOID(PDFINDEX_child)
729
730 OutlineItem *item;
731
732 item = (OutlineItem *)THIS->index->get (THIS->currindex);
733
734 if (!item->hasKids() || item->getKids()->getLength() == 0) { GB.ReturnBoolean(true); return; }
735
736 if (THIS->pindex)
737 {
738 GB.Add(POINTER(&THIS->pindex));
739 GB.Add(POINTER(&THIS->oldindex));
740 }
741 else
742 {
743 GB.NewArray(POINTER(&THIS->pindex),sizeof(void*),1);
744 GB.NewArray(POINTER(&THIS->oldindex),sizeof(uint32_t),1);
745 }
746
747 if (!item->isOpen()) item->open();
748 THIS->pindex[GB.Count(POINTER(THIS->pindex))-1]=(void*)THIS->index;
749 THIS->oldindex[GB.Count(POINTER(THIS->pindex))-1]=THIS->currindex;
750 THIS->index=item->getKids();
751 THIS->currindex=0;
752
753 GB.ReturnBoolean(false);
754
755 END_METHOD
756
757 BEGIN_METHOD_VOID(PDFINDEX_parent)
758
759 if (!THIS->pindex) { GB.ReturnBoolean(true); return; }
760
761 THIS->index=(GooList*)THIS->pindex[GB.Count(POINTER(THIS->pindex))-1];
762 THIS->currindex=THIS->oldindex[GB.Count(POINTER(THIS->pindex))-1];
763 if (GB.Count(POINTER(THIS->pindex))==1)
764 {
765 GB.FreeArray(POINTER(&THIS->pindex));
766 GB.FreeArray(POINTER(&THIS->oldindex));
767 THIS->oldindex=NULL;
768 THIS->pindex=NULL;
769 }
770 else
771 {
772 GB.Remove(POINTER(&THIS->pindex),GB.Count(POINTER(THIS->pindex))-1,1);
773 GB.Remove(POINTER(&THIS->oldindex),GB.Count(POINTER(THIS->oldindex))-1,1);
774 }
775
776 GB.ReturnBoolean(false);
777
778 END_METHOD
779
780 /*****************************************************************************
781
782 PDF pages
783
784 ******************************************************************************/
785
786 BEGIN_PROPERTY (PDFPAGE_width)
787
788 if ( (THIS->rotation==90) || (THIS->rotation==270) )
789 GB.ReturnInteger((int32_t)(THIS->page->getMediaHeight()*THIS->scale));
790 else
791 GB.ReturnInteger((int32_t)(THIS->page->getMediaWidth()*THIS->scale));
792
793 END_PROPERTY
794
795 BEGIN_PROPERTY (PDFPAGE_height)
796
797 if ( (THIS->rotation==90) || (THIS->rotation==270) )
798 GB.ReturnInteger((int32_t)(THIS->page->getMediaWidth()*THIS->scale));
799 else
800 GB.ReturnInteger((int32_t)(THIS->page->getMediaHeight()*THIS->scale));
801
802 END_PROPERTY
803
804 static uint32_t *get_page_data(CPDFDOCUMENT *_object, int32_t x, int32_t y, int32_t *width, int32_t *height, double scale, int32_t rotation)
805 {
806 SplashBitmap *map;
807 uint32_t *data;
808 int32_t w, h;
809 int32_t rw;
810 int32_t rh;
811
812 if ( (THIS->rotation==90) || (THIS->rotation==270) )
813 {
814 rh=(int32_t)(THIS->page->getMediaWidth()*THIS->scale);
815 rw=(int32_t)(THIS->page->getMediaHeight()*THIS->scale);
816 }
817 else
818 {
819 rw=(int32_t)(THIS->page->getMediaWidth()*THIS->scale);
820 rh=(int32_t)(THIS->page->getMediaHeight()*THIS->scale);
821 }
822
823 w = *width;
824 h = *height;
825
826 if (w < 0) w = rw;
827 if (h < 0) h = rh;
828
829 if (x<0) x=0;
830 if (y<0) y=0;
831 if (w<1) w=1;
832 if (h<1) h=1;
833
834
835 if ( (x+w) > rw ) w=rw-x;
836 if ( (y+h) > rh ) h=rh-y;
837
838 if ( (w<0) || (h<0) ) return NULL;
839
840 #if POPPLER_VERSION_0_20
841 THIS->page->displaySlice(THIS->dev,72.0*scale,72.0*scale,
842 rotation,
843 gFalse,
844 gTrue,
845 x,y,w,h,
846 gFalse);
847 #else
848 THIS->page->displaySlice(THIS->dev,72.0*scale,72.0*scale,
849 rotation,
850 gFalse,
851 gTrue,
852 x,y,w,h,
853 gFalse,
854 THIS->doc->getCatalog ());
855 #endif
856
857 map=THIS->dev->getBitmap();
858
859 data=(uint32_t*)map->getDataPtr();
860
861
862 *width = w;
863 *height = h;
864
865 return data;
866 }
867
868 BEGIN_METHOD(PDFPAGE_image, GB_INTEGER x; GB_INTEGER y; GB_INTEGER w; GB_INTEGER h)
869
870 GB_IMAGE img = NULL;
871 uint32_t *data;
872 int32_t x,y, w, h;
873
874 x = VARGOPT(x, 0);
875 y = VARGOPT(y, 0);
876 w = VARGOPT(w, -1);
877 h = VARGOPT(h, -1);
878
879 data = get_page_data(THIS, x, y, &w, &h, THIS->scale, THIS->rotation);
880 if (!data) { GB.ReturnNull(); return; }
881 GB.Image.Create(&img, data, w, h, GB_IMAGE_RGB);
882 GB.ReturnObject(img);
883
884 END_METHOD
885
886 BEGIN_PROPERTY (PDFPAGE_property_image)
887
888 int32_t w=-1;
889 int32_t h=-1;
890 GB_IMAGE img = NULL;
891 uint32_t *data;
892
893 data = get_page_data(THIS, 0, 0, &w, &h, THIS->scale, THIS->rotation);
894 if (!data) { GB.ReturnNull(); return; }
895 GB.Image.Create(&img, data, w, h, GB_IMAGE_RGB);
896 GB.ReturnObject(img);
897
898 END_PROPERTY
899
900
901 BEGIN_METHOD(PDFPAGE_picture, GB_INTEGER x; GB_INTEGER y; GB_INTEGER w; GB_INTEGER h)
902
903 GB_IMAGE img = NULL;
904 uint32_t *data;
905 int32_t x,y, w, h;
906
907 x = VARGOPT(x, 0);
908 y = VARGOPT(y, 0);
909 w = VARGOPT(w, -1);
910 h = VARGOPT(h, -1);
911
912 data = get_page_data(THIS, x, y, &w, &h, THIS->scale, THIS->rotation);
913 if (!data) { GB.ReturnNull(); return; }
914 GB.Picture.Create(&img, data, w, h, GB_IMAGE_RGB);
915 GB.ReturnObject(img);
916
917 END_METHOD
918
919 BEGIN_PROPERTY (PDFPAGE_property_picture)
920
921 int32_t w=-1;
922 int32_t h=-1;
923 GB_IMAGE img = NULL;
924 uint32_t *data;
925
926 data = get_page_data(THIS, 0, 0, &w, &h, THIS->scale, THIS->rotation);
927 if (!data) { GB.ReturnNull(); return; }
928 GB.Picture.Create(&img, data, w, h, GB_IMAGE_RGB);
929 GB.ReturnObject(img);
930
931 END_PROPERTY
932
933 BEGIN_METHOD(PDFPAGE_select, GB_INTEGER X; GB_INTEGER Y; GB_INTEGER W; GB_INTEGER H)
934
935 TextOutputDev *dev;
936 GooString *str;
937 Gfx *gfx;
938 int32_t x,y,w,h;
939
940 x = VARGOPT(X, 0);
941 y = VARGOPT(Y, 0);
942 w = VARGOPT(W, (int32_t)THIS->page->getMediaWidth());
943 h = VARGOPT(H, (int32_t)THIS->page->getMediaHeight());
944
945 #if POPPLER_VERSION_0_20
946 dev = new TextOutputDev (NULL, gTrue, 0, gFalse, gFalse);
947 gfx = THIS->page->createGfx(dev,72.0,72.0,0,gFalse,gTrue,-1, -1, -1, -1, gFalse, NULL, NULL);
948 #else
949 dev = new TextOutputDev (NULL, gTrue, gFalse, gFalse);
950 gfx = THIS->page->createGfx(dev,72.0,72.0,0,gFalse,gTrue,-1, -1, -1, -1, \
951 gFalse,THIS->doc->getCatalog (),NULL, NULL, NULL, NULL);
952 #endif
953
954 THIS->page->display(gfx);
955 dev->endPage();
956
957 str=dev->getText((double)x,(double)y,(double)(w+x),(double)(h+y));
958
959 delete gfx;
960 delete dev;
961
962 if (!str)
963 {
964 GB.ReturnNewZeroString("");
965 return;
966 }
967
968 GB.ReturnNewString(str->getCString(),str->getLength());
969 delete str;
970
971 END_METHOD
972
973 /*****************************************************************************
974
975 Bookmarks of a PDF page
976
977 ******************************************************************************/
978
979 void aux_fill_links(void *_object)
980 {
981 #if POPPLER_VERSION_0_20
982 THIS->links = new Links (THIS->page->getAnnots ());
983 #elif POPPLER_VERSION_0_17
984 THIS->links = new Links (THIS->page->getAnnots (THIS->doc->getCatalog()));
985 #else
986 Object obj;
987
988 THIS->links = new Links (THIS->page->getAnnots (&obj),THIS->doc->getCatalog()->getBaseURI ());
989 obj.free();
990 #endif
991 }
992
993 BEGIN_PROPERTY (PDFPAGELINKS_count)
994
995 if (!THIS->links) aux_fill_links(_object);
996 if (!THIS->links) { GB.ReturnInteger(0); return; }
997 GB.ReturnInteger(THIS->links->getNumLinks());
998
999
1000 END_PROPERTY
1001
1002 BEGIN_METHOD (PDFPAGELINKS_get,GB_INTEGER ind;)
1003
1004 bool pok=true;
1005
1006 if (!THIS->links) aux_fill_links(_object);
1007 if (!THIS->links) pok=false;
1008 else
1009 {
1010 if (VARG(ind)<0) pok=false;
1011 else
1012 {
1013 if (VARG(ind)>=THIS->links->getNumLinks()) pok=false;
1014 }
1015 }
1016
1017 if (!pok) { GB.Error("Out of bounds"); GB.ReturnNull(); return; }
1018
1019 THIS->lcurrent=VARG(ind);
1020 THIS->action=THIS->links->getLink(THIS->lcurrent)->getAction();
1021
1022 RETURN_SELF();
1023
1024 END_METHOD
1025
1026 BEGIN_PROPERTY (PDFPAGELINKDATA_parameters)
1027
1028 if (THIS->action->getKind() != actionLaunch )
1029 {
1030 GB.ReturnNewZeroString("");
1031 return;
1032 }
1033
1034 GB.ReturnNewZeroString(((LinkLaunch*)THIS->action)->getParams()->getCString());
1035
1036 END_PROPERTY
1037
1038 BEGIN_PROPERTY (PDFPAGELINKDATA_uri)
1039
1040 char *uri;
1041
1042 uri=aux_get_target_from_action(THIS->action);
1043
1044 GB.ReturnNewZeroString(uri);
1045 if (uri) GB.FreeString(&uri);
1046
1047 END_PROPERTY
1048
1049 BEGIN_PROPERTY(PDFPAGELINKDATA_left)
1050
1051 int32_t vl;
1052
1053 aux_get_dimensions_from_action(THIS->action,&vl, NULL, NULL, NULL);
1054 GB.ReturnInteger(vl);
1055
1056 END_PROPERTY
1057
1058 BEGIN_PROPERTY(PDFPAGELINKDATA_right)
1059
1060 int32_t vl;
1061
1062 aux_get_dimensions_from_action(THIS->action,NULL,&vl, NULL, NULL);
1063 GB.ReturnInteger(vl);
1064
1065 END_PROPERTY
1066
1067 BEGIN_PROPERTY(PDFPAGELINKDATA_top)
1068
1069 int32_t vl;
1070
1071 aux_get_dimensions_from_action(THIS->action,NULL,NULL,&vl, NULL);
1072 GB.ReturnInteger(vl);
1073
1074 END_PROPERTY
1075
1076 BEGIN_PROPERTY(PDFPAGELINKDATA_bottom)
1077
1078 int32_t vl;
1079
1080 aux_get_dimensions_from_action(THIS->action,NULL, NULL, NULL,&vl);
1081
1082 GB.ReturnInteger(vl);
1083
1084 END_PROPERTY
1085
1086 BEGIN_PROPERTY(PDFPAGELINKDATA_zoom)
1087
1088 GB.ReturnFloat(aux_get_zoom_from_action(THIS->action));
1089
1090 END_PROPERTY
1091
1092 BEGIN_PROPERTY(PDFPAGELINKDATA_page)
1093
1094 GB.ReturnInteger(aux_get_page_from_action(_object,THIS->action));
1095
1096 END_PROPERTY
1097
1098 BEGIN_PROPERTY (PDFPAGELINKDATA_type)
1099
1100 GB.ReturnInteger ( (int32_t)THIS->action->getKind() );
1101
1102 END_PROPERTY
1103
1104 BEGIN_PROPERTY(PDFPAGELINKDATA_check)
1105
1106 if (THIS->action)
1107 RETURN_SELF();
1108 else
1109 GB.ReturnNull();
1110
1111 END_PROPERTY
1112
1113 void aux_get_link_dimensions(void *_object,int32_t *left, int32_t *top, int32_t *width, int32_t *height)
1114 {
1115 double l,t,w,h;
1116 double pw,ph;
1117
1118 pw=THIS->page->getMediaWidth();
1119 ph=THIS->page->getMediaHeight();
1120
1121 THIS->links->getLink(THIS->lcurrent)->getRect(&l, &t, &w, &h);
1122 w=w-l;
1123 h=h-t;
1124
1125 switch (THIS->rotation)
1126 {
1127 case 0:
1128 if (left) *left=(int32_t)(l*THIS->scale);
1129 if (top) *top=(int32_t)((ph-t-h)*THIS->scale);
1130 if (width) *width=(int32_t)(w*THIS->scale);
1131 if (height) *height=(int32_t)(h*THIS->scale);
1132 break;
1133
1134 case 90:
1135 if (top) *top=(int32_t)(l*THIS->scale);
1136 if (left) *left=(int32_t)(t*THIS->scale);
1137 if (height) *height=(int32_t)(w*THIS->scale);
1138 if (width) *width=(int32_t)(h*THIS->scale);
1139 break;
1140
1141 case 180:
1142 if (left) *left=(int32_t)((l-w)*THIS->scale);
1143 if (top) *top=(int32_t)(t*THIS->scale);
1144 if (width) *width=(int32_t)(w*THIS->scale);
1145 if (height) *height=(int32_t)(h*THIS->scale);
1146 break;
1147
1148 case 270:
1149 if (top) *top=(int32_t)((pw-l-w)*THIS->scale);
1150 if (left) *left=(int32_t)((ph-t-h)*THIS->scale);
1151 if (height) *height=(int32_t)(w*THIS->scale);
1152 if (width) *width=(int32_t)(h*THIS->scale);
1153 break;
1154 }
1155
1156 }
1157
1158 BEGIN_PROPERTY (PDFPAGELINK_width)
1159
1160 int32_t vl;
1161
1162 aux_get_link_dimensions(_object,NULL,NULL,&vl,NULL);
1163 GB.ReturnInteger(vl);
1164
1165 END_PROPERTY
1166
1167 BEGIN_PROPERTY (PDFPAGELINK_height)
1168
1169 int32_t vl;
1170
1171 aux_get_link_dimensions(_object,NULL,NULL,NULL,&vl);
1172 GB.ReturnInteger(vl);
1173
1174
1175 END_PROPERTY
1176
1177 BEGIN_PROPERTY (PDFPAGELINK_left)
1178
1179 int32_t vl;
1180
1181 aux_get_link_dimensions(_object,&vl,NULL,NULL,NULL);
1182 GB.ReturnInteger(vl);
1183
1184
1185 END_PROPERTY
1186
1187 BEGIN_PROPERTY (PDFPAGELINK_top)
1188
1189 int32_t vl;
1190
1191 aux_get_link_dimensions(_object,NULL,&vl,NULL,NULL);
1192 GB.ReturnInteger(vl);
1193
1194 END_PROPERTY
1195
1196 /*****************************************************************************
1197
1198 Finding a text in a PDF page
1199
1200 ******************************************************************************/
1201
1202 BEGIN_METHOD (PDFPAGE_find,GB_STRING Text; GB_BOOLEAN Sensitive;)
1203
1204 TextOutputDev *textdev;
1205 double x0=0, y0=0;
1206 double x1, y1;
1207 FoundRect *el;
1208 Unicode *block=NULL;
1209 int32_t nlen=0;
1210 bool sensitive=false;
1211
1212 // TODO: Use UCS-4BE on big endian systems?
1213 if (GB.ConvString ((char **)(void *)&block,STRING(Text),LENGTH(Text),"UTF-8","UCS-4LE"))
1214 {
1215 GB.Error("Invalid UTF-8 string");
1216 return;
1217 }
1218
1219 nlen=GB.StringLength((char*)block)/sizeof(Unicode);
1220
1221 if (!MISSING(Sensitive)) sensitive=VARG(Sensitive);
1222
1223 #if POPPLER_VERSION_0_20
1224 textdev = new TextOutputDev (NULL, true, 0, false, false);
1225 THIS->page->display (textdev, 72, 72, 0, false, false, false);
1226 #else
1227 textdev = new TextOutputDev (NULL, true, false, false);
1228 THIS->page->display (textdev, 72, 72, 0, false, false, false, THIS->doc->getCatalog());
1229 #endif
1230
1231 if (THIS->Found) { GB.FreeArray(POINTER(&THIS->Found)); THIS->Found=NULL; }
1232
1233 #if POPPLER_VERSION_0_20
1234 while (textdev->findText (block,nlen,gFalse,gTrue,gTrue,gFalse,sensitive,gFalse,gFalse,&x0,&y0,&x1,&y1))
1235 #else
1236 while (textdev->findText (block,nlen,gFalse,gTrue,gTrue,gFalse,sensitive,gFalse,&x0,&y0,&x1,&y1))
1237 #endif
1238 {
1239 if (!THIS->Found) {
1240 GB.NewArray(POINTER(&THIS->Found),sizeof(FoundRect),1);
1241 }
1242 else {
1243 GB.Add(POINTER(&THIS->Found));
1244 }
1245
1246 el=(FoundRect*)&((FoundRect*)THIS->Found)[GB.Count(POINTER(THIS->Found))-1];
1247
1248 switch (THIS->rotation)
1249 {
1250 case 0:
1251 el->x0=(int32_t)(x0*THIS->scale);
1252 el->y0=(int32_t)(y0*THIS->scale);
1253 el->x1=(int32_t)((x1-x0)*THIS->scale);
1254 el->y1=(int32_t)((y1-y0)*THIS->scale);
1255 break;
1256
1257 case 90:
1258 el->y1=(int32_t)((x1-x0)*THIS->scale);
1259 el->x1=(int32_t)(y1-y0);
1260 el->y0=(int32_t)(x0*THIS->scale);
1261 el->x0=(int32_t)((THIS->page->getMediaHeight()-y0-el->x1)*THIS->scale);
1262 el->x1=(int32_t)(el->x1*THIS->scale);
1263 break;
1264
1265 case 180:
1266 el->x1=(int32_t)(x1-x0);
1267 el->y1=(int32_t)(y1-y0);
1268 el->x0=(int32_t)((THIS->page->getMediaWidth()-x0-el->x1)*THIS->scale);
1269 el->y0=(int32_t)((THIS->page->getMediaHeight()-y0-el->y1)*THIS->scale);
1270 el->x1=(int32_t)(el->x1*THIS->scale);
1271 el->y1=(int32_t)(el->y1*THIS->scale);
1272 break;
1273
1274 case 270:
1275 el->x1=(int32_t)((y1-y0)*THIS->scale);
1276 el->y1=(int32_t)(x1-x0);
1277 el->x0=(int32_t)(y0*THIS->scale);
1278 el->y0=(int32_t)((THIS->page->getMediaWidth()-x0-el->y1)*THIS->scale);
1279 el->y1=(int32_t)(el->y1*THIS->scale);
1280 break;
1281
1282 }
1283 }
1284
1285 delete textdev;
1286
1287
1288 END_METHOD
1289
1290
1291 BEGIN_METHOD (PDFPAGERESULT_get,GB_INTEGER Index;)
1292
1293 bool bok=true;
1294
1295 if (!THIS->Found) bok=false;
1296 else
1297 {
1298 if (VARG(Index)<0) bok=false;
1299 if (VARG(Index)>= GB.Count(POINTER(THIS->Found)) ) bok=false;
1300 }
1301 if (!bok) { GB.Error("Out of bounds"); GB.ReturnNull(); return; }
1302
1303 THIS->fcurrent=VARG(Index);
1304 RETURN_SELF();
1305
1306 END_METHOD
1307
1308 BEGIN_PROPERTY (PDFPAGERESULT_count)
1309
1310 if (!THIS->Found) { GB.ReturnInteger(0); return; }
1311 GB.ReturnInteger( GB.Count(POINTER(THIS->Found)) );
1312
1313 END_PROPERTY
1314
1315 BEGIN_PROPERTY (PDFPAGERESULT_width)
1316
1317 FoundRect *el=(FoundRect*)&((FoundRect*)THIS->Found)[THIS->fcurrent];
1318 GB.ReturnInteger((int32_t)el->x1);
1319
1320 END_PROPERTY
1321
1322 BEGIN_PROPERTY (PDFPAGERESULT_height)
1323
1324 FoundRect *el=(FoundRect*)&((FoundRect*)THIS->Found)[THIS->fcurrent];
1325 GB.ReturnInteger((int32_t)el->y1);
1326
1327 END_PROPERTY
1328
1329 BEGIN_PROPERTY (PDFPAGERESULT_left)
1330
1331 FoundRect *el=(FoundRect*)&((FoundRect*)THIS->Found)[THIS->fcurrent];
1332 GB.ReturnInteger((int32_t)el->x0);
1333
1334 END_PROPERTY
1335
1336 BEGIN_PROPERTY (PDFPAGERESULT_top)
1337
1338 FoundRect *el=(FoundRect*)&((FoundRect*)THIS->Found)[THIS->fcurrent];
1339 GB.ReturnInteger((int32_t)el->y0);
1340
1341 END_PROPERTY
1342
1343 /**********************************************************************
1344
1345 Gambas Interface
1346
1347 ***********************************************************************/
1348
1349
1350 GB_DESC PdfResultItemDesc[]=
1351 {
1352 GB_DECLARE(".PdfResultItem",0), GB_VIRTUAL_CLASS(),
1353
1354 GB_PROPERTY_READ("Left","i",PDFPAGERESULT_left),
1355 GB_PROPERTY_READ("Top","i",PDFPAGERESULT_top),
1356 GB_PROPERTY_READ("Width","i",PDFPAGERESULT_width),
1357 GB_PROPERTY_READ("Height","i",PDFPAGERESULT_height),
1358
1359 GB_END_DECLARE
1360 };
1361
1362 GB_DESC PdfResultDesc[]=
1363 {
1364 GB_DECLARE(".PdfResult",0), GB_VIRTUAL_CLASS(),
1365
1366 GB_METHOD("_get",".PdfResultItem",PDFPAGERESULT_get,"(Index)i"),
1367 GB_PROPERTY_READ("Count","i",PDFPAGERESULT_count),
1368
1369 GB_END_DECLARE
1370 };
1371
1372
1373 GB_DESC PdfLinkDataDesc[]=
1374 {
1375 GB_DECLARE(".PdfLinkData",0), GB_VIRTUAL_CLASS(),
1376
1377 GB_PROPERTY_READ("Type","i",PDFPAGELINKDATA_type),
1378 GB_PROPERTY_READ("Target","s",PDFPAGELINKDATA_uri),
1379 GB_PROPERTY_READ("Parameters","s",PDFPAGELINKDATA_parameters),
1380 GB_PROPERTY_READ("Page","i",PDFPAGELINKDATA_page),
1381 GB_PROPERTY_READ("Left","i",PDFPAGELINKDATA_left),
1382 GB_PROPERTY_READ("Top","i",PDFPAGELINKDATA_top),
1383 GB_PROPERTY_READ("Right","i",PDFPAGELINKDATA_right),
1384 GB_PROPERTY_READ("Bottom","i",PDFPAGELINKDATA_bottom),
1385 GB_PROPERTY_READ("Zoom","f",PDFPAGELINKDATA_zoom),
1386
1387 GB_END_DECLARE
1388 };
1389
1390 GB_DESC PdfLinkDesc[]=
1391 {
1392 GB_DECLARE(".PdfLink",0), GB_VIRTUAL_CLASS(),
1393
1394 GB_PROPERTY_READ("Left","i",PDFPAGELINK_left),
1395 GB_PROPERTY_READ("Top","i",PDFPAGELINK_top),
1396 GB_PROPERTY_READ("Width","i",PDFPAGELINK_width),
1397 GB_PROPERTY_READ("Height","i",PDFPAGELINK_height),
1398 GB_PROPERTY_READ("Data", ".PdfLinkData", PDFPAGELINKDATA_check),
1399
1400 GB_END_DECLARE
1401 };
1402
1403 GB_DESC PdfIndexDesc[]=
1404 {
1405 GB_DECLARE(".PdfIndex",0), GB_VIRTUAL_CLASS(),
1406
1407 GB_PROPERTY("Expanded","b",PDFINDEX_is_open),
1408 GB_PROPERTY_READ("Count","i",PDFINDEX_count),
1409 GB_PROPERTY_READ("HasChildren","b",PDFINDEX_has_children),
1410 GB_PROPERTY_READ("Title","s",PDFINDEX_title),
1411
1412 GB_PROPERTY_READ("Data", ".PdfLinkData", PDFPAGELINKDATA_check),
1413 GB_METHOD("MovePrevious","b",PDFINDEX_prev,0),
1414 GB_METHOD("MoveNext","b",PDFINDEX_next,0),
1415 GB_METHOD("MoveChild","b",PDFINDEX_child,0),
1416 GB_METHOD("MoveParent","b",PDFINDEX_parent,0),
1417 GB_METHOD("MoveRoot",0,PDFINDEX_root,0),
1418
1419 GB_END_DECLARE
1420 };
1421
1422
1423 GB_DESC PdfPageDesc[]=
1424 {
1425 GB_DECLARE(".PdfPage",0), GB_VIRTUAL_CLASS(),
1426
1427 GB_PROPERTY_READ("W","f",PDFPAGE_width),
1428 GB_PROPERTY_READ("H","f",PDFPAGE_height),
1429 GB_PROPERTY_READ("Width","f",PDFPAGE_width),
1430 GB_PROPERTY_READ("Height","f",PDFPAGE_height),
1431 GB_PROPERTY_READ("Picture","Picture",PDFPAGE_property_picture),
1432 GB_PROPERTY_READ("Image","Image",PDFPAGE_property_image),
1433 GB_PROPERTY_SELF("Result",".PdfResult"),
1434
1435 GB_METHOD("GetImage","Image",PDFPAGE_image,"[(X)i(Y)i(Width)i(Height)i]"),
1436 GB_METHOD("GetPicture","Picture",PDFPAGE_picture,"[(X)i(Y)i(Width)i(Height)i]"),
1437 GB_METHOD("Find","b",PDFPAGE_find,"(Text)s[(CaseSensitive)b]"),
1438 GB_METHOD("Select","s",PDFPAGE_select,"[(X)i(Y)i(W)i(H)i]"),
1439
1440 GB_METHOD("_get",".PdfLink",PDFPAGELINKS_get,"(Index)i"),
1441 GB_PROPERTY_READ("Count","i",PDFPAGELINKS_count),
1442
1443 GB_END_DECLARE
1444 };
1445
1446 GB_DESC PdfDocumentInfo[] =
1447 {
1448 GB_DECLARE(".PdfInfo",0), GB_VIRTUAL_CLASS(),
1449
1450 GB_PROPERTY_READ("Title","s",PDFINFO_title),
1451 GB_PROPERTY_READ("Format","s",PDFINFO_format),
1452 GB_PROPERTY_READ("Author","s",PDFINFO_author),
1453 GB_PROPERTY_READ("Subject","s",PDFINFO_subject),
1454 GB_PROPERTY_READ("Keywords","s",PDFINFO_keywords),
1455 GB_PROPERTY_READ("Creator","s",PDFINFO_creator),
1456 GB_PROPERTY_READ("Producer","s",PDFINFO_producer),
1457 GB_PROPERTY_READ("CreationDate","d",PDFINFO_creation),
1458 GB_PROPERTY_READ("ModificationDate","d",PDFINFO_modification),
1459 GB_PROPERTY_READ("Linearized","b",PDFINFO_linearized),
1460 GB_PROPERTY_READ("Layout","i",PDFINFO_layout),
1461 GB_PROPERTY_READ("Mode","i",PDFINFO_mode),
1462 GB_PROPERTY_READ("CanCopy","b",PDFINFO_cancopy),
1463 GB_PROPERTY_READ("CanModify","b",PDFINFO_canmodify),
1464 GB_PROPERTY_READ("CanPrint","b",PDFINFO_canprint),
1465 GB_PROPERTY_READ("CanAddNotes","b",PDFINFO_canaddnotes),
1466
1467 GB_END_DECLARE
1468 };
1469
1470 GB_DESC PdfLayoutDesc[] =
1471 {
1472
1473 GB_DECLARE("PdfLayout", 0), GB_NOT_CREATABLE(),
1474
1475 GB_CONSTANT("Unset","i",Catalog::pageLayoutNone),
1476 GB_CONSTANT("SinglePage","i",Catalog::pageLayoutSinglePage),
1477 GB_CONSTANT("OneColumn","i",Catalog::pageLayoutOneColumn),
1478 GB_CONSTANT("TwoColumnLeft","i",Catalog::pageLayoutTwoColumnLeft),
1479 GB_CONSTANT("TwoColumnRight","i",Catalog::pageLayoutTwoColumnRight),
1480 GB_CONSTANT("TwoPageLeft","i",Catalog::pageLayoutTwoPageLeft),
1481 GB_CONSTANT("TwoPageRight","i",Catalog::pageLayoutTwoPageRight),
1482
1483 GB_END_DECLARE
1484 };
1485
1486
1487 GB_DESC PdfModeDesc[] =
1488 {
1489 GB_DECLARE("PdfPageMode",0), GB_NOT_CREATABLE(),
1490
1491 GB_CONSTANT("Unset","i",Catalog::pageModeNone),
1492 GB_CONSTANT("UseOutlines","i",Catalog::pageModeOutlines),
1493 GB_CONSTANT("UseThumbs","i",Catalog::pageModeThumbs),
1494 GB_CONSTANT("FullScreen","i",Catalog::pageModeFullScreen),
1495 GB_CONSTANT("UseOC","i",Catalog::pageModeOC),
1496 GB_CONSTANT("UseAttachments","i",Catalog::pageModeAttach),
1497
1498 GB_END_DECLARE
1499 };
1500
1501 GB_DESC PdfDocumentDesc[] =
1502 {
1503
1504 GB_DECLARE("PdfDocument", sizeof(CPDFDOCUMENT)),
1505
1506 GB_CONSTANT("Unknown","i",actionUnknown), /* unknown action */
1507 GB_CONSTANT("Goto","i",actionGoTo), /* go to destination */
1508 GB_CONSTANT("GotoRemote","i",actionGoToR), /* go to destination in new file */
1509 GB_CONSTANT("Launch","i",actionLaunch), /* launch app or open doc. */
1510 GB_CONSTANT("Uri","i",actionURI), /* URI */
1511 GB_CONSTANT("Named","i",actionNamed), /* named action*/
1512 GB_CONSTANT("Movie","i",actionMovie), /* movie action */
1513
1514 GB_CONSTANT("Normal","i",0),
1515 GB_CONSTANT("Sideways","i",90),
1516 GB_CONSTANT("Inverted","i",180),
1517 GB_CONSTANT("SidewaysInverted","i",270),
1518
1519 GB_METHOD("_new", 0, PDFDOCUMENT_new, "[(File)s]"),
1520 GB_METHOD("_free", 0, PDFDOCUMENT_free, 0),
1521
1522 GB_METHOD("Open",0,PDFDOCUMENT_open,"(File)s"),
1523 GB_METHOD("Close",0,PDFDOCUMENT_close,0),
1524 GB_METHOD("_get",".PdfPage",PDFDOCUMENT_get,"(Index)i"),
1525
1526 GB_PROPERTY("Zoom", "f", PDFDOCUMENT_scale),
1527 GB_PROPERTY("Orientation", "i", PDFDOCUMENT_rotation),
1528
1529 GB_PROPERTY_READ("Ready","b",PDFDOCUMENT_ready),
1530 GB_PROPERTY_READ("Count","i",PDFDOCUMENT_count),
1531 GB_PROPERTY_READ("HasIndex","b",PDFDOCUMENT_has_index),
1532 GB_PROPERTY_READ("Index",".PdfIndex",PDFDOCUMENT_index),
1533 GB_PROPERTY_READ("Info",".PdfInfo",PDFDOCUMENT_info),
1534
1535 GB_END_DECLARE
1536 };
1537
1538