pdflib.cpp

windows下PDF文档的开发包

/*---------------------------------------------------------------------------*
 |              PDFlib - A library for generating PDF on the fly             |
 +---------------------------------------------------------------------------+
 | Copyright (c) 1997-2004 Thomas Merz and PDFlib GmbH. All rights reserved. |
 +---------------------------------------------------------------------------+
 |                                                                           |
 |    This software is subject to the PDFlib license. It is NOT in the       |
 |    public domain. Extended versions and commercial licenses are           |
 |    available, please check http://www.pdflib.com.                         |
 |                                                                           |
 *---------------------------------------------------------------------------*/

// $Id: pdflib.cpp,v 1.34.2.12 2004/01/21 14:24:51 tm Exp $
//
// in sync with pdflib.h 1.151.2.22
//
// Implementation of C++ wrapper for PDFlib
//
//

#include "pdflib.hpp"

#define CHAR(s)	(s).c_str()
#define LEN(s)	(s).size()


#ifdef	PDF_THROWS_CPP_EXCEPTIONS

PDFlib::Exception::Exception(string errmsg, int errnum, string apiname, void *opaque)
: m_errmsg(errmsg),
  m_errnum(errnum),
  m_apiname(apiname),
  m_opaque(opaque)
{ }

string PDFlib::Exception::get_errmsg() { return m_errmsg; }
string PDFlib::Exception::get_message() { return m_errmsg; }
int PDFlib::Exception::get_errnum() { return m_errnum; }
string PDFlib::Exception::get_apiname() { return m_apiname; }
const void * PDFlib::Exception::get_opaque() { return m_opaque; }

#define PDFCPP_TRY	PDF_TRY(p)
#define PDFCPP_CATCH  \
PDF_CATCH(p) {\
    throw Exception(PDF_get_errmsg(p), PDF_get_errnum(p),\
			    PDF_get_apiname(p), PDF_get_opaque(p));\
}
#else

#define PDFCPP_TRY
#define PDFCPP_CATCH

#endif // PDF_THROWS_CPP_EXCEPTIONS


#ifdef	PDF_THROWS_CPP_EXCEPTIONS
PDFlib::PDFlib(
    errorproc_t errorproc,
    allocproc_t allocproc,
    reallocproc_t reallocproc,
    freeproc_t freeproc,
    void *opaque) PDF_THROWS(PDFlib::Exception)
{
    m_PDFlib_api = ::PDF_get_api();

    if (m_PDFlib_api->sizeof_PDFlib_api != sizeof(PDFlib_api) ||
	m_PDFlib_api->major != PDFLIB_MAJORVERSION ||
	m_PDFlib_api->minor != PDFLIB_MINORVERSION) {
	throw Exception("loaded wrong version of PDFlib library", 0,
		"pdflib.cpp", opaque);
    }

    m_PDFlib_api->PDF_boot();

    p = m_PDFlib_api->PDF_new2(NULL, allocproc, reallocproc, freeproc, opaque);

/*
 * errorproc is ignored here to be compatible with old applications
 * that were not compiled with PDF_THROWS_CPP_EXCEPTIONS
 */
    (void) errorproc;

    if (p == (PDF *)0) {
	throw Exception("No memory for PDFlib object", 0, "pdflib.cpp", opaque);
    }

    PDFCPP_TRY
    {
	PDF_set_parameter(p, "binding", "C++");
    }
    PDFCPP_CATCH;
}

PDFlib::PDFlib(
    allocproc_t allocproc,
    reallocproc_t reallocproc,
    freeproc_t freeproc,
    void *opaque) PDF_THROWS(PDFlib::Exception)
{
    m_PDFlib_api = ::PDF_get_api();

    if (m_PDFlib_api->sizeof_PDFlib_api != sizeof(PDFlib_api) ||
	m_PDFlib_api->major != PDFLIB_MAJORVERSION ||
	m_PDFlib_api->minor != PDFLIB_MINORVERSION) {
	throw Exception("loaded wrong version of PDFlib library", 0,
		"pdflib.cpp", opaque);
    }

    m_PDFlib_api->PDF_boot();

    p = m_PDFlib_api->PDF_new2(NULL, allocproc, reallocproc, freeproc, opaque);

    if (p == (PDF *)0) {
	throw Exception("No memory for PDFlib object", 0, "pdflib.cpp", opaque);
    }

    PDFCPP_TRY
    {
	PDF_set_parameter(p, "binding", "C++");
    }
    PDFCPP_CATCH;
}

