wok-6.x: ac1cbda6d814 gambas2/stuff/CPdfDocument.cpp

wok-6.x view gambas2/stuff/CPdfDocument.cpp @ rev 22023

Remove cat process

author	Pascal Bellard <pascal.bellard@slitaz.org>
date	Sun Oct 20 12:39:13 2019 +0200 (2019-10-20)
parents
children

line source

1 /***************************************************************************

3 CPdfDocument.cpp

5 gb.pdf Component

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.

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.

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.

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.

29 ***************************************************************************/

31 #define __CPDFDOCUMENT_C

33 #include "CPdfDocument.h"

35 #include "gambas.h"

36 #include "main.h"

38 #include <stdio.h>

39 #include <stdint.h>

40 #include <math.h>

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>

55 /*****************************************************************************

57 Translations from Poppler universe to Gambas universe

59 ******************************************************************************/

60 typedef struct

61 {

62 int32_t x0;

63 int32_t y0;

64 int32_t x1;

65 int32_t y1;

66 } FoundRect;

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;

76 THIS->doc->getDocInfo (&obj);

77 if (!obj.isDict()) { GB.ReturnNewZeroString(""); return; }

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();

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 }

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

SliTaz Repositories

wok-6.x view gambas2/stuff/CPdfDocument.cpp @ rev 22023