1/*---------------------------------------------------------------------------*
2 |              PDFlib - A library for generating PDF on the fly             |
3 +---------------------------------------------------------------------------+
4 | Copyright (c) 1997-2004 Thomas Merz and PDFlib GmbH. All rights reserved. |
5 +---------------------------------------------------------------------------+
6 |                                                                           |
7 |    This software is subject to the PDFlib license. It is NOT in the       |
8 |    public domain. Extended versions and commercial licenses are           |
9 |    available, please check http://www.pdflib.com.                         |
10 |                                                                           |
11 *---------------------------------------------------------------------------*/
12
13// $Id: pdflib.cpp 14574 2005-10-29 16:27:43Z bonefish $
14//
15// in sync with pdflib.h 1.151.2.22
16//
17// Implementation of C++ wrapper for PDFlib
18//
19//
20
21#include "pdflib.hpp"
22
23#define CHAR(s)	(s).c_str()
24#define LEN(s)	(s).size()
25
26
27#ifdef	PDF_THROWS_CPP_EXCEPTIONS
28
29PDFlib::Exception::Exception(string errmsg, int errnum, string apiname, void *opaque)
30: m_errmsg(errmsg),
31  m_errnum(errnum),
32  m_apiname(apiname),
33  m_opaque(opaque)
34{ }
35
36string PDFlib::Exception::get_errmsg() { return m_errmsg; }
37string PDFlib::Exception::get_message() { return m_errmsg; }
38int PDFlib::Exception::get_errnum() { return m_errnum; }
39string PDFlib::Exception::get_apiname() { return m_apiname; }
40const void * PDFlib::Exception::get_opaque() { return m_opaque; }
41
42#define PDFCPP_TRY	PDF_TRY(p)
43#define PDFCPP_CATCH  \
44PDF_CATCH(p) {\
45    throw Exception(PDF_get_errmsg(p), PDF_get_errnum(p),\
46			    PDF_get_apiname(p), PDF_get_opaque(p));\
47}
48#else
49
50#define PDFCPP_TRY
51#define PDFCPP_CATCH
52
53#endif // PDF_THROWS_CPP_EXCEPTIONS
54
55
56#ifdef	PDF_THROWS_CPP_EXCEPTIONS
57PDFlib::PDFlib(
58    errorproc_t errorproc,
59    allocproc_t allocproc,
60    reallocproc_t reallocproc,
61    freeproc_t freeproc,
62    void *opaque) PDF_THROWS(PDFlib::Exception)
63{
64    m_PDFlib_api = ::PDF_get_api();
65
66    if (m_PDFlib_api->sizeof_PDFlib_api != sizeof(PDFlib_api) ||
67	m_PDFlib_api->major != PDFLIB_MAJORVERSION ||
68	m_PDFlib_api->minor != PDFLIB_MINORVERSION) {
69	throw Exception("loaded wrong version of PDFlib library", 0,
70		"pdflib.cpp", opaque);
71    }
72
73    m_PDFlib_api->PDF_boot();
74
75    p = m_PDFlib_api->PDF_new2(NULL, allocproc, reallocproc, freeproc, opaque);
76
77/*
78 * errorproc is ignored here to be compatible with old applications
79 * that were not compiled with PDF_THROWS_CPP_EXCEPTIONS
80 */
81    (void) errorproc;
82
83    if (p == (PDF *)0) {
84	throw Exception("No memory for PDFlib object", 0, "pdflib.cpp", opaque);
85    }
86
87    PDFCPP_TRY
88    {
89	PDF_set_parameter(p, "binding", "C++");
90    }
91    PDFCPP_CATCH;
92}
93
94PDFlib::PDFlib(
95    allocproc_t allocproc,
96    reallocproc_t reallocproc,
97    freeproc_t freeproc,
98    void *opaque) PDF_THROWS(PDFlib::Exception)
99{
100    m_PDFlib_api = ::PDF_get_api();
101
102    if (m_PDFlib_api->sizeof_PDFlib_api != sizeof(PDFlib_api) ||
103	m_PDFlib_api->major != PDFLIB_MAJORVERSION ||
104	m_PDFlib_api->minor != PDFLIB_MINORVERSION) {
105	throw Exception("loaded wrong version of PDFlib library", 0,
106		"pdflib.cpp", opaque);
107    }
108
109    m_PDFlib_api->PDF_boot();
110
111    p = m_PDFlib_api->PDF_new2(NULL, allocproc, reallocproc, freeproc, opaque);
112
113    if (p == (PDF *)0) {
114	throw Exception("No memory for PDFlib object", 0, "pdflib.cpp", opaque);
115    }
116
117    PDFCPP_TRY
118    {
119	PDF_set_parameter(p, "binding", "C++");
120    }
121    PDFCPP_CATCH;
122}
123
124#else // ! PDF_THROWS_CPP_EXCEPTIONS
125
126PDFlib::PDFlib(
127    errorproc_t errorproc,
128    allocproc_t allocproc,
129    reallocproc_t reallocproc,
130    freeproc_t freeproc,
131    void *opaque)
132{
133    PDF_boot();
134    m_PDFlib_api = ::PDF_get_api();
135
136    p = m_PDFlib_api->PDF_new2(errorproc, allocproc, reallocproc, freeproc, opaque);
137
138    PDF_set_parameter(p, "binding", "C++");
139}
140
141#endif // ! PDF_THROWS_CPP_EXCEPTIONS
142
143
144PDFlib::~PDFlib() PDF_THROWS_NOTHING
145{
146    m_PDFlib_api->PDF_delete(p);
147    m_PDFlib_api->PDF_shutdown();
148}
149
150/* p_annots.c */
151void
152PDFlib::add_launchlink(float llx, float lly, float urx, float ury,
153    string filename) PDF_THROWS(PDFlib::Exception)
154{
155    PDFCPP_TRY	m_PDFlib_api->PDF_add_launchlink(p, llx, lly, urx, ury, CHAR(filename));
156    PDFCPP_CATCH;
157}
158
159void
160PDFlib::add_locallink(float llx, float lly, float urx, float ury, int page,
161    string optlist) PDF_THROWS(PDFlib::Exception)
162{
163    PDFCPP_TRY	m_PDFlib_api->PDF_add_locallink(p, llx, lly, urx, ury, page, CHAR(optlist));
164    PDFCPP_CATCH;
165}
166
167void
168PDFlib::add_note(float llx, float lly, float urx, float ury, string contents,
169    string title, string icon, bool p_open) PDF_THROWS(PDFlib::Exception)
170{
171    PDFCPP_TRY	m_PDFlib_api->PDF_add_note(p, llx, lly, urx, ury, CHAR(contents),
172    	CHAR(title), CHAR(icon), p_open);
173    PDFCPP_CATCH;
174}
175
176void
177PDFlib::add_pdflink(float llx, float lly, float urx, float ury,
178    string filename, int page, string optlist) PDF_THROWS(PDFlib::Exception)
179{
180    PDFCPP_TRY
181    {
182	m_PDFlib_api->PDF_add_pdflink(p, llx, lly, urx, ury, CHAR(filename),
183			    page, CHAR(optlist));
184    }
185    PDFCPP_CATCH;
186}
187
188void
189PDFlib::add_weblink(float llx, float lly, float urx, float ury,
190    string url) PDF_THROWS(PDFlib::Exception)
191{
192    PDFCPP_TRY	m_PDFlib_api->PDF_add_weblink(p, llx, lly, urx, ury, CHAR(url));
193    PDFCPP_CATCH;
194}
195
196void
197PDFlib::attach_file(float llx, float lly, float urx, float ury,
198    string filename, string description, string author,
199    string mimetype, string icon) PDF_THROWS(PDFlib::Exception)
200{
201    PDFCPP_TRY
202    {
203	m_PDFlib_api->PDF_attach_file2(p, llx, lly, urx, ury, CHAR(filename), 0,
204	    CHAR(description), (int) LEN(description), CHAR(author),
205	    (int) LEN(author), CHAR(mimetype), CHAR(icon));
206    }
207    PDFCPP_CATCH;
208}
209
210void
211PDFlib::set_border_color(float red, float green, float blue)
212    PDF_THROWS(PDFlib::Exception)
213{
214    PDFCPP_TRY	m_PDFlib_api->PDF_set_border_color(p, red, green, blue);
215    PDFCPP_CATCH;
216}
217
218void
219PDFlib::set_border_dash(float b, float w) PDF_THROWS(PDFlib::Exception)
220{
221    PDFCPP_TRY	m_PDFlib_api->PDF_set_border_dash(p, b, w);
222    PDFCPP_CATCH;
223}
224
225void
226PDFlib::set_border_style(string style, float width) PDF_THROWS(PDFlib::Exception)
227{
228    PDFCPP_TRY	m_PDFlib_api->PDF_set_border_style(p, CHAR(style), width);
229    PDFCPP_CATCH;
230}
231
232/* p_basic.c */
233
234void
235PDFlib::begin_page(float width, float height) PDF_THROWS(PDFlib::Exception)
236{
237    PDFCPP_TRY	m_PDFlib_api->PDF_begin_page(p, width, height);
238    PDFCPP_CATCH;
239}
240
241void
242PDFlib::close() PDF_THROWS(PDFlib::Exception)
243{
244    PDFCPP_TRY	m_PDFlib_api->PDF_close(p);
245    PDFCPP_CATCH;
246}
247
248void
249PDFlib::end_page() PDF_THROWS(PDFlib::Exception)
250{
251    PDFCPP_TRY	m_PDFlib_api->PDF_end_page(p);
252    PDFCPP_CATCH;
253}
254
255string
256PDFlib::get_apiname() PDF_THROWS(PDFlib::Exception)
257{
258    const char *retval = NULL;
259
260    PDFCPP_TRY
261    {
262	retval = m_PDFlib_api->PDF_get_apiname(p);
263    }
264    PDFCPP_CATCH;
265
266    if (retval)
267	return retval;
268    else
269	return "";
270}
271
272const char *
273PDFlib::get_buffer(long *size) PDF_THROWS(PDFlib::Exception)
274{
275    const char * retval = NULL;
276
277    PDFCPP_TRY	retval = m_PDFlib_api->PDF_get_buffer(p, size);
278    PDFCPP_CATCH;
279
280    return retval;
281}
282
283string
284PDFlib::get_errmsg() PDF_THROWS(PDFlib::Exception)
285{
286    const char *retval = NULL;
287
288    PDFCPP_TRY
289    {
290	retval = m_PDFlib_api->PDF_get_errmsg(p);
291    }
292    PDFCPP_CATCH;
293
294    if (retval)
295	return retval;
296    else
297	return "";
298}
299
300int
301PDFlib::get_errnum() PDF_THROWS(PDFlib::Exception)
302{
303    int retval = 0;
304
305    PDFCPP_TRY retval = m_PDFlib_api->PDF_get_errnum(p);
306    PDFCPP_CATCH;
307
308    return retval;
309}
310
311int
312PDFlib::get_majorversion() PDF_THROWS_NOTHING
313{
314    return (int) m_PDFlib_api->PDF_get_value(NULL, "major", 0);
315}
316
317int
318PDFlib::get_minorversion() PDF_THROWS_NOTHING
319{
320    return (int) m_PDFlib_api->PDF_get_value(NULL, "minor", 0);
321}
322
323void *
324PDFlib::get_opaque() PDF_THROWS(PDFlib::Exception)
325{
326    void * retval = NULL;
327
328    PDFCPP_TRY	retval = m_PDFlib_api->PDF_get_opaque(p);
329    PDFCPP_CATCH;
330
331    return retval;
332}
333
334int
335PDFlib::open(string filename) PDF_THROWS(PDFlib::Exception)
336{
337    int retval = 0;
338
339    PDFCPP_TRY	retval = m_PDFlib_api->PDF_open_file(p, CHAR(filename));
340    PDFCPP_CATCH;
341
342    return retval;
343}
344
345int
346PDFlib::open(FILE *fp) PDF_THROWS(PDFlib::Exception)
347{
348    int retval = 0;
349
350    PDFCPP_TRY	retval = m_PDFlib_api->PDF_open_fp(p, fp);
351    PDFCPP_CATCH;
352
353    return retval;
354}
355
356void
357PDFlib::open(writeproc_t writeproc) PDF_THROWS(PDFlib::Exception)
358{
359    PDFCPP_TRY	m_PDFlib_api->PDF_open_mem(p, writeproc);
360    PDFCPP_CATCH;
361}
362
363int
364PDFlib::open_file(string filename) PDF_THROWS(PDFlib::Exception)
365{
366    int retval = 0;
367
368    PDFCPP_TRY	retval = m_PDFlib_api->PDF_open_file(p, CHAR(filename));
369    PDFCPP_CATCH;
370
371    return retval;
372}
373
374int
375PDFlib::open_fp(FILE *fp) PDF_THROWS(PDFlib::Exception)
376{
377    int retval = 0;
378
379    PDFCPP_TRY	retval = m_PDFlib_api->PDF_open_fp(p, fp);
380    PDFCPP_CATCH;
381
382    return retval;
383}
384
385void
386PDFlib::open_mem(writeproc_t writeproc) PDF_THROWS(PDFlib::Exception)
387{
388    PDFCPP_TRY	m_PDFlib_api->PDF_open_mem(p, writeproc);
389    PDFCPP_CATCH;
390}
391
392/* p_block.c */
393int
394PDFlib::fill_imageblock(int page, string blockname, int image, string optlist)
395    PDF_THROWS(PDFlib::Exception)
396{
397    int retval = 0;
398
399    PDFCPP_TRY retval = m_PDFlib_api->PDF_fill_imageblock(p, page, CHAR(blockname),
400				image, CHAR(optlist));
401    PDFCPP_CATCH;
402
403    return retval;
404}
405
406int
407PDFlib::fill_pdfblock(int page, string blockname, int contents, string optlist)
408    PDF_THROWS(PDFlib::Exception)
409{
410    int retval = 0;
411
412    PDFCPP_TRY	retval = m_PDFlib_api->PDF_fill_pdfblock(p, page, CHAR(blockname),
413				contents, CHAR(optlist));
414    PDFCPP_CATCH;
415
416    return retval;
417}
418
419int
420PDFlib::fill_textblock(int page, string blockname, string text, string optlist)
421    PDF_THROWS(PDFlib::Exception)
422{
423    int retval = 0;
424
425    PDFCPP_TRY	retval = m_PDFlib_api->PDF_fill_textblock(p, page, CHAR(blockname),
426			    CHAR(text), (int) LEN(text), CHAR(optlist));
427    PDFCPP_CATCH;
428
429    return retval;
430}
431
432/* p_color.c */
433
434int
435PDFlib::makespotcolor(string spotname, int reserved) PDF_THROWS(PDFlib::Exception)
436{
437	(void) reserved;
438
439    int retval = 0;
440
441    PDFCPP_TRY  retval = m_PDFlib_api->PDF_makespotcolor(p, CHAR(spotname), (int) LEN(spotname));
442    PDFCPP_CATCH;
443
444    return retval;
445}
446
447void
448PDFlib::setcolor(string fstype, string colorspace,
449    float c1, float c2, float c3, float c4) PDF_THROWS(PDFlib::Exception)
450{
451    PDFCPP_TRY
452	m_PDFlib_api->PDF_setcolor(p, CHAR(fstype), CHAR(colorspace), c1, c2, c3, c4);
453    PDFCPP_CATCH;
454}
455
456void
457PDFlib::setgray(float g) PDF_THROWS(PDFlib::Exception)
458{
459    PDFCPP_TRY	m_PDFlib_api->PDF_setcolor(p, "fillstroke", "gray", g, 0, 0, 0);
460    PDFCPP_CATCH;
461}
462
463void
464PDFlib::setgray_fill(float g) PDF_THROWS(PDFlib::Exception)
465{
466    PDFCPP_TRY	m_PDFlib_api->PDF_setcolor(p, "fill", "gray", g, 0, 0, 0);
467    PDFCPP_CATCH;
468}
469
470void
471PDFlib::setgray_stroke(float g) PDF_THROWS(PDFlib::Exception)
472{
473    PDFCPP_TRY	m_PDFlib_api->PDF_setcolor(p, "stroke", "gray", g, 0, 0, 0);
474    PDFCPP_CATCH;
475}
476
477void
478PDFlib::setrgbcolor(float red, float green, float blue)
479    PDF_THROWS(PDFlib::Exception)
480{
481    PDFCPP_TRY	m_PDFlib_api->PDF_setcolor(p, "fillstroke", "rgb", red, green, blue, 0);
482    PDFCPP_CATCH;
483}
484
485void
486PDFlib::setrgbcolor_fill(float red, float green, float blue)
487    PDF_THROWS(PDFlib::Exception)
488{
489    PDFCPP_TRY	m_PDFlib_api->PDF_setcolor(p, "fill", "rgb", red, green, blue, 0);
490    PDFCPP_CATCH;
491}
492
493void
494PDFlib::setrgbcolor_stroke(float red, float green, float blue)
495    PDF_THROWS(PDFlib::Exception)
496{
497    PDFCPP_TRY	m_PDFlib_api->PDF_setcolor(p, "stroke", "rgb", red, green, blue, 0);
498    PDFCPP_CATCH;
499}
500
501/* p_draw.c */
502
503void
504PDFlib::arc(float x, float y, float r, float alpha, float beta)
505    PDF_THROWS(PDFlib::Exception)
506{
507    PDFCPP_TRY	m_PDFlib_api->PDF_arc(p, x, y, r, alpha, beta);
508    PDFCPP_CATCH;
509}
510
511void
512PDFlib::arcn(float x, float y, float r, float alpha, float beta)
513    PDF_THROWS(PDFlib::Exception)
514{
515    PDFCPP_TRY	m_PDFlib_api->PDF_arcn(p, x, y, r, alpha, beta);
516    PDFCPP_CATCH;
517}
518
519void
520PDFlib::circle(float x, float y, float r) PDF_THROWS(PDFlib::Exception)
521{
522    PDFCPP_TRY	m_PDFlib_api->PDF_circle(p, x, y, r);
523    PDFCPP_CATCH;
524}
525
526void
527PDFlib::clip() PDF_THROWS(PDFlib::Exception)
528{
529    PDFCPP_TRY	m_PDFlib_api->PDF_clip(p);
530    PDFCPP_CATCH;
531}
532
533void
534PDFlib::closepath() PDF_THROWS(PDFlib::Exception)
535{
536    PDFCPP_TRY	m_PDFlib_api->PDF_closepath(p);
537    PDFCPP_CATCH;
538}
539
540void
541PDFlib::closepath_fill_stroke() PDF_THROWS(PDFlib::Exception)
542{
543    PDFCPP_TRY	m_PDFlib_api->PDF_closepath_fill_stroke(p);
544    PDFCPP_CATCH;
545}
546
547void
548PDFlib::closepath_stroke() PDF_THROWS(PDFlib::Exception)
549{
550    PDFCPP_TRY	m_PDFlib_api->PDF_closepath_stroke(p);
551    PDFCPP_CATCH;
552}
553
554void
555PDFlib::curveto(float x1, float y1, float x2, float y2, float x3, float y3)
556    PDF_THROWS(PDFlib::Exception)
557{
558    PDFCPP_TRY	m_PDFlib_api->PDF_curveto(p, x1, y1, x2, y2, x3, y3);
559    PDFCPP_CATCH;
560}
561
562void
563PDFlib::endpath() PDF_THROWS(PDFlib::Exception)
564{
565    PDFCPP_TRY	m_PDFlib_api->PDF_endpath(p);
566    PDFCPP_CATCH;
567}
568
569void
570PDFlib::fill() PDF_THROWS(PDFlib::Exception)
571{
572    PDFCPP_TRY	m_PDFlib_api->PDF_fill(p);
573    PDFCPP_CATCH;
574}
575
576void
577PDFlib::fill_stroke() PDF_THROWS(PDFlib::Exception)
578{
579    PDFCPP_TRY	m_PDFlib_api->PDF_fill_stroke(p);
580    PDFCPP_CATCH;
581}
582
583void
584PDFlib::lineto(float x, float y) PDF_THROWS(PDFlib::Exception)
585{
586    PDFCPP_TRY	m_PDFlib_api->PDF_lineto(p, x, y);
587    PDFCPP_CATCH;
588}
589
590void
591PDFlib::moveto(float x, float y) PDF_THROWS(PDFlib::Exception)
592{
593    PDFCPP_TRY	m_PDFlib_api->PDF_moveto(p, x, y);
594    PDFCPP_CATCH;
595}
596
597void
598PDFlib::rect(float x, float y, float width, float height)
599    PDF_THROWS(PDFlib::Exception)
600{
601    PDFCPP_TRY	m_PDFlib_api->PDF_rect(p, x, y, width, height);
602    PDFCPP_CATCH;
603}
604
605void
606PDFlib::stroke() PDF_THROWS(PDFlib::Exception)
607{
608    PDFCPP_TRY	m_PDFlib_api->PDF_stroke(p);
609    PDFCPP_CATCH;
610}
611
612/* p_encoding.c */
613
614void
615PDFlib::encoding_set_char(string encoding, int slot, string glyphname, int uv)
616    PDF_THROWS(PDFlib::Exception)
617{
618    PDFCPP_TRY	m_PDFlib_api->PDF_encoding_set_char(p, CHAR(encoding), slot,
619	CHAR(glyphname), uv);
620    PDFCPP_CATCH;
621}
622
623/* p_font.c */
624
625int
626PDFlib::findfont(string fontname, string encoding, int embed)
627    PDF_THROWS(PDFlib::Exception)
628{
629    int retval = 0;
630    PDFCPP_TRY
631
632	retval = m_PDFlib_api->PDF_findfont(p, CHAR(fontname),
633		CHAR(encoding), embed);
634    PDFCPP_CATCH;
635
636    return retval;
637}
638
639int
640PDFlib::load_font(string fontname, string encoding, string optlist)
641        PDF_THROWS(PDFlib::Exception)
642{
643    int retval = 0;
644    PDFCPP_TRY
645       retval = m_PDFlib_api->PDF_load_font(p, CHAR(fontname), 0, CHAR(encoding),
646		    CHAR(optlist));
647    PDFCPP_CATCH;
648
649    return retval;
650}
651
652void
653PDFlib::setfont(int font, float fontsize) PDF_THROWS(PDFlib::Exception)
654{
655    PDFCPP_TRY	m_PDFlib_api->PDF_setfont(p, font, fontsize);
656    PDFCPP_CATCH;
657}
658
659/* p_gstate.c */
660
661void
662PDFlib::concat(float a, float b, float c, float d, float e, float f)
663    PDF_THROWS(PDFlib::Exception)
664{
665    PDFCPP_TRY	m_PDFlib_api->PDF_concat(p, a, b, c, d, e, f);
666    PDFCPP_CATCH;
667}
668
669void
670PDFlib::initgraphics() PDF_THROWS(PDFlib::Exception)
671{
672    PDFCPP_TRY	m_PDFlib_api->PDF_initgraphics(p);
673    PDFCPP_CATCH;
674}
675
676void
677PDFlib::restore() PDF_THROWS(PDFlib::Exception)
678{
679    PDFCPP_TRY	m_PDFlib_api->PDF_restore(p);
680    PDFCPP_CATCH;
681}
682
683void
684PDFlib::rotate(float phi) PDF_THROWS(PDFlib::Exception)
685{
686    PDFCPP_TRY	m_PDFlib_api->PDF_rotate(p, phi);
687    PDFCPP_CATCH;
688}
689
690void
691PDFlib::save() PDF_THROWS(PDFlib::Exception)
692{
693    PDFCPP_TRY	m_PDFlib_api->PDF_save(p);
694    PDFCPP_CATCH;
695}
696
697void
698PDFlib::scale(float sx, float sy) PDF_THROWS(PDFlib::Exception)
699{
700    PDFCPP_TRY	m_PDFlib_api->PDF_scale(p, sx, sy);
701    PDFCPP_CATCH;
702}
703
704void
705PDFlib::setdash(float b, float w) PDF_THROWS(PDFlib::Exception)
706{
707    PDFCPP_TRY	m_PDFlib_api->PDF_setdash(p, b, w);
708    PDFCPP_CATCH;
709}
710
711void
712PDFlib::setdashpattern(string optlist) PDF_THROWS(PDFlib::Exception)
713{
714    PDFCPP_TRY	m_PDFlib_api->PDF_setdashpattern(p, CHAR(optlist));
715    PDFCPP_CATCH;
716}
717
718void
719PDFlib::setflat(float flatness) PDF_THROWS(PDFlib::Exception)
720{
721    PDFCPP_TRY	m_PDFlib_api->PDF_setflat(p, flatness);
722    PDFCPP_CATCH;
723}
724
725void
726PDFlib::setlinecap(int linecap) PDF_THROWS(PDFlib::Exception)
727{
728    PDFCPP_TRY	m_PDFlib_api->PDF_setlinecap(p, linecap);
729    PDFCPP_CATCH;
730}
731
732void
733PDFlib::setlinejoin(int linejoin) PDF_THROWS(PDFlib::Exception)
734{
735    PDFCPP_TRY	m_PDFlib_api->PDF_setlinejoin(p, linejoin);
736    PDFCPP_CATCH;
737}
738
739void
740PDFlib::setlinewidth(float width) PDF_THROWS(PDFlib::Exception)
741{
742    PDFCPP_TRY	m_PDFlib_api->PDF_setlinewidth(p, width);
743    PDFCPP_CATCH;
744}
745
746void
747PDFlib::setmatrix( float a, float b, float c, float d, float e, float f)
748    PDF_THROWS(PDFlib::Exception)
749{
750    PDFCPP_TRY	m_PDFlib_api->PDF_setmatrix(p, a, b, c, d, e, f);
751    PDFCPP_CATCH;
752}
753
754void
755PDFlib::setmiterlimit(float miter) PDF_THROWS(PDFlib::Exception)
756{
757    PDFCPP_TRY	m_PDFlib_api->PDF_setmiterlimit(p, miter);
758    PDFCPP_CATCH;
759}
760
761void
762PDFlib::setpolydash(float *darray, int length) PDF_THROWS(PDFlib::Exception)
763{
764    PDFCPP_TRY	m_PDFlib_api->PDF_setpolydash(p, darray, length);
765    PDFCPP_CATCH;
766}
767
768void
769PDFlib::skew(float alpha, float beta) PDF_THROWS(PDFlib::Exception)
770{
771    PDFCPP_TRY	m_PDFlib_api->PDF_skew(p, alpha, beta);
772    PDFCPP_CATCH;
773}
774
775void
776PDFlib::translate(float tx, float ty) PDF_THROWS(PDFlib::Exception)
777{
778    PDFCPP_TRY	m_PDFlib_api->PDF_translate(p, tx, ty);
779    PDFCPP_CATCH;
780}
781
782/* p_hyper.c */
783
784int
785PDFlib::add_bookmark(string text, int parent, bool p_open)
786    PDF_THROWS(PDFlib::Exception)
787{
788    int retval = 0;
789    PDFCPP_TRY
790      retval = m_PDFlib_api->PDF_add_bookmark2(p, CHAR(text), (int) LEN(text),
791		    parent, p_open);
792    PDFCPP_CATCH;
793
794    return retval;
795}
796
797void
798PDFlib::add_nameddest(string name, string optlist) PDF_THROWS(PDFlib::Exception)
799{
800    PDFCPP_TRY	m_PDFlib_api->PDF_add_nameddest(p, CHAR(name), 0, CHAR(optlist));
801    PDFCPP_CATCH;
802}
803
804void
805PDFlib::set_info(string key, string value) PDF_THROWS(PDFlib::Exception)
806{
807    PDFCPP_TRY
808	m_PDFlib_api->PDF_set_info2(p, CHAR(key), CHAR(value),
809		(int) LEN(value));
810    PDFCPP_CATCH;
811}
812
813/* p_icc.c */
814
815int
816PDFlib::load_iccprofile(string profilename, string optlist)
817    PDF_THROWS(PDFlib::Exception)
818{
819    int retval = 0;
820
821    PDFCPP_TRY
822	retval = m_PDFlib_api->PDF_load_iccprofile(p, CHAR(profilename), 0,
823		CHAR(optlist));
824    PDFCPP_CATCH;
825
826    return retval;
827}
828
829/* p_image.c */
830
831void
832PDFlib::add_thumbnail(int image) PDF_THROWS(PDFlib::Exception)
833{
834    PDFCPP_TRY	m_PDFlib_api->PDF_add_thumbnail(p, image);
835    PDFCPP_CATCH;
836}
837
838void
839PDFlib::close_image(int image) PDF_THROWS(PDFlib::Exception)
840{
841    PDFCPP_TRY	m_PDFlib_api->PDF_close_image(p, image);
842    PDFCPP_CATCH;
843}
844
845void
846PDFlib::fit_image (int image, float x, float y, string optlist)
847        PDF_THROWS(PDFlib::Exception)
848{
849    PDFCPP_TRY	m_PDFlib_api->PDF_fit_image(p, image, x, y, CHAR(optlist));
850    PDFCPP_CATCH;
851}
852
853int
854PDFlib::load_image (string imagetype, string filename, string optlist)
855        PDF_THROWS(PDFlib::Exception)
856{
857    int retval = 0;
858
859    PDFCPP_TRY
860	retval = m_PDFlib_api->PDF_load_image(p, CHAR(imagetype),
861		CHAR(filename),0, CHAR(optlist));
862    PDFCPP_CATCH;
863
864    return retval;
865}
866
867int
868PDFlib::open_CCITT(string filename, int width, int height, bool BitReverse,
869    int K, bool BlackIs1) PDF_THROWS(PDFlib::Exception)
870{
871    int retval = 0;
872
873    PDFCPP_TRY
874    {
875	retval = m_PDFlib_api->PDF_open_CCITT(p, CHAR(filename), width, height,
876				    BitReverse, K, BlackIs1);
877    }
878    PDFCPP_CATCH;
879
880    return retval;
881}
882
883int
884PDFlib::open_image(string imagetype, string source, const char *data, long len,
885    int width, int height, int components, int bpc, string params)
886    PDF_THROWS(PDFlib::Exception)
887{
888    int retval = 0;
889
890    PDFCPP_TRY
891    {
892	retval = m_PDFlib_api->PDF_open_image(p, CHAR(imagetype), CHAR(source),
893			data, len, width, height, components, bpc, CHAR(params));
894    }
895    PDFCPP_CATCH;
896
897    return retval;
898}
899
900int
901PDFlib::open_image_file(string imagetype, string filename,
902    string stringparam, int intparam) PDF_THROWS(PDFlib::Exception)
903{
904    int retval = 0;
905
906    PDFCPP_TRY
907    {
908	retval = m_PDFlib_api->PDF_open_image_file(p, CHAR(imagetype),
909		    CHAR(filename), CHAR(stringparam), intparam);
910    }
911    PDFCPP_CATCH;
912
913    return retval;
914}
915
916void
917PDFlib::place_image(int image, float x, float y, float p_scale)
918    PDF_THROWS(PDFlib::Exception)
919{
920    PDFCPP_TRY	m_PDFlib_api->PDF_place_image(p, image, x, y, p_scale);
921    PDFCPP_CATCH;
922}
923
924/* p_params.c */
925
926string
927PDFlib::get_parameter(string key, float modifier) PDF_THROWS(PDFlib::Exception)
928{
929    const char *retval = NULL;
930
931    PDFCPP_TRY
932    {
933        retval = m_PDFlib_api->PDF_get_parameter(p, CHAR(key), modifier);
934    }
935    PDFCPP_CATCH;
936
937    if (retval)
938	return retval;
939    else
940	return "";
941}
942
943float
944PDFlib::get_value(string key, float modifier) PDF_THROWS(PDFlib::Exception)
945{
946    float retval = 0;
947
948    PDFCPP_TRY	retval = m_PDFlib_api->PDF_get_value(p, CHAR(key), modifier);
949    PDFCPP_CATCH;
950
951    return retval;
952}
953
954void
955PDFlib::set_parameter(string key, string value) PDF_THROWS(PDFlib::Exception)
956{
957    PDFCPP_TRY	m_PDFlib_api->PDF_set_parameter(p, CHAR(key), CHAR(value));
958    PDFCPP_CATCH;
959}
960
961void
962PDFlib::set_value(string key, float value) PDF_THROWS(PDFlib::Exception)
963{
964    PDFCPP_TRY	m_PDFlib_api->PDF_set_value(p, CHAR(key), value);
965    PDFCPP_CATCH;
966}
967
968/* p_pattern.c */
969
970int
971PDFlib::begin_pattern(float width, float height, float xstep, float ystep,
972    int painttype) PDF_THROWS(PDFlib::Exception)
973{
974    int retval = 0;
975
976    PDFCPP_TRY
977
978	retval = m_PDFlib_api->PDF_begin_pattern(p, width, height,
979		xstep, ystep, painttype);
980    PDFCPP_CATCH;
981
982    return retval;
983}
984
985void
986PDFlib::end_pattern() PDF_THROWS(PDFlib::Exception)
987{
988    PDFCPP_TRY	m_PDFlib_api->PDF_end_pattern(p);
989    PDFCPP_CATCH;
990}
991
992/* p_pdi.c */
993
994void
995PDFlib::close_pdi(int doc) PDF_THROWS(PDFlib::Exception)
996{
997    PDFCPP_TRY	m_PDFlib_api->PDF_close_pdi(p, doc);
998    PDFCPP_CATCH;
999}
1000
1001void
1002PDFlib::close_pdi_page(int page) PDF_THROWS(PDFlib::Exception)
1003{
1004    PDFCPP_TRY	m_PDFlib_api->PDF_close_pdi_page(p, page);
1005    PDFCPP_CATCH;
1006}
1007
1008void
1009PDFlib::fit_pdi_page (int page, float x, float y, string optlist)
1010        PDF_THROWS(PDFlib::Exception)
1011{
1012    PDFCPP_TRY	m_PDFlib_api->PDF_fit_pdi_page(p, page, x, y, CHAR(optlist));
1013    PDFCPP_CATCH;
1014}
1015
1016string
1017PDFlib::get_pdi_parameter(string key, int doc, int page, int reserved, int *len)
1018    PDF_THROWS(PDFlib::Exception)
1019{
1020    const char *retval = NULL;
1021
1022    PDFCPP_TRY
1023        retval = m_PDFlib_api->PDF_get_pdi_parameter(p, CHAR(key),
1024		    doc, page, reserved, len);
1025    PDFCPP_CATCH;
1026
1027    if (retval)
1028	return retval;
1029    else
1030	return "";
1031}
1032
1033float
1034PDFlib::get_pdi_value(string key, int doc, int page, int reserved)
1035    PDF_THROWS(PDFlib::Exception)
1036{
1037    float retval = 0;
1038
1039    PDFCPP_TRY
1040	retval = m_PDFlib_api->PDF_get_pdi_value(p, CHAR(key), doc, page,reserved);
1041    PDFCPP_CATCH;
1042
1043    return retval;
1044}
1045
1046int
1047PDFlib::open_pdi(string filename, string optlist, int reserved)
1048    PDF_THROWS(PDFlib::Exception)
1049{
1050    int retval = 0;
1051
1052    PDFCPP_TRY
1053	retval = m_PDFlib_api->PDF_open_pdi(p, CHAR(filename),
1054		CHAR(optlist), reserved);
1055    PDFCPP_CATCH;
1056
1057    return retval;
1058}
1059
1060int
1061PDFlib::open_pdi_page(int doc, int pagenumber, string optlist)
1062    PDF_THROWS(PDFlib::Exception)
1063{
1064    int retval = 0;
1065    PDFCPP_TRY
1066	retval = m_PDFlib_api->PDF_open_pdi_page(p, doc, pagenumber,
1067		    CHAR(optlist));
1068    PDFCPP_CATCH;
1069
1070    return retval;
1071}
1072
1073void
1074PDFlib::place_pdi_page(int page, float x, float y, float sx, float sy)
1075    PDF_THROWS(PDFlib::Exception)
1076{
1077    PDFCPP_TRY	m_PDFlib_api->PDF_place_pdi_page(p, page, x, y, sx, sy);
1078    PDFCPP_CATCH;
1079}
1080
1081int
1082PDFlib::process_pdi(int doc, int page, string optlist)
1083        PDF_THROWS(PDFlib::Exception)
1084{
1085    int retval = 0;
1086
1087    PDFCPP_TRY
1088	retval = m_PDFlib_api->PDF_process_pdi(p, doc, page, CHAR(optlist));
1089    PDFCPP_CATCH;
1090
1091    return retval;
1092}
1093
1094/* p_resource.c */
1095
1096void
1097PDFlib::create_pvf(string filename, void *data, size_t size, string optlist)
1098    PDF_THROWS(PDFlib::Exception)
1099{
1100    PDFCPP_TRY
1101	m_PDFlib_api->PDF_create_pvf(p, CHAR(filename), 0, data, size, CHAR(optlist));
1102    PDFCPP_CATCH;
1103}
1104
1105int
1106PDFlib::delete_pvf(string filename) PDF_THROWS(PDFlib::Exception)
1107{
1108    int retval = 0;
1109
1110    PDFCPP_TRY	retval = m_PDFlib_api->PDF_delete_pvf(p, CHAR(filename), 0);
1111    PDFCPP_CATCH;
1112
1113    return retval;
1114}
1115
1116/* p_shading.c */
1117int
1118PDFlib::shading (string shtype, float x0, float y0, float x1, float y1,
1119    float c1, float c2, float c3, float c4, string optlist)
1120    PDF_THROWS(PDFlib::Exception)
1121{
1122    int retval = 0;
1123
1124    PDFCPP_TRY
1125	retval = m_PDFlib_api->PDF_shading(p, CHAR(shtype), x0, y0, x1, y1,
1126		    c1, c2, c3, c4, CHAR(optlist));
1127    PDFCPP_CATCH;
1128
1129    return retval;
1130}
1131
1132int
1133PDFlib::shading_pattern (int shade, string optlist) PDF_THROWS(PDFlib::Exception)
1134{
1135    int retval = 0;
1136
1137    PDFCPP_TRY
1138	retval = m_PDFlib_api->PDF_shading_pattern(p, shade, CHAR(optlist));
1139    PDFCPP_CATCH;
1140
1141    return retval;
1142}
1143
1144void
1145PDFlib::shfill (int shade) PDF_THROWS(PDFlib::Exception)
1146{
1147    PDFCPP_TRY
1148	m_PDFlib_api->PDF_shfill(p, shade);
1149    PDFCPP_CATCH;
1150}
1151
1152/* p_template.c */
1153
1154int
1155PDFlib::begin_template(float width, float height)
1156    PDF_THROWS(PDFlib::Exception)
1157{
1158    int retval = 0;
1159
1160    PDFCPP_TRY	retval = m_PDFlib_api->PDF_begin_template(p, width, height);
1161    PDFCPP_CATCH;
1162
1163    return retval;
1164}
1165
1166void
1167PDFlib::end_template() PDF_THROWS(PDFlib::Exception)
1168{
1169    PDFCPP_TRY	m_PDFlib_api->PDF_end_template(p);
1170    PDFCPP_CATCH;
1171}
1172
1173/* p_text.c */
1174
1175void
1176PDFlib::continue_text(string text) PDF_THROWS(PDFlib::Exception)
1177{
1178    PDFCPP_TRY	m_PDFlib_api->PDF_continue_text2(p, CHAR(text), (int) LEN(text));
1179    PDFCPP_CATCH;
1180}
1181
1182void
1183PDFlib::fit_textline(string text, float x, float y, string optlist)
1184    PDF_THROWS(PDFlib::Exception)
1185{
1186    PDFCPP_TRY
1187        m_PDFlib_api->PDF_fit_textline(p, CHAR(text), (int) LEN(text), x, y, CHAR(optlist));
1188    PDFCPP_CATCH;
1189}
1190
1191void
1192PDFlib::set_text_pos(float x, float y) PDF_THROWS(PDFlib::Exception)
1193{
1194    PDFCPP_TRY	m_PDFlib_api->PDF_set_text_pos(p, x, y);
1195    PDFCPP_CATCH;
1196}
1197
1198void
1199PDFlib::show(string text) PDF_THROWS(PDFlib::Exception)
1200{
1201    PDFCPP_TRY	m_PDFlib_api->PDF_show2(p, CHAR(text), (int) LEN(text));
1202    PDFCPP_CATCH;
1203}
1204
1205int
1206PDFlib::show_boxed(string text, float left, float top,
1207    float width, float height, string hmode, string feature)
1208    PDF_THROWS(PDFlib::Exception)
1209{
1210    int retval = 0;
1211
1212    PDFCPP_TRY
1213    {
1214	retval = m_PDFlib_api->PDF_show_boxed(p, CHAR(text), left, top, width,
1215		    height, CHAR(hmode), CHAR(feature));
1216    }
1217    PDFCPP_CATCH;
1218
1219    return retval;
1220}
1221
1222void
1223PDFlib::show_xy(string text, float x, float y) PDF_THROWS(PDFlib::Exception)
1224{
1225    PDFCPP_TRY	m_PDFlib_api->PDF_show_xy2(p, CHAR(text), (int) LEN(text), x, y);
1226    PDFCPP_CATCH;
1227}
1228
1229float
1230PDFlib::stringwidth(string text, int font, float fontsize)
1231    PDF_THROWS(PDFlib::Exception)
1232{
1233    float retval = 0;
1234
1235    PDFCPP_TRY
1236	retval = m_PDFlib_api->PDF_stringwidth2(p, CHAR(text),
1237		    (int) LEN(text), font, fontsize);
1238    PDFCPP_CATCH;
1239
1240    return retval;
1241}
1242
1243/* p_type3.c */
1244
1245void
1246PDFlib::begin_font(string fontname, float a, float b,
1247    float c, float d, float e, float f, string optlist)
1248    PDF_THROWS(PDFlib::Exception)
1249{
1250    PDFCPP_TRY	m_PDFlib_api->PDF_begin_font(p, CHAR(fontname), 0,
1251	a, b, c, d, e, f, CHAR(optlist));
1252    PDFCPP_CATCH;
1253}
1254
1255void
1256PDFlib::begin_glyph(string glyphname, float wx, float llx, float lly,
1257    float urx, float ury) PDF_THROWS(PDFlib::Exception)
1258{
1259    PDFCPP_TRY	m_PDFlib_api->PDF_begin_glyph(p, CHAR(glyphname), wx, llx, lly, urx, ury);
1260    PDFCPP_CATCH;
1261}
1262
1263void
1264PDFlib::end_font()
1265    PDF_THROWS(PDFlib::Exception)
1266{
1267    PDFCPP_TRY	m_PDFlib_api->PDF_end_font(p);
1268    PDFCPP_CATCH;
1269}
1270
1271void
1272PDFlib::end_glyph()
1273    PDF_THROWS(PDFlib::Exception)
1274{
1275    PDFCPP_TRY	m_PDFlib_api->PDF_end_glyph(p);
1276    PDFCPP_CATCH;
1277}
1278
1279/* p_xgstate.c */
1280
1281int
1282PDFlib::create_gstate (string optlist) PDF_THROWS(PDFlib::Exception)
1283{
1284    int retval = 0;
1285
1286    PDFCPP_TRY
1287	retval = m_PDFlib_api->PDF_create_gstate(p, CHAR(optlist));
1288    PDFCPP_CATCH;
1289
1290    return retval;
1291}
1292
1293void
1294PDFlib::set_gstate(int gstate)
1295    PDF_THROWS(PDFlib::Exception)
1296{
1297    PDFCPP_TRY	m_PDFlib_api->PDF_set_gstate(p, gstate);
1298    PDFCPP_CATCH;
1299}
1300