#else // ! PDF_THROWS_CPP_EXCEPTIONS

PDFlib::PDFlib(
    errorproc_t errorproc,
    allocproc_t allocproc,
    reallocproc_t reallocproc,
    freeproc_t freeproc,
    void *opaque)
{
    PDF_boot();
    m_PDFlib_api = ::PDF_get_api();

    p = m_PDFlib_api->PDF_new2(errorproc, allocproc, reallocproc, freeproc, opaque);

    PDF_set_parameter(p, "binding", "C++");
}

#endif // ! PDF_THROWS_CPP_EXCEPTIONS


PDFlib::~PDFlib() PDF_THROWS_NOTHING
{
    m_PDFlib_api->PDF_delete(p);
    m_PDFlib_api->PDF_shutdown();
}

/* p_annots.c */
void
PDFlib::add_launchlink(float llx, float lly, float urx, float ury,
    string filename) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_add_launchlink(p, llx, lly, urx, ury, CHAR(filename));
    PDFCPP_CATCH;
}

void
PDFlib::add_locallink(float llx, float lly, float urx, float ury, int page,
    string optlist) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_add_locallink(p, llx, lly, urx, ury, page, CHAR(optlist));
    PDFCPP_CATCH;
}

void
PDFlib::add_note(float llx, float lly, float urx, float ury, string contents,
    string title, string icon, bool p_open) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_add_note(p, llx, lly, urx, ury, CHAR(contents),
    	CHAR(title), CHAR(icon), p_open);
    PDFCPP_CATCH;
}

void
PDFlib::add_pdflink(float llx, float lly, float urx, float ury,
    string filename, int page, string optlist) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY
    {
	m_PDFlib_api->PDF_add_pdflink(p, llx, lly, urx, ury, CHAR(filename),
			    page, CHAR(optlist));
    }
    PDFCPP_CATCH;
}

void
PDFlib::add_weblink(float llx, float lly, float urx, float ury,
    string url) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_add_weblink(p, llx, lly, urx, ury, CHAR(url));
    PDFCPP_CATCH;
}

void
PDFlib::attach_file(float llx, float lly, float urx, float ury,
    string filename, string description, string author,
    string mimetype, string icon) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY
    {
	m_PDFlib_api->PDF_attach_file2(p, llx, lly, urx, ury, CHAR(filename), 0,
	    CHAR(description), (int) LEN(description), CHAR(author),
	    (int) LEN(author), CHAR(mimetype), CHAR(icon));
    }
    PDFCPP_CATCH;
}

void
PDFlib::set_border_color(float red, float green, float blue)
    PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_set_border_color(p, red, green, blue);
    PDFCPP_CATCH;
}

void
PDFlib::set_border_dash(float b, float w) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_set_border_dash(p, b, w);
    PDFCPP_CATCH;
}

void
PDFlib::set_border_style(string style, float width) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_set_border_style(p, CHAR(style), width);
    PDFCPP_CATCH;
}

/* p_basic.c */

void
PDFlib::begin_page(float width, float height) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_begin_page(p, width, height);
    PDFCPP_CATCH;
}

void
PDFlib::close() PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_close(p);
    PDFCPP_CATCH;
}

void
PDFlib::end_page() PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_end_page(p);
    PDFCPP_CATCH;
}

string
PDFlib::get_apiname() PDF_THROWS(PDFlib::Exception)
{
    const char *retval = NULL;

    PDFCPP_TRY 
    {
	retval = m_PDFlib_api->PDF_get_apiname(p);
    }
    PDFCPP_CATCH;

    if (retval)
	return retval;
    else
	return "";
}

const char *
PDFlib::get_buffer(long *size) PDF_THROWS(PDFlib::Exception)
{
    const char * retval = NULL;

    PDFCPP_TRY	retval = m_PDFlib_api->PDF_get_buffer(p, size);
    PDFCPP_CATCH;

    return retval;
}

