HPDF_SaveToFile (HPDF_Doc pdf,
const char *file_name)
{
HPDF_Stream stream;
HPDF_PTRACE ((" HPDF_SaveToFile\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
stream = HPDF_FileWriter_New (pdf->mmgr, file_name);
if (!stream)
return HPDF_CheckError (&pdf->error);
InternalSaveToStream (pdf, stream);
HPDF_Stream_Free (stream);
return HPDF_CheckError (&pdf->error);
}
HPDF_MarkupAnnot_SetIntent (HPDF_Annotation annot,
HPDF_AnnotIntent intent)
{
HPDF_PTRACE((" HPDF_MarkupAnnot_SetIntent\n"));
if (HPDF_Dict_AddName (annot, "IT",
HPDF_ANNOT_INTENT_NAMES[(HPDF_INT)intent]) != HPDF_OK)
return HPDF_CheckError (annot->error);
return HPDF_OK;
}
HPDF_SetPassword (HPDF_Doc pdf,
const char *owner_passwd,
const char *user_passwd)
{
HPDF_PTRACE ((" HPDF_SetPassword\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_DOC_INVALID_OBJECT;
if (!pdf->encrypt_dict) {
pdf->encrypt_dict = HPDF_EncryptDict_New (pdf->mmgr, pdf->xref);
if (!pdf->encrypt_dict)
return HPDF_CheckError (&pdf->error);
}
if (HPDF_EncryptDict_SetPassword (pdf->encrypt_dict, owner_passwd,
user_passwd) != HPDF_OK)
return HPDF_CheckError (&pdf->error);
return HPDF_Doc_SetEncryptOn (pdf);
}
HPDF_Page_SetHeight (HPDF_Page page,
HPDF_REAL value)
{
HPDF_PTRACE((" HPDF_Page_SetWidth\n"));
if (value < 3 || value > 14400)
return HPDF_RaiseError (page->error, HPDF_PAGE_INVALID_SIZE, 0);
if (HPDF_Page_SetBoxValue (page, "MediaBox", 3, value) != HPDF_OK)
return HPDF_CheckError (page->error);
return HPDF_OK;
}
HPDF_Image_SetMaskImage (HPDF_Image image,
HPDF_Image mask_image)
{
if (!HPDF_Image_Validate (image))
return HPDF_INVALID_IMAGE;
if (!HPDF_Image_Validate (mask_image))
return HPDF_INVALID_IMAGE;
if (HPDF_Image_SetMask (mask_image, HPDF_TRUE) != HPDF_OK)
return HPDF_CheckError (image->error);
return HPDF_Dict_Add (image, "Mask", mask_image);
}
HPDF_GetInfoAttr (HPDF_Doc pdf,
HPDF_InfoType type)
{
const char *ret = NULL;
HPDF_Dict info = GetInfo (pdf);
HPDF_PTRACE((" HPDF_GetInfoAttr\n"));
if (info)
ret = HPDF_Info_GetInfoAttr (info, type);
else
HPDF_CheckError (&pdf->error);
return ret;
}
HPDF_Image_GetColorSpace (HPDF_Image image)
{
HPDF_Name n;
HPDF_PTRACE ((" HPDF_Image_GetColorSpace\n"));
n = HPDF_Dict_GetItem (image, "ColorSpace", HPDF_OCLASS_NAME);
if (!n) {
HPDF_CheckError (image->error);
return NULL;
}
return n->value;
}
HPDF_3DAnnot_Set3DView (HPDF_Annotation annot)
{
HPDF_Boolean b;
HPDF_PTRACE((" HPDF_3DAnnot_Set3DView\n"));
if (!CheckSubType (annot, HPDF_ANNOT_3D))
return HPDF_INVALID_ANNOTATION;
b = HPDF_Boolean_New (annot->mmgr, 0);
if (!b)
return HPDF_CheckError (annot->error);
return HPDF_Dict_Add (annot, "3DD", b);
}
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;
}
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_PopupAnnot_SetOpened (HPDF_Annotation annot,
HPDF_BOOL opened)
{
HPDF_Boolean b;
HPDF_PTRACE((" HPDF_TextAnnot_SetOpend\n"));
if (!CheckSubType (annot, HPDF_ANNOT_POPUP))
return HPDF_INVALID_ANNOTATION;
b = HPDF_Boolean_New (annot->mmgr, opened);
if (!b)
return HPDF_CheckError (annot->error);
return HPDF_Dict_Add (annot, "Open", b);
}
HPDF_Page_CreateDestination (HPDF_Page page)
{
HPDF_PageAttr attr;
HPDF_Destination dst;
HPDF_PTRACE((" HPDF_Page_CreateDestination\n"));
if (!HPDF_Page_Validate (page))
return NULL;
attr = (HPDF_PageAttr)page->attr;
dst = HPDF_Destination_New (page->mmgr, page, attr->xref);
if (!dst)
HPDF_CheckError (page->error);
return dst;
}
HPDF_TextAnnot_SetIcon (HPDF_Annotation annot,
HPDF_AnnotIcon icon)
{
HPDF_PTRACE((" HPDF_TextAnnot_SetIcon\n"));
if (!CheckSubType (annot, HPDF_ANNOT_TEXT_NOTES))
return HPDF_INVALID_ANNOTATION;
if (icon >= HPDF_ANNOT_ICON_EOF)
return HPDF_RaiseError (annot->error, HPDF_ANNOT_INVALID_ICON,
(HPDF_STATUS)icon);
if (HPDF_Dict_AddName (annot, "Name",
HPDF_ANNOT_ICON_NAMES_NAMES[(HPDF_INT)icon]) != HPDF_OK)
return HPDF_CheckError (annot->error);
return HPDF_OK;
}
HPDF_Page_Create3DAnnotExData(HPDF_Page page)
{
HPDF_PageAttr attr;
HPDF_Annotation exData;
HPDF_PTRACE((" HPDF_Page_Create3DAnnotExData\n"));
if (!HPDF_Page_Validate (page))
return NULL;
attr = (HPDF_PageAttr)page->attr;
exData = HPDF_3DAnnotExData_New(page->mmgr, attr->xref);
if ( !exData)
HPDF_CheckError (page->error);
return exData;
}
HPDF_AddPage (HPDF_Doc pdf)
{
HPDF_Page page;
HPDF_STATUS ret;
HPDF_PTRACE ((" HPDF_AddPage\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
if (pdf->page_per_pages) {
if (pdf->page_per_pages <= pdf->cur_page_num) {
pdf->cur_pages = HPDF_Doc_AddPagesTo (pdf, pdf->root_pages);
if (!pdf->cur_pages)
return NULL;
pdf->cur_page_num = 0;
}
}
page = HPDF_Page_New (pdf->mmgr, pdf->xref);
if (!page) {
HPDF_CheckError (&pdf->error);
return NULL;
}
if ((ret = HPDF_Pages_AddKids (pdf->cur_pages, page)) != HPDF_OK) {
HPDF_RaiseError (&pdf->error, ret, 0);
return NULL;
}
if ((ret = HPDF_List_Add (pdf->page_list, page)) != HPDF_OK) {
HPDF_RaiseError (&pdf->error, ret, 0);
return NULL;
}
pdf->cur_page = page;
if (pdf->compression_mode & HPDF_COMP_TEXT)
HPDF_Page_SetFilter (page, HPDF_STREAM_FILTER_FLATE_DECODE);
pdf->cur_page_num++;
return page;
}
HPDF_InsertPage (HPDF_Doc pdf,
HPDF_Page target)
{
HPDF_Page page;
HPDF_STATUS ret;
HPDF_PTRACE ((" HPDF_InsertPage\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
if (!HPDF_Page_Validate (target)) {
HPDF_RaiseError (&pdf->error, HPDF_INVALID_PAGE, 0);
return NULL;
}
/* check whether the page belong to the pdf */
if (pdf->mmgr != target->mmgr) {
HPDF_RaiseError (&pdf->error, HPDF_INVALID_PAGE, 0);
return NULL;
}
page = HPDF_Page_New (pdf->mmgr, pdf->xref);
if (!page) {
HPDF_CheckError (&pdf->error);
return NULL;
}
if ((ret = HPDF_Page_InsertBefore (page, target)) != HPDF_OK) {
HPDF_RaiseError (&pdf->error, ret, 0);
return NULL;
}
if ((ret = HPDF_List_Insert (pdf->page_list, target, page)) != HPDF_OK) {
HPDF_RaiseError (&pdf->error, ret, 0);
return NULL;
}
if (pdf->compression_mode & HPDF_COMP_TEXT)
HPDF_Page_SetFilter (page, HPDF_STREAM_FILTER_FLATE_DECODE);
return page;
}
HPDF_STATUS
HPDF_PDFA_AppendOutputIntents(HPDF_Doc pdf, const char *iccname, HPDF_Dict iccdict)
{
HPDF_Array intents;
HPDF_Dict intent;
HPDF_STATUS ret;
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
/* prepare intent */
intent = HPDF_Dict_New (pdf->mmgr);
ret = HPDF_Xref_Add (pdf->xref, intent);
if ( ret != HPDF_OK) {
HPDF_Dict_Free(intent);
return ret;
}
ret += HPDF_Dict_AddName (intent, "Type", "OutputIntent");
ret += HPDF_Dict_AddName (intent, "S", "GTS_PDFA1");
ret += HPDF_Dict_Add (intent, "OutputConditionIdentifier", HPDF_String_New (pdf->mmgr, iccname, NULL));
ret += HPDF_Dict_Add (intent, "OutputCondition", HPDF_String_New (pdf->mmgr, iccname,NULL));
ret += HPDF_Dict_Add (intent, "Info", HPDF_String_New (pdf->mmgr, iccname, NULL));
ret += HPDF_Dict_Add (intent, "DestOutputProfile ", iccdict);
if ( ret != HPDF_OK) {
HPDF_Dict_Free(intent);
return ret;
}
/* Copied from HPDF_AddIntent - not public function */
intents = HPDF_Dict_GetItem (pdf->catalog, "OutputIntents", HPDF_OCLASS_ARRAY);
if (intents == NULL) {
intents = HPDF_Array_New (pdf->mmgr);
if (intents) {
HPDF_STATUS ret = HPDF_Dict_Add (pdf->catalog, "OutputIntents", intents);
if (ret != HPDF_OK) {
HPDF_CheckError (&pdf->error);
return HPDF_Error_GetDetailCode (&pdf->error);
}
}
}
HPDF_Array_Add(intents,intent);
return HPDF_Error_GetDetailCode (&pdf->error);
}
HPDF_SetOpenAction (HPDF_Doc pdf,
HPDF_Destination open_action)
{
HPDF_STATUS ret;
HPDF_PTRACE ((" HPDF_SetOpenAction\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
if (open_action && !HPDF_Destination_Validate (open_action))
return HPDF_RaiseError (&pdf->error, HPDF_INVALID_DESTINATION, 0);
ret = HPDF_Catalog_SetOpenAction (pdf->catalog, open_action);
if (ret != HPDF_OK)
return HPDF_CheckError (&pdf->error);
return HPDF_OK;
}
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 (pdf->compression_mode & HPDF_COMP_IMAGE)
{
if (image != NULL)
image->filter = HPDF_STREAM_FILTER_FLATE_DECODE;
else
{
printf("Error. image is NULL.\n");
assert (0);
}
}
return image;
}
HPDF_LoadJpegImageFromMem (HPDF_Doc pdf,
const HPDF_BYTE *buffer,
HPDF_UINT size)
{
HPDF_Image image;
HPDF_PTRACE ((" HPDF_LoadJpegImageFromMem\n"));
if (!HPDF_HasDoc (pdf)) {
return NULL;
}
image = HPDF_Image_LoadJpegImageFromMem (pdf->mmgr, buffer, size , pdf->xref);
if (!image) {
HPDF_CheckError (&pdf->error);
}
return image;
}
HPDF_SaveToStream (HPDF_Doc pdf)
{
HPDF_PTRACE ((" HPDF_SaveToStream\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
if (!pdf->stream)
pdf->stream = HPDF_MemStream_New (pdf->mmgr, HPDF_STREAM_BUF_SIZ);
if (!HPDF_Stream_Validate (pdf->stream))
return HPDF_RaiseError (&pdf->error, HPDF_INVALID_STREAM, 0);
HPDF_MemStream_FreeData (pdf->stream);
if (InternalSaveToStream (pdf, pdf->stream) != HPDF_OK)
return HPDF_CheckError (&pdf->error);
return HPDF_OK;
}
HPDF_Page_Create3DC3DMeasure(HPDF_Page page,
HPDF_Point3D firstanchorpoint,
HPDF_Point3D textanchorpoint)
{
HPDF_PageAttr attr;
HPDF_Annotation measure;
HPDF_PTRACE((" HPDF_Page_Create3DC3DMeasure\n"));
if (!HPDF_Page_Validate (page))
return NULL;
attr = (HPDF_PageAttr)page->attr;
measure = HPDF_3DC3DMeasure_New(page->mmgr, attr->xref, firstanchorpoint, textanchorpoint);
if ( !measure)
HPDF_CheckError (page->error);
return measure;
}
HPDF_SetPageLayout (HPDF_Doc pdf,
HPDF_PageLayout layout)
{
HPDF_STATUS ret;
HPDF_PTRACE ((" HPDF_GetPageLayout\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
if (layout < 0 || layout >= HPDF_PAGE_LAYOUT_EOF)
return HPDF_RaiseError (&pdf->error, HPDF_PAGE_LAYOUT_OUT_OF_RANGE,
(HPDF_STATUS)layout);
ret = HPDF_Catalog_SetPageLayout (pdf->catalog, layout);
if (ret != HPDF_OK)
HPDF_CheckError (&pdf->error);
return HPDF_OK;
}
HPDF_SetPageMode (HPDF_Doc pdf,
HPDF_PageMode mode)
{
HPDF_STATUS ret;
HPDF_PTRACE ((" HPDF_GetPageMode\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
if (mode < 0 || mode >= HPDF_PAGE_MODE_EOF)
return HPDF_RaiseError (&pdf->error, HPDF_PAGE_MODE_OUT_OF_RANGE,
(HPDF_STATUS)mode);
ret = HPDF_Catalog_SetPageMode (pdf->catalog, mode);
if (ret != HPDF_OK)
return HPDF_CheckError (&pdf->error);
return HPDF_OK;
}
HPDF_GetTTFontDefFromFile (HPDF_Doc pdf,
const char *file_name,
HPDF_BOOL embedding)
{
HPDF_Stream font_data;
HPDF_FontDef def;
HPDF_PTRACE ((" HPDF_GetTTFontDefFromFile\n"));
/* create file stream */
font_data = HPDF_FileReader_New (pdf->mmgr, file_name);
if (HPDF_Stream_Validate (font_data)) {
def = HPDF_TTFontDef_Load (pdf->mmgr, font_data, embedding);
} else {
HPDF_CheckError (&pdf->error);
return NULL;
}
return def;
}
HPDF_Page_Create3DView (HPDF_Page page,
HPDF_U3D u3d,
HPDF_Annotation annot3d,
const char *name)
{
HPDF_PageAttr attr;
HPDF_Dict view;
HPDF_PTRACE((" HPDF_Page_Create3DView\n"));
if (!HPDF_Page_Validate (page))
return NULL;
attr = (HPDF_PageAttr)page->attr;
view = HPDF_3DView_New( page->mmgr, attr->xref, u3d, name);
if (!view) {
HPDF_CheckError (page->error);
}
return view;
}
HPDF_LoadU3DFromMem (HPDF_Doc pdf,
const HPDF_BYTE *buffer,
HPDF_UINT size)
{
HPDF_Stream imagedata;
HPDF_Image image;
HPDF_PTRACE ((" HPDF_LoadU3DFromMem\n"));
if (!HPDF_HasDoc (pdf)) {
return NULL;
}
/* create file stream */
imagedata = HPDF_MemStream_New (pdf->mmgr, size);
if (!HPDF_Stream_Validate (imagedata)) {
HPDF_RaiseError (&pdf->error, HPDF_INVALID_STREAM, 0);
return NULL;
}
if (HPDF_Stream_Write (imagedata, buffer, size) != HPDF_OK) {
HPDF_Stream_Free (imagedata);
return NULL;
}
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_LinkAnnot_SetBorderStyle (HPDF_Annotation annot,
HPDF_REAL width,
HPDF_UINT16 dash_on,
HPDF_UINT16 dash_off)
{
HPDF_Array array;
HPDF_STATUS ret;
HPDF_PTRACE((" HPDF_LinkAnnot_SetBorderStyle\n"));
if (!CheckSubType (annot, HPDF_ANNOT_LINK))
return HPDF_INVALID_ANNOTATION;
if (width < 0)
return HPDF_RaiseError (annot->error, HPDF_INVALID_PARAMETER, 0);
array = HPDF_Array_New (annot->mmgr);
if (!array)
return HPDF_CheckError (annot->error);
if ((ret = HPDF_Dict_Add (annot, "Border", array)) != HPDF_OK)
return HPDF_CheckError (annot->error);
ret += HPDF_Array_AddNumber (array, 0);
ret += HPDF_Array_AddNumber (array, 0);
ret += HPDF_Array_AddReal (array, width);
if (ret != HPDF_OK)
return HPDF_CheckError (annot->error);
if (dash_on && dash_off) {
HPDF_Array dash = HPDF_Array_New (annot->mmgr);
if (!dash)
return HPDF_CheckError (annot->error);
if ((ret = HPDF_Array_Add (array, dash)) != HPDF_OK)
return HPDF_CheckError (annot->error);
ret += HPDF_Array_AddNumber (dash, dash_on);
ret += HPDF_Array_AddNumber (dash, dash_off);
if (ret != HPDF_OK)
return HPDF_CheckError (annot->error);
}
return HPDF_OK;
}
HPDF_LoadType1FontFromFile (HPDF_Doc pdf,
const char *afm_file_name,
const char *data_file_name)
{
HPDF_Stream afm;
HPDF_Stream pfm = NULL;
const char *ret;
HPDF_PTRACE ((" HPDF_LoadType1FontFromFile\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
/* create file stream */
afm = HPDF_FileReader_New (pdf->mmgr, afm_file_name);
if (data_file_name)
pfm = HPDF_FileReader_New (pdf->mmgr, data_file_name);
if (HPDF_Stream_Validate (afm) &&
(!data_file_name || HPDF_Stream_Validate (pfm))) {
ret = LoadType1FontFromStream (pdf, afm, pfm);
} else
ret = NULL;
/* destroy file stream */
if (afm)
HPDF_Stream_Free (afm);
if (pfm)
HPDF_Stream_Free (pfm);
if (!ret)
HPDF_CheckError (&pdf->error);
return ret;
}
HPDF_Page_CreatePD33DMeasure(HPDF_Page page,
HPDF_Point3D annotationPlaneNormal,
HPDF_Point3D firstAnchorPoint,
HPDF_Point3D secondAnchorPoint,
HPDF_Point3D leaderLinesDirection,
HPDF_Point3D measurementValuePoint,
HPDF_Point3D textYDirection,
HPDF_REAL value,
const char* unitsString
)
{
HPDF_PageAttr attr;
HPDF_Annotation measure;
HPDF_PTRACE((" HPDF_Page_CreatePD33DMeasure\n"));
if (!HPDF_Page_Validate (page))
return NULL;
attr = (HPDF_PageAttr)page->attr;
measure = HPDF_PD33DMeasure_New(page->mmgr,
attr->xref,
annotationPlaneNormal,
firstAnchorPoint,
secondAnchorPoint,
leaderLinesDirection,
measurementValuePoint,
textYDirection,
value,
unitsString
);
if ( !measure)
HPDF_CheckError (page->error);
return measure;
}
