HPDF_LoadPngImageFromFile (HPDF_Doc pdf,
const HPDF_CHAR *filename)
{
HPDF_Stream imagedata;
HPDF_Image image;
HPDF_PTRACE ((" HPDF_LoadPngImageFromFile\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
/* create file stream */
imagedata = HPDF_FileReader_New (pdf->mmgr, filename);
if (HPDF_Stream_Validate (imagedata))
image = LoadPngImageFromStream (pdf, imagedata, HPDF_FALSE);
else
image = NULL;
/* destroy file stream */
if (imagedata)
HPDF_Stream_Free (imagedata);
if (!image)
HPDF_CheckError (&pdf->error);
return image;
}
HPDF_AddPageLabel (HPDF_Doc pdf,
HPDF_UINT page_num,
HPDF_PageNumStyle style,
HPDF_UINT first_page,
const char *prefix)
{
HPDF_Dict page_label;
HPDF_STATUS ret;
HPDF_PTRACE ((" HPDF_AddPageLabel\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
page_label = HPDF_PageLabel_New (pdf, style, first_page, prefix);
if (!page_label)
return HPDF_CheckError (&pdf->error);
if (style < 0 || style >= HPDF_PAGE_NUM_STYLE_EOF)
return HPDF_RaiseError (&pdf->error, HPDF_PAGE_NUM_STYLE_OUT_OF_RANGE,
(HPDF_STATUS)style);
ret = HPDF_Catalog_AddPageLabel (pdf->catalog, page_num, page_label);
if (ret != HPDF_OK)
return HPDF_CheckError (&pdf->error);
return HPDF_OK;
}
/*
* Class: org_libharu_PdfDocument
* Method: hasDoc
* Signature: (I)Z
*/
JNIEXPORT jboolean JNICALL
Java_org_libharu_PdfDocument_hasDoc(JNIEnv *env, jclass cls, jint pdf) {
if (HPDF_HasDoc((HPDF_Doc) pdf)) {
return JNI_TRUE;
}
return JNI_FALSE;
}
HPDF_LoadTTFontFromFile2 (HPDF_Doc pdf,
const char *file_name,
HPDF_UINT index,
HPDF_BOOL embedding)
{
HPDF_Stream font_data;
const char *ret;
HPDF_PTRACE ((" HPDF_LoadTTFontFromFile2\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
/* create file stream */
font_data = HPDF_FileReader_New (pdf->mmgr, file_name);
if (HPDF_Stream_Validate (font_data)) {
ret = LoadTTFontFromStream2 (pdf, font_data, index, embedding, file_name);
} else
ret = NULL;
if (!ret)
HPDF_CheckError (&pdf->error);
return ret;
}
HPDF_LoadRawImageFromFile (HPDF_Doc pdf,
const char *filename,
HPDF_UINT width,
HPDF_UINT height,
HPDF_ColorSpace color_space)
{
HPDF_Stream imagedata;
HPDF_Image image;
HPDF_PTRACE ((" HPDF_LoadRawImageFromFile\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
/* create file stream */
imagedata = HPDF_FileReader_New (pdf->mmgr, filename);
if (HPDF_Stream_Validate (imagedata))
image = HPDF_Image_LoadRawImage (pdf->mmgr, imagedata, pdf->xref, width,
height, color_space);
else
image = NULL;
/* destroy file stream */
HPDF_Stream_Free (imagedata);
if (!image)
HPDF_CheckError (&pdf->error);
if (image && pdf->compression_mode & HPDF_COMP_IMAGE)
image->filter = HPDF_STREAM_FILTER_FLATE_DECODE;
return image;
}
static const char*
LoadType1FontFromStream (HPDF_Doc pdf,
HPDF_Stream afmdata,
HPDF_Stream pfmdata)
{
HPDF_FontDef def;
HPDF_PTRACE ((" HPDF_LoadType1FontFromStream\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
def = HPDF_Type1FontDef_Load (pdf->mmgr, afmdata, pfmdata);
if (def) {
HPDF_FontDef tmpdef = HPDF_Doc_FindFontDef (pdf, def->base_font);
if (tmpdef) {
HPDF_FontDef_Free (def);
HPDF_SetError (&pdf->error, HPDF_FONT_EXISTS, 0);
return NULL;
}
if (HPDF_List_Add (pdf->fontdef_list, def) != HPDF_OK) {
HPDF_FontDef_Free (def);
return NULL;
}
return def->base_font;
}
return NULL;
}
HPDF_GetCurrentEncoder (HPDF_Doc pdf)
{
if (!HPDF_HasDoc (pdf))
return NULL;
return pdf->cur_encoder;
}
HPDF_GetEncoder (HPDF_Doc pdf,
const char *encoding_name)
{
HPDF_Encoder encoder;
HPDF_STATUS ret;
HPDF_PTRACE ((" HPDF_GetEncoder\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
encoder = HPDF_Doc_FindEncoder (pdf, encoding_name);
if (!encoder) {
encoder = HPDF_BasicEncoder_New (pdf->mmgr, encoding_name);
if (!encoder) {
HPDF_CheckError (&pdf->error);
return NULL;
}
if ((ret = HPDF_List_Add (pdf->encoder_list, encoder)) != HPDF_OK) {
HPDF_Encoder_Free (encoder);
HPDF_RaiseError (&pdf->error, ret, 0);
return NULL;
}
}
return encoder;
}
HPDF_LoadRawImageFromMem (HPDF_Doc pdf,
const HPDF_BYTE *buf,
HPDF_UINT width,
HPDF_UINT height,
HPDF_ColorSpace color_space,
HPDF_UINT bits_per_component)
{
HPDF_Image image;
HPDF_PTRACE ((" HPDF_LoadRawImageFromMem\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
image = HPDF_Image_LoadRawImageFromMem (pdf->mmgr, buf, pdf->xref, width,
height, color_space, bits_per_component);
if (!image)
HPDF_CheckError (&pdf->error);
if (image && pdf->compression_mode & HPDF_COMP_IMAGE)
image->filter = HPDF_STREAM_FILTER_FLATE_DECODE;
return image;
}
HPDF_LoadU3DFromFile (HPDF_Doc pdf,
const char *filename)
{
HPDF_Stream imagedata;
HPDF_Image image;
HPDF_PTRACE ((" HPDF_LoadU3DFromFile\n"));
if (!HPDF_HasDoc (pdf)) {
return NULL;
}
/* create file stream */
imagedata = HPDF_FileReader_New (pdf->mmgr, filename);
if (HPDF_Stream_Validate (imagedata)) {
image = HPDF_U3D_LoadU3D (pdf->mmgr, imagedata, pdf->xref);
} else {
image = NULL;
}
/* destroy file stream */
HPDF_Stream_Free (imagedata);
if (!image) {
HPDF_CheckError (&pdf->error);
}
return image;
}
HPDF_Pages
HPDF_Doc_AddPagesTo (HPDF_Doc pdf,
HPDF_Pages parent)
{
HPDF_Pages pages;
HPDF_PTRACE ((" HPDF_AddPagesTo\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
if (!HPDF_Pages_Validate (parent)) {
HPDF_RaiseError (&pdf->error, HPDF_INVALID_PAGES, 0);
return NULL;
}
/* check whether the page belong to the pdf */
if (pdf->mmgr != parent->mmgr) {
HPDF_RaiseError (&pdf->error, HPDF_INVALID_PAGES, 0);
return NULL;
}
pages = HPDF_Pages_New (pdf->mmgr, parent, pdf->xref);
if (pages)
pdf->cur_pages = pages;
else
HPDF_CheckError (&pdf->error);
return pages;
}
HPDF_SetPagesConfiguration (HPDF_Doc pdf,
HPDF_UINT page_per_pages)
{
HPDF_PTRACE ((" HPDF_SetPagesConfiguration\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
if (pdf->cur_page)
return HPDF_RaiseError (&pdf->error, HPDF_INVALID_DOCUMENT_STATE, 0);
if (page_per_pages > HPDF_LIMIT_MAX_ARRAY)
return HPDF_RaiseError (&pdf->error, HPDF_INVALID_PARAMETER, 0);
if (pdf->cur_pages == pdf->root_pages) {
pdf->cur_pages = HPDF_Doc_AddPagesTo (pdf, pdf->root_pages);
if (!pdf->cur_pages)
return pdf->error.error_no;
pdf->cur_page_num = 0;
}
pdf->page_per_pages = page_per_pages;
return HPDF_OK;
}
HPDF_ReadFromStream (HPDF_Doc pdf,
HPDF_BYTE *buf,
HPDF_UINT32 *size)
{
HPDF_UINT isize = *size;
HPDF_STATUS ret;
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
if (!HPDF_Stream_Validate (pdf->stream))
return HPDF_RaiseError (&pdf->error, HPDF_INVALID_OPERATION, 0);
if (*size == 0)
return HPDF_RaiseError (&pdf->error, HPDF_INVALID_PARAMETER, 0);
ret = HPDF_Stream_Read (pdf->stream, buf, &isize);
*size = isize;
if (ret != HPDF_OK)
HPDF_CheckError (&pdf->error);
return ret;
}
HPDF_GetContents (HPDF_Doc pdf,
HPDF_BYTE *buf,
HPDF_UINT32 *size)
{
HPDF_Stream stream;
HPDF_UINT isize;
HPDF_STATUS ret;
HPDF_PTRACE ((" HPDF_GetContents\n"));
if (!HPDF_HasDoc (pdf)) {
return HPDF_INVALID_DOCUMENT;
}
stream = HPDF_MemStream_New (pdf->mmgr, HPDF_STREAM_BUF_SIZ);
if (!stream) {
return HPDF_CheckError (&pdf->error);
}
if (InternalSaveToStream (pdf, stream) != HPDF_OK) {
HPDF_Stream_Free (stream);
return HPDF_CheckError (&pdf->error);
}
ret = HPDF_Stream_Read (stream, buf, &isize);
*size = isize;
HPDF_Stream_Free (stream);
return ret;
}
HPDF_FontDef
HPDF_GetFontDef (HPDF_Doc pdf,
const char *font_name)
{
HPDF_STATUS ret;
HPDF_FontDef def;
HPDF_PTRACE ((" HPDF_GetFontDef\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
def = HPDF_Doc_FindFontDef (pdf, font_name);
if (!def) {
def = HPDF_Base14FontDef_New (pdf->mmgr, font_name);
if (!def)
return NULL;
if ((ret = HPDF_List_Add (pdf->fontdef_list, def)) != HPDF_OK) {
HPDF_FontDef_Free (def);
HPDF_RaiseError (&pdf->error, ret, 0);
def = NULL;
}
}
return def;
}
HPDF_UseCNTFonts (HPDF_Doc pdf)
{
HPDF_FontDef fontdef;
HPDF_STATUS ret;
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
/* MingLiU */
fontdef = HPDF_CIDFontDef_New (pdf->mmgr, "MingLiU",
MingLiU_Init);
if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)
return ret;
fontdef = HPDF_CIDFontDef_New (pdf->mmgr, "MingLiU,Bold",
MingLiU_Bold_Init);
if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)
return ret;
fontdef = HPDF_CIDFontDef_New (pdf->mmgr, "MingLiU,Italic",
MingLiU_Italic_Init);
if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)
return ret;
fontdef = HPDF_CIDFontDef_New (pdf->mmgr, "MingLiU,BoldItalic",
MingLiU_BoldItalic_Init);
if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)
return ret;
return HPDF_OK;
}
HPDF_UseCNSFonts (HPDF_Doc pdf)
{
HPDF_FontDef fontdef;
HPDF_STATUS ret;
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
/* SimSun */
fontdef = HPDF_CIDFontDef_New (pdf->mmgr, "SimSun",
SimSun_Init);
if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)
return ret;
fontdef = HPDF_CIDFontDef_New (pdf->mmgr, "SimSun,Bold",
SimSun_Bold_Init);
if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)
return ret;
fontdef = HPDF_CIDFontDef_New (pdf->mmgr, "SimSun,Italic",
SimSun_Italic_Init);
if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)
return ret;
fontdef = HPDF_CIDFontDef_New (pdf->mmgr, "SimSun,BoldItalic",
SimSun_BoldItalic_Init);
if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)
return ret;
/* SimHei */
fontdef = HPDF_CIDFontDef_New (pdf->mmgr, "SimHei",
SimHei_Init);
if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)
return ret;
fontdef = HPDF_CIDFontDef_New (pdf->mmgr, "SimHei,Bold",
SimHei_Bold_Init);
if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)
return ret;
fontdef = HPDF_CIDFontDef_New (pdf->mmgr, "SimHei,Italic",
SimHei_Italic_Init);
if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)
return ret;
fontdef = HPDF_CIDFontDef_New (pdf->mmgr, "SimHei,BoldItalic",
SimHei_BoldItalic_Init);
if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)
return ret;
return HPDF_OK;
}
extern void AP_savePdfAndCleanUp(char *path,HPDF_Doc pdf)
{
HPDF_SaveToFile(pdf, path);
printf("[libharu] Freeing PDF object ");
if (HPDF_HasDoc(pdf)) {
HPDF_Free(pdf);
}
printf("[libharu] PDF Creation END");
}
HPDF_GetCurrentPage (HPDF_Doc pdf)
{
HPDF_PTRACE ((" HPDF_GetCurrentPage\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
return pdf->cur_page;
}
HPDF_GetViewerPreference (HPDF_Doc pdf)
{
HPDF_PTRACE ((" HPDF_Catalog_GetViewerPreference\n"));
if (!HPDF_HasDoc (pdf))
return 0;
return HPDF_Catalog_GetViewerPreference (pdf->catalog);
}
HPDF_GetPageMode (HPDF_Doc pdf)
{
HPDF_PTRACE ((" HPDF_GetPageMode\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_PAGE_MODE_USE_NONE;
return HPDF_Catalog_GetPageMode (pdf->catalog);
}
HPDF_GetPageLayout (HPDF_Doc pdf)
{
HPDF_PTRACE ((" HPDF_GetPageLayout\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_PAGE_LAYOUT_SINGLE;
return HPDF_Catalog_GetPageLayout (pdf->catalog);
}
HPDF_ResetStream (HPDF_Doc pdf)
{
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
if (!HPDF_Stream_Validate (pdf->stream))
return HPDF_RaiseError (&pdf->error, HPDF_INVALID_OPERATION, 0);
return HPDF_Stream_Seek (pdf->stream, 0, HPDF_SEEK_SET);
}
HPDF_GetStreamSize (HPDF_Doc pdf)
{
HPDF_PTRACE ((" HPDF_GetStreamSize\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
if (!HPDF_Stream_Validate (pdf->stream))
return 0;
return HPDF_Stream_Size(pdf->stream);
}
HPDF_CreateExtGState (HPDF_Doc pdf)
{
HPDF_ExtGState ext_gstate;
if (!HPDF_HasDoc (pdf))
return NULL;
pdf->pdf_version = HPDF_VER_14;
ext_gstate = HPDF_ExtGState_New (pdf->mmgr, pdf->xref);
if (!ext_gstate)
HPDF_CheckError (&pdf->error);
return ext_gstate;
}
static HPDF_Dict
GetInfo (HPDF_Doc pdf)
{
if (!HPDF_HasDoc (pdf))
return NULL;
if (!pdf->info) {
pdf->info = HPDF_Dict_New (pdf->mmgr);
if (!pdf->info || HPDF_Xref_Add (pdf->xref, pdf->info) != HPDF_OK)
pdf->info = NULL;
}
return pdf->info;
}
HPDF_SetCurrentEncoder (HPDF_Doc pdf,
const char *encoding_name)
{
HPDF_Encoder encoder;
if (!HPDF_HasDoc (pdf))
return HPDF_GetError (pdf);
encoder = HPDF_GetEncoder (pdf, encoding_name);
pdf->cur_encoder = encoder;
if (!pdf)
return HPDF_GetError (pdf);
return HPDF_OK;
}
HPDF_UseUTFEncodings (HPDF_Doc pdf)
{
HPDF_Encoder encoder;
HPDF_STATUS ret;
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
encoder = HPDF_CMapEncoder_New (pdf->mmgr, "UTF-8",
UTF8_Init);
if ((ret = HPDF_Doc_RegisterEncoder (pdf, encoder)) != HPDF_OK)
return ret;
return HPDF_OK;
}
HPDF_SetViewerPreference (HPDF_Doc pdf,
HPDF_UINT value)
{
HPDF_STATUS ret;
HPDF_PTRACE ((" HPDF_Catalog_SetViewerPreference\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
ret = HPDF_Catalog_SetViewerPreference (pdf->catalog, value);
if (ret != HPDF_OK)
return HPDF_CheckError (&pdf->error);
return HPDF_OK;
}
HPDF_LoadPngImageFromFile2 (HPDF_Doc pdf,
const char *filename)
{
HPDF_Stream imagedata;
HPDF_Image image;
HPDF_String fname;
HPDF_PTRACE ((" HPDF_LoadPngImageFromFile\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
/* check whether file name is valid or not. */
imagedata = HPDF_FileReader_New (pdf->mmgr, filename);
if (HPDF_Stream_Validate (imagedata))
image = LoadPngImageFromStream (pdf, imagedata, HPDF_TRUE);
else
image = NULL;
/* destroy file stream */
if (imagedata)
HPDF_Stream_Free (imagedata);
if (!image) {
HPDF_CheckError (&pdf->error);
return NULL;
}
/* add file-name to image dictionary as a hidden entry.
* it is used when the image data is needed.
*/
fname = HPDF_String_New (pdf->mmgr, filename, NULL);
if (!fname) {
HPDF_CheckError (&pdf->error);
return NULL;
}
fname->header.obj_id |= HPDF_OTYPE_HIDDEN;
if ((HPDF_Dict_Add (image, "_FILE_NAME", fname)) != HPDF_OK) {
HPDF_CheckError (&pdf->error);
return NULL;
}
return image;
}