string
PDFlib::get_errmsg() PDF_THROWS(PDFlib::Exception)
{
    const char *retval = NULL;

    PDFCPP_TRY 
    {
	retval = m_PDFlib_api->PDF_get_errmsg(p);
    }
    PDFCPP_CATCH;

    if (retval)
	return retval;
    else
	return "";
}

int
PDFlib::get_errnum() PDF_THROWS(PDFlib::Exception)
{
    int retval = 0;

    PDFCPP_TRY retval = m_PDFlib_api->PDF_get_errnum(p);
    PDFCPP_CATCH;

    return retval;
}

int
PDFlib::get_majorversion() PDF_THROWS_NOTHING
{
    return (int) m_PDFlib_api->PDF_get_value(NULL, "major", 0);
}

int
PDFlib::get_minorversion() PDF_THROWS_NOTHING
{
    return (int) m_PDFlib_api->PDF_get_value(NULL, "minor", 0);
}

void *
PDFlib::get_opaque() PDF_THROWS(PDFlib::Exception)
{
    void * retval = NULL;

    PDFCPP_TRY	retval = m_PDFlib_api->PDF_get_opaque(p);
    PDFCPP_CATCH;

    return retval;
}

int
PDFlib::open(string filename) PDF_THROWS(PDFlib::Exception)
{
    int retval = 0;

    PDFCPP_TRY	retval = m_PDFlib_api->PDF_open_file(p, CHAR(filename));
    PDFCPP_CATCH;

    return retval;
}

int
PDFlib::open(FILE *fp) PDF_THROWS(PDFlib::Exception)
{
    int retval = 0;

    PDFCPP_TRY	retval = m_PDFlib_api->PDF_open_fp(p, fp);
    PDFCPP_CATCH;

    return retval;
}

void
PDFlib::open(writeproc_t writeproc) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_open_mem(p, writeproc);
    PDFCPP_CATCH;
}

int
PDFlib::open_file(string filename) PDF_THROWS(PDFlib::Exception)
{
    int retval = 0;

    PDFCPP_TRY	retval = m_PDFlib_api->PDF_open_file(p, CHAR(filename));
    PDFCPP_CATCH;

    return retval;
}

int
PDFlib::open_fp(FILE *fp) PDF_THROWS(PDFlib::Exception)
{
    int retval = 0;

    PDFCPP_TRY	retval = m_PDFlib_api->PDF_open_fp(p, fp);
    PDFCPP_CATCH;

    return retval;
}

void
PDFlib::open_mem(writeproc_t writeproc) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_open_mem(p, writeproc);
    PDFCPP_CATCH;
}

/* p_block.c */
int
PDFlib::fill_imageblock(int page, string blockname, int image, string optlist)
    PDF_THROWS(PDFlib::Exception)
{
    int retval = 0;

    PDFCPP_TRY retval = m_PDFlib_api->PDF_fill_imageblock(p, page, CHAR(blockname),
				image, CHAR(optlist));
    PDFCPP_CATCH;

    return retval;
}

int
PDFlib::fill_pdfblock(int page, string blockname, int contents, string optlist)
    PDF_THROWS(PDFlib::Exception)
{
    int retval = 0;

    PDFCPP_TRY	retval = m_PDFlib_api->PDF_fill_pdfblock(p, page, CHAR(blockname),
				contents, CHAR(optlist));
    PDFCPP_CATCH;

    return retval;
}

int
PDFlib::fill_textblock(int page, string blockname, string text, string optlist)
    PDF_THROWS(PDFlib::Exception)
{
    int retval = 0;

    PDFCPP_TRY	retval = m_PDFlib_api->PDF_fill_textblock(p, page, CHAR(blockname),
			    CHAR(text), (int) LEN(text), CHAR(optlist));
    PDFCPP_CATCH;

    return retval;
}

/* p_color.c */

int
PDFlib::makespotcolor(string spotname, int reserved) PDF_THROWS(PDFlib::Exception)
{
	(void) reserved;
	
    int retval = 0;

    PDFCPP_TRY  retval = m_PDFlib_api->PDF_makespotcolor(p, CHAR(spotname), (int) LEN(spotname));
    PDFCPP_CATCH;

    return retval;
}

void
PDFlib::setcolor(string fstype, string colorspace,
    float c1, float c2, float c3, float c4) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY
	m_PDFlib_api->PDF_setcolor(p, CHAR(fstype), CHAR(colorspace), c1, c2, c3, c4);
    PDFCPP_CATCH;
}

