home *** CD-ROM | disk | FTP | other *** search
/ PC World 2002 February / PCWorld_2002-02_cd.bin / Software / Vyzkuste / pdflib / pdflib-4.0.1.sit / pdflib-4.0.1 / bind / cpp / pdflib.cpp < prev    next >
Encoding:
Text File  |  2001-07-04  |  12.6 KB  |  660 lines  |  [TEXT/CWIE]
  1. /*---------------------------------------------------------------------------*
  2.  |              PDFlib - A library for generating PDF on the fly             |
  3.  +---------------------------------------------------------------------------+
  4.  | Copyright (c) 1997-2001 PDFlib GmbH and Thomas Merz. All rights reserved. |
  5.  +---------------------------------------------------------------------------+
  6.  |    This software is NOT in the public domain.  It can be used under two   |
  7.  |    substantially different licensing terms:                               |
  8.  |                                                                           |
  9.  |    The commercial license is available for a fee, and allows you to       |
  10.  |    - ship a commercial product based on PDFlib                            |
  11.  |    - implement commercial Web services with PDFlib                        |
  12.  |    - distribute (free or commercial) software when the source code is     |
  13.  |      not made available                                                   |
  14.  |    Details can be found in the file PDFlib-license.pdf.                   |
  15.  |                                                                           |
  16.  |    The "Aladdin Free Public License" doesn't require any license fee,     |
  17.  |    and allows you to                                                      |
  18.  |    - develop and distribute PDFlib-based software for which the complete  |
  19.  |      source code is made available                                        |
  20.  |    - redistribute PDFlib non-commercially under certain conditions        |
  21.  |    - redistribute PDFlib on digital media for a fee if the complete       |
  22.  |      contents of the media are freely redistributable                     |
  23.  |    Details can be found in the file aladdin-license.pdf.                  |
  24.  |                                                                           |
  25.  |    These conditions extend to ports to other programming languages.       |
  26.  |    PDFlib is distributed with no warranty of any kind. Commercial users,  |
  27.  |    however, will receive warranty and support statements in writing.      |
  28.  *---------------------------------------------------------------------------*/
  29.  
  30. // $Id: pdflib.cpp,v 1.13 2001/04/02 11:45:28 york Exp $
  31. //
  32. // Implementation of C++ wrapper for PDFlib
  33. //
  34. //
  35.  
  36. #include "pdflib.hpp"
  37.  
  38. // If we don't have ANSI C++ strings we do it the old way.
  39. #ifdef PDF_BROKEN_STRINGS
  40.     #define CHAR(s)    (char const *)(s)
  41. #else
  42.     #define CHAR(s)    s.c_str()
  43. #endif
  44.  
  45. PDF::PDF(
  46.     errorproc_t errorproc,
  47.     allocproc_t allocproc,
  48.     reallocproc_t reallocproc,
  49.     freeproc_t freeproc,
  50.     void *opaque)
  51. {
  52.     PDF_boot();
  53.     p = ::PDF_new2(errorproc, allocproc, reallocproc, freeproc, opaque);
  54.  
  55.     if (p)
  56.     PDF_set_parameter(p, "binding", "C++");
  57. }
  58.  
  59. PDF::~PDF()
  60. {
  61.     ::PDF_delete(p);
  62.     ::PDF_shutdown();
  63. }
  64.  
  65. void *
  66. PDF::get_opaque()
  67. {
  68.     return ::PDF_get_opaque(p);
  69. }
  70.  
  71. int
  72. PDF::get_majorversion()
  73. {
  74.     return ::PDF_get_majorversion();
  75. }
  76.  
  77. int
  78. PDF::get_minorversion()
  79. {
  80.     return ::PDF_get_minorversion();
  81. }
  82.  
  83. int
  84. PDF::open(pdfstring filename)
  85. {
  86.     return ::PDF_open_file(p, CHAR(filename));
  87. }
  88.  
  89. int
  90. PDF::open(FILE *fp)
  91. {
  92.     return ::PDF_open_fp(p, fp);
  93. }
  94.  
  95. void
  96. PDF::open(writeproc_t writeproc)
  97. {
  98.     ::PDF_open_mem(p, writeproc);
  99. }
  100.  
  101. void
  102. PDF::close()
  103. {
  104.     ::PDF_close(p);
  105. }
  106.  
  107. const char *
  108. PDF::get_buffer(long *size)
  109. {
  110.     return ::PDF_get_buffer(p, size);
  111. }
  112.  
  113. void
  114. PDF::begin_page(float width, float height)
  115. {
  116.     ::PDF_begin_page(p, width, height);
  117. }
  118.  
  119. void
  120. PDF::end_page()
  121. {
  122.     ::PDF_end_page(p);
  123. }
  124.  
  125. void
  126. PDF::set_parameter(pdfstring key, pdfstring value)
  127. {
  128.     ::PDF_set_parameter(p, CHAR(key), CHAR(value));
  129. }
  130.  
  131. pdfstring
  132. PDF::get_parameter(pdfstring key, float mod)
  133. {
  134.     return ::PDF_get_parameter(p, CHAR(key), mod);
  135. }
  136.  
  137. float
  138. PDF::get_value(pdfstring key, float mod)
  139. {
  140.     return ::PDF_get_value(p, CHAR(key), mod);
  141. }
  142.  
  143. void
  144. PDF::set_value(pdfstring key, float value)
  145. {
  146.     ::PDF_set_value(p, CHAR(key), value);
  147. }
  148.  
  149. #ifdef PDF_BROKEN_STRINGS
  150.  
  151. void
  152. PDF::show2(pdfstring text, int len)
  153. {
  154.     ::PDF_show2(p, CHAR(text), len);
  155. }
  156.  
  157. void
  158. PDF::show_xy2(pdfstring text, int len, float x, float y)
  159. {
  160.     ::PDF_show_xy2(p, CHAR(text), len, x, y);
  161. }
  162.  
  163. void
  164. PDF::continue_text2(pdfstring text, int len)
  165. {
  166.     ::PDF_continue_text2(p, CHAR(text), len);
  167. }
  168.  
  169. float
  170. PDF::stringwidth2(pdfstring text, int len, int font, float size)
  171. {
  172.     return ::PDF_stringwidth2(p, CHAR(text), len, font, size);
  173. }
  174.  
  175. #endif // PDF_BROKEN_STRINGS
  176.  
  177. void
  178. PDF::show(pdfstring text)
  179. {
  180. #ifdef PDF_BROKEN_STRINGS
  181.     ::PDF_show(p, CHAR(text));
  182. #else
  183.     ::PDF_show2(p, text.c_str(), (int) text.size());
  184. #endif
  185. }
  186.  
  187. void
  188. PDF::show_xy(pdfstring text, float x, float y)
  189. {
  190. #ifdef PDF_BROKEN_STRINGS
  191.     ::PDF_show_xy(p, CHAR(text), x, y);
  192. #else
  193.     ::PDF_show_xy2(p, text.c_str(), (int) text.size(), x, y);
  194. #endif
  195. }
  196.  
  197. void
  198. PDF::continue_text(pdfstring text)
  199. {
  200. #ifdef PDF_BROKEN_STRINGS
  201.     ::PDF_continue_text(p, CHAR(text));
  202. #else
  203.     ::PDF_continue_text2(p, text.c_str(), (int) text.size());
  204. #endif
  205. }
  206.  
  207. int
  208. PDF::show_boxed(pdfstring text, float left, float top,
  209.     float width, float height, pdfstring hmode, pdfstring reserved)
  210. {
  211.     return ::PDF_show_boxed(p, CHAR(text), left, top, width, height,
  212.         CHAR(hmode), CHAR(reserved));
  213. }
  214.  
  215. void
  216. PDF::set_text_pos(float x, float y)
  217. {
  218.     ::PDF_set_text_pos(p, x, y);
  219. }
  220.  
  221. float
  222. PDF::stringwidth(pdfstring text, int font, float size)
  223. {
  224. #ifdef PDF_BROKEN_STRINGS
  225.     return ::PDF_stringwidth(p, CHAR(text), font, size);
  226. #else
  227.     return ::PDF_stringwidth2(p, text.c_str(), (int) text.size(), font, size);
  228. #endif
  229. }
  230.  
  231. int
  232. PDF::findfont(pdfstring fontname, pdfstring encoding, int embed)
  233. {
  234.     return ::PDF_findfont(p, CHAR(fontname), CHAR(encoding), embed);
  235. }
  236.  
  237. void
  238. PDF::setfont(int font, float fontsize)
  239. {
  240.     ::PDF_setfont(p, font, fontsize);
  241. }
  242.  
  243. void
  244. PDF::save()
  245. {
  246.     ::PDF_save(p);
  247. }
  248.  
  249. void
  250. PDF::restore()
  251. {
  252.     ::PDF_restore(p);
  253. }
  254.  
  255. void
  256. PDF::translate(float tx, float ty)
  257. {
  258.     ::PDF_translate(p, tx, ty);
  259. }
  260.  
  261. void
  262. PDF::scale(float sx, float sy)
  263. {
  264.     ::PDF_scale(p, sx, sy);
  265. }
  266.  
  267. void
  268. PDF::rotate(float phi)
  269. {
  270.     ::PDF_rotate(p, phi);
  271. }
  272.  
  273. void
  274. PDF::skew(float alpha, float beta)
  275. {
  276.     ::PDF_skew(p, alpha, beta);
  277. }
  278.  
  279. void
  280. PDF::concat(float a, float b, float c, float d, float e, float f)
  281. {
  282.     ::PDF_concat(p, a, b, c, d, e, f);
  283. }
  284.  
  285. void
  286. PDF::setdash(float b, float w)
  287. {
  288.     ::PDF_setdash(p, b, w);
  289. }
  290.  
  291. void
  292. PDF::setpolydash(float *darray, int length)
  293. {
  294.     ::PDF_setpolydash(p, darray, length);
  295. }
  296.  
  297. void
  298. PDF::setflat(float flat)
  299. {
  300.     ::PDF_setflat(p, flat);
  301. }
  302.  
  303. void
  304. PDF::setlinejoin(int join)
  305. {
  306.     ::PDF_setlinejoin(p, join);
  307. }
  308.  
  309. void
  310. PDF::setlinecap(int cap)
  311. {
  312.     ::PDF_setlinecap(p, cap);
  313. }
  314.  
  315. void
  316. PDF::setmiterlimit(float miter)
  317. {
  318.     ::PDF_setmiterlimit(p, miter);
  319. }
  320.  
  321. void
  322. PDF::setlinewidth(float width)
  323. {
  324.     ::PDF_setlinewidth(p, width);
  325. }
  326.  
  327. void
  328. PDF::moveto(float x, float y)
  329. {
  330.     ::PDF_moveto(p, x, y);
  331. }
  332.  
  333. void
  334. PDF::lineto(float x, float y)
  335. {
  336.     ::PDF_lineto(p, x, y);
  337. }
  338.  
  339. void
  340. PDF::curveto(float x1, float y1, float x2, float y2, float x3, float y3)
  341. {
  342.     ::PDF_curveto(p, x1, y1, x2, y2, x3, y3);
  343. }
  344.  
  345. void
  346. PDF::circle(float x, float y, float r)
  347. {
  348.     ::PDF_circle(p, x, y, r);
  349. }
  350.  
  351. void
  352. PDF::arc(float x, float y, float r, float alpha1, float alpha2)
  353. {
  354.     ::PDF_arc(p, x, y, r, alpha1, alpha2);
  355. }
  356.  
  357. void
  358. PDF::arcn(float x, float y, float r, float alpha1, float alpha2)
  359. {
  360.     ::PDF_arcn(p, x, y, r, alpha1, alpha2);
  361. }
  362.  
  363. void
  364. PDF::rect(float x, float y, float width, float height)
  365. {
  366.     ::PDF_rect(p, x, y, width, height);
  367. }
  368.  
  369. void
  370. PDF::closepath()
  371. {
  372.     ::PDF_closepath(p);
  373. }
  374.  
  375. void
  376. PDF::stroke()
  377. {
  378.     ::PDF_stroke(p);
  379. }
  380.  
  381. void
  382. PDF::closepath_stroke()
  383. {
  384.     ::PDF_closepath_stroke(p);
  385. }
  386.  
  387. void
  388. PDF::fill()
  389. {
  390.     ::PDF_fill(p);
  391. }
  392.  
  393. void
  394. PDF::fill_stroke()
  395. {
  396.     ::PDF_fill_stroke(p);
  397. }
  398.  
  399. void
  400. PDF::closepath_fill_stroke()
  401. {
  402.     ::PDF_closepath_fill_stroke(p);
  403. }
  404.  
  405. void
  406. PDF::clip()
  407. {
  408.     ::PDF_clip(p);
  409. }
  410.  
  411. void
  412. PDF::endpath()
  413. {
  414.     ::PDF_endpath(p);
  415. }
  416.  
  417. void
  418. PDF::setgray_fill(float g)
  419. {
  420.     ::PDF_setcolor(p, "fill", "gray", g, 0, 0, 0);
  421. }
  422.  
  423. void
  424. PDF::setgray_stroke(float g)
  425. {
  426.     ::PDF_setcolor(p, "stroke", "gray", g, 0, 0, 0);
  427. }
  428.  
  429. void
  430. PDF::setgray(float g)
  431. {
  432.     ::PDF_setcolor(p, "both", "gray", g, 0, 0, 0);
  433. }
  434.  
  435. void
  436. PDF::setrgbcolor_fill(float red, float green, float blue)
  437. {
  438.     ::PDF_setcolor(p, "fill", "rgb", red, green, blue, 0);
  439. }
  440.  
  441. void
  442. PDF::setrgbcolor_stroke(float red, float green, float blue)
  443. {
  444.     ::PDF_setcolor(p, "stroke", "rgb", red, green, blue, 0);
  445. }
  446.  
  447. void
  448. PDF::setrgbcolor(float red, float green, float blue)
  449. {
  450.     ::PDF_setcolor(p, "both", "rgb", red, green, blue, 0);
  451. }
  452.  
  453. int
  454. PDF::begin_template(float width, float height)
  455. {
  456.     return ::PDF_begin_template(p, width, height);
  457. }
  458.  
  459. void
  460. PDF::end_template()
  461. {
  462.     ::PDF_end_template(p);
  463. }
  464.  
  465. void
  466. PDF::place_image(int image, float x, float y, float scale)
  467. {
  468.     ::PDF_place_image(p, image, x, y, scale);
  469. }
  470.  
  471. int
  472. PDF::open_image(pdfstring type, pdfstring source, const char *data,
  473.     long len, int width, int height, int components, int bpc, pdfstring params)
  474. {
  475.     return ::PDF_open_image(p, CHAR(type), CHAR(source), data, len,
  476.         width, height, components, bpc, CHAR(params));
  477. }
  478.  
  479. void
  480. PDF::close_image(int image)
  481. {
  482.     ::PDF_close_image(p, image);
  483. }
  484.  
  485. int
  486. PDF::open_image_file(pdfstring type, pdfstring filename,
  487.     pdfstring stringparam, int intparam)
  488. {
  489.     return ::PDF_open_image_file(p, CHAR(type), CHAR(filename),
  490.         CHAR(stringparam), intparam);
  491. }
  492.  
  493. int
  494. PDF::open_CCITT(pdfstring filename, int width, int height, bool BitReverse,
  495.     int K, bool BlackIs1)
  496. {
  497.     return ::PDF_open_CCITT(p, CHAR(filename), width, height, BitReverse,
  498.     K,BlackIs1);
  499. }
  500.  
  501. int
  502. PDF::add_bookmark(pdfstring text, int parent, bool open)
  503. {
  504.     return ::PDF_add_bookmark(p, CHAR(text), parent, open);
  505. }
  506.  
  507. void
  508. PDF::set_info(pdfstring key, pdfstring value)
  509. {
  510.     ::PDF_set_info(p, CHAR(key), CHAR(value));
  511. }
  512.  
  513. void
  514. PDF::attach_file(float llx, float lly, float urx, float ury,
  515.     pdfstring filename, pdfstring description, pdfstring author,
  516.     pdfstring mimetype, pdfstring icon)
  517. {
  518.     ::PDF_attach_file(p, llx, lly, urx, ury, CHAR(filename), CHAR(description),
  519.             CHAR(author), CHAR(mimetype), CHAR(icon));
  520. }
  521.  
  522. void
  523. PDF::add_note(float llx, float lly, float urx, float ury, pdfstring contents,
  524.     pdfstring title, pdfstring icon, bool open)
  525. {
  526.     ::PDF_add_note(p, llx, lly, urx, ury, CHAR(contents),
  527.         CHAR(title), CHAR(icon), open);
  528. }
  529.  
  530. void
  531. PDF::add_pdflink(float llx, float lly, float urx, float ury,
  532.     pdfstring filename, int page, pdfstring dest)
  533. {
  534.     ::PDF_add_pdflink(p, llx, lly, urx, ury, CHAR(filename), page, CHAR(dest));
  535. }
  536.  
  537. void
  538. PDF::add_launchlink(float llx, float lly, float urx, float ury,
  539.     pdfstring filename)
  540. {
  541.     ::PDF_add_launchlink(p, llx, lly, urx, ury, CHAR(filename));
  542. }
  543.  
  544. void
  545. PDF::add_locallink(float llx, float lly, float urx, float ury, int page,
  546.     pdfstring dest)
  547. {
  548.     ::PDF_add_locallink(p, llx, lly, urx, ury, page, CHAR(dest));
  549. }
  550.  
  551. void
  552. PDF::add_weblink(float llx, float lly, float urx, float ury, pdfstring url)
  553. {
  554.     ::PDF_add_weblink(p, llx, lly, urx, ury, CHAR(url));
  555. }
  556.  
  557. void
  558. PDF::set_border_style(pdfstring style, float width)
  559. {
  560.     ::PDF_set_border_style(p, CHAR(style), width);
  561. }
  562.  
  563. void
  564. PDF::set_border_color(float red, float green, float blue)
  565. {
  566.     ::PDF_set_border_color(p, red, green, blue);
  567. }
  568.  
  569. void
  570. PDF::set_border_dash(float d1, float d2)
  571. {
  572.     ::PDF_set_border_dash(p, d1, d2);
  573. }
  574.  
  575. int
  576. PDF::open_pdi(pdfstring filename, pdfstring stringparam, int intparam)
  577. {
  578.     return ::PDF_open_pdi(p, CHAR(filename), CHAR(stringparam), intparam);
  579. }
  580.  
  581. void
  582. PDF::close_pdi(int doc)
  583. {
  584.     ::PDF_close_pdi(p, doc);
  585. }
  586.  
  587. int
  588. PDF::open_pdi_page(int doc, int page, pdfstring label)
  589. {
  590.     return ::PDF_open_pdi_page(p, doc, page, CHAR(label));
  591. }
  592.  
  593. void
  594. PDF::place_pdi_page(int page, float x, float y, float sx, float sy)
  595. {
  596.     ::PDF_place_pdi_page(p, page, x, y, sx, sy);
  597. }
  598.  
  599. void
  600. PDF::close_pdi_page(int page)
  601. {
  602.     ::PDF_close_pdi_page(p, page);
  603. }
  604.  
  605. pdfstring
  606. PDF::get_pdi_parameter(pdfstring key, int doc, int page, int index, int *len)
  607. {
  608.     return ::PDF_get_pdi_parameter(p, CHAR(key), doc, page, index, len);
  609. }
  610.  
  611. float
  612. PDF::get_pdi_value(pdfstring key, int doc, int page, int index)
  613. {
  614.     return ::PDF_get_pdi_value(p, CHAR(key), doc, page, index);
  615. }
  616.  
  617. int
  618. PDF::begin_pattern(float width, float height, float xstep, float ystep,
  619.     int painttype)
  620. {
  621.     return ::PDF_begin_pattern(p, width, height, xstep, ystep, painttype);
  622. }
  623.  
  624. void
  625. PDF::end_pattern()
  626. {
  627.     ::PDF_end_pattern(p);
  628. }
  629.  
  630. int
  631. PDF::makespotcolor(pdfstring spotname, int len)
  632. {
  633.     return ::PDF_makespotcolor(p, CHAR(spotname), len);
  634. }
  635.  
  636. void
  637. PDF::setcolor(pdfstring type, pdfstring colorspace,
  638.     float c1, float c2, float c3, float c4)
  639. {
  640.     ::PDF_setcolor(p, CHAR(type), CHAR(colorspace), c1, c2, c3, c4);
  641. }
  642.  
  643. void
  644. PDF::add_thumbnail(int image)
  645. {
  646.     ::PDF_add_thumbnail(p, image);
  647. }
  648.  
  649. void
  650. PDF::initgraphics()
  651. {
  652.     ::PDF_initgraphics(p);
  653. }
  654.  
  655. void
  656. PDF::setmatrix(float a, float b, float c, float d, float e, float f)
  657. {
  658.     ::PDF_setmatrix(p, a, b, c, d, e, f);
  659. }
  660.