void
PDFlib::setgray(float g) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_setcolor(p, "fillstroke", "gray", g, 0, 0, 0);
    PDFCPP_CATCH;
}

void
PDFlib::setgray_fill(float g) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_setcolor(p, "fill", "gray", g, 0, 0, 0);
    PDFCPP_CATCH;
}

void
PDFlib::setgray_stroke(float g) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_setcolor(p, "stroke", "gray", g, 0, 0, 0);
    PDFCPP_CATCH;
}

void
PDFlib::setrgbcolor(float red, float green, float blue)
    PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_setcolor(p, "fillstroke", "rgb", red, green, blue, 0);
    PDFCPP_CATCH;
}

void
PDFlib::setrgbcolor_fill(float red, float green, float blue)
    PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_setcolor(p, "fill", "rgb", red, green, blue, 0);
    PDFCPP_CATCH;
}

void
PDFlib::setrgbcolor_stroke(float red, float green, float blue)
    PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_setcolor(p, "stroke", "rgb", red, green, blue, 0);
    PDFCPP_CATCH;
}

/* p_draw.c */

void
PDFlib::arc(float x, float y, float r, float alpha, float beta)
    PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_arc(p, x, y, r, alpha, beta);
    PDFCPP_CATCH;
}

void
PDFlib::arcn(float x, float y, float r, float alpha, float beta)
    PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_arcn(p, x, y, r, alpha, beta);
    PDFCPP_CATCH;
}

void
PDFlib::circle(float x, float y, float r) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_circle(p, x, y, r);
    PDFCPP_CATCH;
}

void
PDFlib::clip() PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_clip(p);
    PDFCPP_CATCH;
}

void
PDFlib::closepath() PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_closepath(p);
    PDFCPP_CATCH;
}

void
PDFlib::closepath_fill_stroke() PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_closepath_fill_stroke(p);
    PDFCPP_CATCH;
}

void
PDFlib::closepath_stroke() PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_closepath_stroke(p);
    PDFCPP_CATCH;
}

void
PDFlib::curveto(float x1, float y1, float x2, float y2, float x3, float y3)
    PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_curveto(p, x1, y1, x2, y2, x3, y3);
    PDFCPP_CATCH;
}

void
PDFlib::endpath() PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_endpath(p);
    PDFCPP_CATCH;
}

void
PDFlib::fill() PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_fill(p);
    PDFCPP_CATCH;
}

void
PDFlib::fill_stroke() PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_fill_stroke(p);
    PDFCPP_CATCH;
}

void
PDFlib::lineto(float x, float y) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_lineto(p, x, y);
    PDFCPP_CATCH;
}

void
PDFlib::moveto(float x, float y) PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_moveto(p, x, y);
    PDFCPP_CATCH;
}

void
PDFlib::rect(float x, float y, float width, float height)
    PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_rect(p, x, y, width, height);
    PDFCPP_CATCH;
}

void
PDFlib::stroke() PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_stroke(p);
    PDFCPP_CATCH;
}

/* p_encoding.c */

void
PDFlib::encoding_set_char(string encoding, int slot, string glyphname, int uv)
    PDF_THROWS(PDFlib::Exception)
{
    PDFCPP_TRY	m_PDFlib_api->PDF_encoding_set_char(p, CHAR(encoding), slot,
	CHAR(glyphname), uv);
    PDFCPP_CATCH;
}

/* p_font.c */

int
PDFlib::findfont(string fontname, string encoding, int embed)
    PDF_THROWS(PDFlib::Exception)
{
    int retval = 0;
    PDFCPP_TRY

	retval = m_PDFlib_api->PDF_findfont(p, CHAR(fontname),
		CHAR(encoding), embed);
    PDFCPP_CATCH;

    return retval;
}

int
PDFlib::load_font(string fontname, string encoding, string optlist)
        PDF_THROWS(PDFlib::Exception)
{
    int retval = 0;
    PDFCPP_TRY
       retval = m_PDFlib_api->PDF_load_font(p, CHAR(fontname), 0, CHAR(encoding),
		    CHAR(optlist));
    PDFCPP_CATCH;

    return retval;
}