HPDF_Page
HPDF_Page_New (HPDF_MMgr mmgr,
HPDF_Xref xref)
{
HPDF_STATUS ret;
HPDF_PageAttr attr;
HPDF_Page page;
HPDF_PTRACE((" HPDF_Page_New\n"));
page = HPDF_Dict_New (mmgr);
if (!page)
return NULL;
page->header.obj_class |= HPDF_OSUBCLASS_PAGE;
page->free_fn = Page_OnFree;
page->before_write_fn = Page_BeforeWrite;
attr = HPDF_GetMem (page->mmgr, sizeof(HPDF_PageAttr_Rec));
if (!attr) {
HPDF_Dict_Free (page);
return NULL;
}
page->attr = attr;
HPDF_MemSet (attr, 0, sizeof(HPDF_PageAttr_Rec));
attr->gmode = HPDF_GMODE_PAGE_DESCRIPTION;
attr->cur_pos = HPDF_ToPoint (0, 0);
attr->text_pos = HPDF_ToPoint (0, 0);
ret = HPDF_Xref_Add (xref, page);
if (ret != HPDF_OK)
return NULL;
attr->gstate = HPDF_GState_New (page->mmgr, NULL);
attr->contents = HPDF_DictStream_New (page->mmgr, xref);
if (!attr->gstate || !attr->contents)
return NULL;
attr->stream = attr->contents->stream;
attr->xref = xref;
/* add requiered elements */
ret += HPDF_Dict_AddName (page, "Type", "Page");
ret += HPDF_Dict_Add (page, "MediaBox", HPDF_Box_Array_New (page->mmgr,
HPDF_ToBox (0, 0, HPDF_DEF_PAGE_WIDTH, HPDF_DEF_PAGE_HEIGHT)));
ret += HPDF_Dict_Add (page, "Contents", attr->contents);
ret += AddResource (page);
if (ret != HPDF_OK)
return NULL;
return page;
}
const char*
HPDF_Page_GetLocalFontName (HPDF_Page page,
HPDF_Font font)
{
HPDF_PageAttr attr = (HPDF_PageAttr )page->attr;
const char *key;
HPDF_PTRACE((" HPDF_Page_GetLocalFontName\n"));
/* whether check font-resource exists. when it does not exists,
* create font-resource
* 2006.07.21 Fixed a problem which may cause a memory leak.
*/
if (!attr->fonts) {
HPDF_Dict resources;
HPDF_Dict fonts;
resources = HPDF_Page_GetInheritableItem (page, "Resources",
HPDF_OCLASS_DICT);
if (!resources)
return NULL;
fonts = HPDF_Dict_New (page->mmgr);
if (!fonts)
return NULL;
if (HPDF_Dict_Add (resources, "Font", fonts) != HPDF_OK)
return NULL;
attr->fonts = fonts;
}
/* search font-object from font-resource */
key = HPDF_Dict_GetKeyByObj (attr->fonts, font);
if (!key) {
/* if the font is not resisterd in font-resource, register font to
* font-resource.
*/
char fontName[HPDF_LIMIT_MAX_NAME_LEN + 1];
char *ptr;
char *end_ptr = fontName + HPDF_LIMIT_MAX_NAME_LEN;
ptr = (char *)HPDF_StrCpy (fontName, "F", end_ptr);
HPDF_IToA (ptr, attr->fonts->list->count + 1, end_ptr);
if (HPDF_Dict_Add (attr->fonts, fontName, font) != HPDF_OK)
return NULL;
key = HPDF_Dict_GetKeyByObj (attr->fonts, font);
}
return key;
}
static HPDF_STATUS
PrepareTrailer (HPDF_Doc pdf)
{
HPDF_PTRACE ((" PrepareTrailer\n"));
if (HPDF_Dict_Add (pdf->trailer, "Root", pdf->catalog) != HPDF_OK)
return pdf->error.error_no;
if (HPDF_Dict_Add (pdf->trailer, "Info", pdf->info) != HPDF_OK)
return pdf->error.error_no;
return HPDF_OK;
}
const char*
HPDF_Page_GetXObjectName (HPDF_Page page,
HPDF_XObject xobj)
{
HPDF_PageAttr attr = (HPDF_PageAttr )page->attr;
const char *key;
HPDF_PTRACE((" HPDF_Page_GetXObjectName\n"));
if (!attr->xobjects) {
HPDF_Dict resources;
HPDF_Dict xobjects;
resources = HPDF_Page_GetInheritableItem (page, "Resources",
HPDF_OCLASS_DICT);
if (!resources)
return NULL;
xobjects = HPDF_Dict_New (page->mmgr);
if (!xobjects)
return NULL;
if (HPDF_Dict_Add (resources, "XObject", xobjects) != HPDF_OK)
return NULL;
attr->xobjects = xobjects;
}
/* search xobject-object from xobject-resource */
key = HPDF_Dict_GetKeyByObj (attr->xobjects, xobj);
if (!key) {
/* if the xobject is not resisterd in xobject-resource, register
* xobject to xobject-resource.
*/
char xobj_name[HPDF_LIMIT_MAX_NAME_LEN + 1];
char *ptr;
char *end_ptr = xobj_name + HPDF_LIMIT_MAX_NAME_LEN;
ptr = (char *)HPDF_StrCpy (xobj_name, "X", end_ptr);
HPDF_IToA (ptr, attr->xobjects->list->count + 1, end_ptr);
if (HPDF_Dict_Add (attr->xobjects, xobj_name, xobj) != HPDF_OK)
return NULL;
key = HPDF_Dict_GetKeyByObj (attr->xobjects, xobj);
}
return key;
}
const char*
HPDF_Page_GetExtGStateName (HPDF_Page page,
HPDF_ExtGState state)
{
HPDF_PageAttr attr = (HPDF_PageAttr )page->attr;
const char *key;
HPDF_PTRACE((" HPDF_Page_GetExtGStateName\n"));
if (!attr->ext_gstates) {
HPDF_Dict resources;
HPDF_Dict ext_gstates;
resources = HPDF_Page_GetInheritableItem (page, "Resources",
HPDF_OCLASS_DICT);
if (!resources)
return NULL;
ext_gstates = HPDF_Dict_New (page->mmgr);
if (!ext_gstates)
return NULL;
if (HPDF_Dict_Add (resources, "ExtGState", ext_gstates) != HPDF_OK)
return NULL;
attr->ext_gstates = ext_gstates;
}
/* search ext_gstate-object from ext_gstate-resource */
key = HPDF_Dict_GetKeyByObj (attr->ext_gstates, state);
if (!key) {
/* if the ext-gstate is not resisterd in ext-gstate resource, register
* to ext-gstate resource.
*/
char ext_gstate_name[HPDF_LIMIT_MAX_NAME_LEN + 1];
char *ptr;
char *end_ptr = ext_gstate_name + HPDF_LIMIT_MAX_NAME_LEN;
ptr = (char *)HPDF_StrCpy (ext_gstate_name, "E", end_ptr);
HPDF_IToA (ptr, attr->ext_gstates->list->count + 1, end_ptr);
if (HPDF_Dict_Add (attr->ext_gstates, ext_gstate_name, state) != HPDF_OK)
return NULL;
key = HPDF_Dict_GetKeyByObj (attr->ext_gstates, state);
}
return key;
}
HPDF_STATUS
HPDF_EncryptDict_Prepare (HPDF_EncryptDict dict,
HPDF_Dict info,
HPDF_Xref xref)
{
HPDF_STATUS ret;
HPDF_Encrypt attr = (HPDF_Encrypt)dict->attr;
HPDF_Binary user_key;
HPDF_Binary owner_key;
HPDF_PTRACE((" HPDF_EncryptDict_Prepare\n"));
HPDF_EncryptDict_CreateID (dict, info, xref);
HPDF_Encrypt_CreateOwnerKey (attr);
HPDF_Encrypt_CreateEncryptionKey (attr);
HPDF_Encrypt_CreateUserKey (attr);
owner_key = HPDF_Binary_New (dict->mmgr, attr->owner_key, HPDF_PASSWD_LEN);
if (!owner_key)
return HPDF_Error_GetCode (dict->error);
if ((ret = HPDF_Dict_Add (dict, "O", owner_key)) != HPDF_OK)
return ret;
user_key = HPDF_Binary_New (dict->mmgr, attr->user_key, HPDF_PASSWD_LEN);
if (!user_key)
return HPDF_Error_GetCode (dict->error);
if ((ret = HPDF_Dict_Add (dict, "U", user_key)) != HPDF_OK)
return ret;
ret += HPDF_Dict_AddName (dict, "Filter", "Standard");
if (attr->mode == HPDF_ENCRYPT_R2) {
ret += HPDF_Dict_AddNumber (dict, "V", 1);
ret += HPDF_Dict_AddNumber (dict, "R", 2);
} else if (attr->mode == HPDF_ENCRYPT_R3) {
ret += HPDF_Dict_AddNumber (dict, "V", 2);
ret += HPDF_Dict_AddNumber (dict, "R", 3);
ret += HPDF_Dict_AddNumber (dict, "Length", attr->key_len * 8);
}
ret += HPDF_Dict_AddNumber (dict, "P", attr->permission);
if (ret != HPDF_OK)
return HPDF_Error_GetCode (dict->error);
return HPDF_OK;
}
HPDF_STATUS
HPDF_Image_SetMask (HPDF_Image image,
HPDF_BOOL mask)
{
HPDF_Boolean image_mask;
if (!HPDF_Image_Validate (image))
return HPDF_INVALID_IMAGE;
if (mask && HPDF_Image_GetBitsPerComponent (image) != 1)
return HPDF_SetError (image->error, HPDF_INVALID_BIT_PER_COMPONENT,
0);
image_mask = HPDF_Dict_GetItem (image, "ImageMask", HPDF_OCLASS_BOOLEAN);
if (!image_mask) {
HPDF_STATUS ret;
image_mask = HPDF_Boolean_New (image->mmgr, HPDF_FALSE);
if ((ret = HPDF_Dict_Add (image, "ImageMask", image_mask)) != HPDF_OK)
return ret;
}
image_mask->value = mask;
return HPDF_OK;
}
HPDF_TextMarkupAnnot_SetQuadPoints ( HPDF_Annotation annot, HPDF_Point lb, HPDF_Point rb, HPDF_Point lt, HPDF_Point rt) /* l-left, r-right, b-bottom, t-top positions */
{
HPDF_Array quadPoints;
HPDF_STATUS ret = HPDF_OK;
HPDF_PTRACE((" HPDF_TextMarkupAnnot_SetQuadPoints\n"));
quadPoints = HPDF_Array_New ( annot->mmgr);
if ( !quadPoints)
return HPDF_Error_GetCode ( annot->error);
if ((ret = HPDF_Dict_Add ( annot, "QuadPoints", quadPoints)) != HPDF_OK)
return ret;
ret += HPDF_Array_AddReal (quadPoints, lb.x);
ret += HPDF_Array_AddReal (quadPoints, lb.y);
ret += HPDF_Array_AddReal (quadPoints, rb.x);
ret += HPDF_Array_AddReal (quadPoints, rb.y);
ret += HPDF_Array_AddReal (quadPoints, lt.x);
ret += HPDF_Array_AddReal (quadPoints, lt.y);
ret += HPDF_Array_AddReal (quadPoints, rt.x);
ret += HPDF_Array_AddReal (quadPoints, rt.y);
if (ret != HPDF_OK)
return HPDF_Error_GetCode (quadPoints->error);
return HPDF_OK;
}
HPDF_Annotation
HPDF_StampAnnot_New (HPDF_MMgr mmgr,
HPDF_Xref xref,
HPDF_Rect rect,
HPDF_StampAnnotName name,
const char* text,
HPDF_Encoder encoder)
{
HPDF_Annotation annot;
HPDF_String s;
HPDF_PTRACE((" HPDF_StampAnnot_New\n"));
annot = HPDF_Annotation_New (mmgr, xref, HPDF_ANNOT_STAMP, rect);
if (!annot)
return NULL;
if (HPDF_Dict_AddName ( annot, "Name", HPDF_STAMP_ANNOT_NAME_NAMES[name]) != HPDF_OK)
return NULL;
s = HPDF_String_New (mmgr, text, encoder);
if (!s)
return NULL;
if (HPDF_Dict_Add (annot, "Contents", s) != HPDF_OK)
return NULL;
return annot;
}
HPDF_MarkupAnnot_SetPopup (HPDF_Annotation annot,
HPDF_Annotation popup)
{
HPDF_PTRACE((" HPDF_MarkupAnnot_SetPopup\n"));
return HPDF_Dict_Add( annot, "Popup", popup);
}
HPDF_STATUS
Pages_BeforeWrite (HPDF_Dict obj)
{
HPDF_Array kids = (HPDF_Array )HPDF_Dict_GetItem (obj, "Kids",
HPDF_OCLASS_ARRAY);
HPDF_Number count = (HPDF_Number)HPDF_Dict_GetItem (obj, "Count",
HPDF_OCLASS_NUMBER);
HPDF_STATUS ret;
HPDF_PTRACE((" HPDF_Pages_BeforeWrite\n"));
if (!kids)
return HPDF_SetError (obj->error, HPDF_PAGES_MISSING_KIDS_ENTRY, 0);
if (count)
count->value = GetPageCount (obj);
else {
count = HPDF_Number_New (obj->mmgr, GetPageCount (obj));
if (!count)
return HPDF_Error_GetCode (obj->error);
if ((ret = HPDF_Dict_Add (obj, "Count", count)) != HPDF_OK)
return ret;
}
return HPDF_OK;
}
HPDF_LineAnnot_SetCaption (HPDF_Annotation annot, HPDF_BOOL showCaption, HPDF_LineAnnotCapPosition position, HPDF_INT horzOffset, HPDF_INT vertOffset)
{
HPDF_STATUS ret = HPDF_OK;
HPDF_Array capOffset;
HPDF_PTRACE((" HPDF_LineAnnot_SetCaption\n"));
ret += HPDF_Dict_AddBoolean ( annot, "Cap", showCaption);
ret += HPDF_Dict_AddName( annot, "CP", HPDF_LINE_ANNOT_CAP_POSITION_NAMES[(HPDF_INT)position]);
if (ret != HPDF_OK)
return HPDF_Error_GetCode ( annot->error);
capOffset = HPDF_Array_New ( annot->mmgr);
if ( !capOffset)
return HPDF_Error_GetCode ( annot->error);
if ((ret = HPDF_Dict_Add ( annot, "CO", capOffset)) != HPDF_OK)
return ret;
ret += HPDF_Array_AddNumber (capOffset, horzOffset);
ret += HPDF_Array_AddNumber (capOffset, vertOffset);
if (ret != HPDF_OK)
return HPDF_Error_GetCode (capOffset->error);
return HPDF_OK;
}
HPDF_FreeTextAnnot_Set3PointCalloutLine ( HPDF_Annotation annot, HPDF_Point startPoint, HPDF_Point kneePoint, HPDF_Point endPoint) /* Callout line will be in default user space */
{
HPDF_Array clPoints;
HPDF_STATUS ret = HPDF_OK;
HPDF_PTRACE((" HPDF_FreeTextAnnot_Set3PointCalloutLine\n"));
clPoints = HPDF_Array_New ( annot->mmgr);
if ( !clPoints)
return HPDF_Error_GetCode ( annot->error);
if ((ret = HPDF_Dict_Add ( annot, "CL", clPoints)) != HPDF_OK)
return ret;
ret += HPDF_Array_AddReal (clPoints, startPoint.x);
ret += HPDF_Array_AddReal (clPoints, startPoint.y);
ret += HPDF_Array_AddReal (clPoints, kneePoint.x);
ret += HPDF_Array_AddReal (clPoints, kneePoint.y);
ret += HPDF_Array_AddReal (clPoints, endPoint.x);
ret += HPDF_Array_AddReal (clPoints, endPoint.y);
if (ret != HPDF_OK)
return HPDF_Error_GetCode (clPoints->error);
return HPDF_OK;
}
HPDF_MarkupAnnot_SetRectDiff (HPDF_Annotation annot, HPDF_Rect rect) /* RD entry : this is the difference between Rect and the text annotation rectangle */
{
HPDF_Array array;
HPDF_STATUS ret = HPDF_OK;
HPDF_REAL tmp;
HPDF_PTRACE((" HPDF_MarkupAnnot_SetRectDiff\n"));
array = HPDF_Array_New ( annot->mmgr);
if ( !array)
return HPDF_Error_GetCode ( annot->error);
if ((ret = HPDF_Dict_Add ( annot, "RD", array)) != HPDF_OK)
return ret;
if (rect.top < rect.bottom) {
tmp = rect.top;
rect.top = rect.bottom;
rect.bottom = tmp;
}
ret += HPDF_Array_AddReal (array, rect.left);
ret += HPDF_Array_AddReal (array, rect.bottom);
ret += HPDF_Array_AddReal (array, rect.right);
ret += HPDF_Array_AddReal (array, rect.top);
if (ret != HPDF_OK)
return HPDF_Error_GetCode (array->error);
return HPDF_OK;
}
/* Generate an ID for the trailer dict, PDF/A needs this.
TODO: Better algorithm for generate unique ID.
*/
HPDF_STATUS
HPDF_PDFA_GenerateID(HPDF_Doc pdf)
{
HPDF_Array id;
HPDF_BYTE *currentTime;
HPDF_BYTE idkey[HPDF_MD5_KEY_LEN];
HPDF_MD5_CTX md5_ctx;
time_t ltime;
ltime = time(NULL);
currentTime = (HPDF_BYTE *)ctime(<ime);
id = HPDF_Dict_GetItem(pdf->trailer, "ID", HPDF_OCLASS_ARRAY);
if (!id) {
id = HPDF_Array_New(pdf->mmgr);
if (!id || HPDF_Dict_Add(pdf->trailer, "ID", id) != HPDF_OK)
return pdf->error.error_no;
HPDF_MD5Init(&md5_ctx);
HPDF_MD5Update(&md5_ctx, (HPDF_BYTE *) "libHaru", sizeof("libHaru") - 1);
HPDF_MD5Update(&md5_ctx, currentTime, HPDF_StrLen((const char *)currentTime, -1));
HPDF_MD5Final(idkey, &md5_ctx);
if (HPDF_Array_Add (id, HPDF_Binary_New (pdf->mmgr, idkey, HPDF_MD5_KEY_LEN)) != HPDF_OK)
return pdf->error.error_no;
if (HPDF_Array_Add (id, HPDF_Binary_New (pdf->mmgr,idkey,HPDF_MD5_KEY_LEN)) != HPDF_OK)
return pdf->error.error_no;
return HPDF_OK;
}
return HPDF_OK;
}
HPDF_STATUS
HPDF_Pages_AddKids (HPDF_Pages parent,
HPDF_Dict kid)
{
HPDF_Array kids;
HPDF_STATUS ret;
HPDF_PTRACE((" HPDF_Pages_AddKids\n"));
if (HPDF_Dict_GetItem (kid, "Parent", HPDF_OCLASS_DICT))
return HPDF_SetError (parent->error, HPDF_PAGE_CANNOT_SET_PARENT, 0);
if ((ret = HPDF_Dict_Add (kid, "Parent", parent)) != HPDF_OK)
return ret;
kids = (HPDF_Array )HPDF_Dict_GetItem (parent, "Kids", HPDF_OCLASS_ARRAY);
if (!kids)
return HPDF_SetError (parent->error, HPDF_PAGES_MISSING_KIDS_ENTRY, 0);
if (kid->header.obj_class == (HPDF_OCLASS_DICT | HPDF_OSUBCLASS_PAGE)) {
HPDF_PageAttr attr = (HPDF_PageAttr)kid->attr;
attr->parent = parent;
}
return HPDF_Array_Add (kids, kid);
}
HPDF_STATUS
HPDF_Page_InsertBefore (HPDF_Page page,
HPDF_Page target)
{
HPDF_Page parent;
HPDF_Array kids;
HPDF_STATUS ret;
HPDF_PageAttr attr;
HPDF_PTRACE((" HPDF_Page_InsertBefore\n"));
if (!target)
return HPDF_INVALID_PARAMETER;
attr = (HPDF_PageAttr )target->attr;
parent = attr->parent;
if (!parent)
return HPDF_PAGE_CANNOT_SET_PARENT;
if (HPDF_Dict_GetItem (page, "Parent", HPDF_OCLASS_DICT))
return HPDF_SetError (parent->error, HPDF_PAGE_CANNOT_SET_PARENT, 0);
if ((ret = HPDF_Dict_Add (page, "Parent", parent)) != HPDF_OK)
return ret;
kids = (HPDF_Array )HPDF_Dict_GetItem (parent, "Kids", HPDF_OCLASS_ARRAY);
if (!kids)
return HPDF_SetError (parent->error, HPDF_PAGES_MISSING_KIDS_ENTRY, 0);
attr = (HPDF_PageAttr)page->attr;
attr->parent = parent;
return HPDF_Array_Insert (kids, target, page);
}
HPDF_Annotation
HPDF_MarkupAnnot_New (HPDF_MMgr mmgr,
HPDF_Xref xref,
HPDF_Rect rect,
const char *text,
HPDF_Encoder encoder,
HPDF_AnnotType subtype)
{
HPDF_Annotation annot;
HPDF_String s;
HPDF_PTRACE((" HPDF_MarkupAnnot_New\n"));
annot = HPDF_Annotation_New (mmgr, xref, subtype, rect);
if (!annot)
return NULL;
s = HPDF_String_New (mmgr, text, encoder);
if (!s)
return NULL;
if (HPDF_Dict_Add (annot, "Contents", s) != HPDF_OK)
return NULL;
return annot;
}
HPDF_3DView_Add3DC3DMeasure(HPDF_Dict view,
HPDF_3DMeasure measure)
{
HPDF_STATUS ret = HPDF_OK;
HPDF_Array array;
void* a;
a = HPDF_Dict_GetItem (view, "MA", HPDF_OCLASS_ARRAY);
if ( a )
{
array = (HPDF_Array)a;
}
else
{
array = HPDF_Array_New (view->mmgr);
if (!array)
return 0;
if (HPDF_Dict_Add (view, "MA", array) != HPDF_OK)
return 0;
}
ret = HPDF_Array_Add(array, measure);
return ret;
}
HPDF_EXPORT(HPDF_STATUS) HPDF_U3D_Add3DView(HPDF_U3D u3d, HPDF_Dict view)
{
HPDF_Array views = NULL;
HPDF_STATUS ret = HPDF_OK;
HPDF_PTRACE ((" HPDF_Add3DView\n"));
if (u3d == NULL || view == NULL) {
return HPDF_INVALID_U3D_DATA;
}
views = (HPDF_Array)HPDF_Dict_GetItem (u3d, "VA", HPDF_OCLASS_ARRAY);
if (views == NULL) {
views = HPDF_Array_New (u3d->mmgr);
if (!views) {
return HPDF_Error_GetCode (u3d->error);
}
ret = HPDF_Dict_Add (u3d, "VA", views);
if (ret == HPDF_OK) {
ret = HPDF_Dict_AddNumber (u3d, "DV", 0);
} else {
HPDF_Array_Free (views);
return ret;
}
}
if (ret == HPDF_OK) {
ret = HPDF_Array_Add( views, view);
}
return ret;
}
HPDF_EXPORT(HPDF_STATUS) HPDF_3DView_SetOrthogonalProjection(HPDF_Dict view, HPDF_REAL mag)
{
HPDF_STATUS ret = HPDF_OK;
HPDF_Dict projection;
HPDF_PTRACE ((" HPDF_3DView_SetOrthogonalProjection\n"));
if (view == NULL || mag <= 0) {
return HPDF_INVALID_U3D_DATA;
}
projection = HPDF_Dict_New (view->mmgr);
if (!projection) {
return HPDF_Error_GetCode (view->error);
}
ret = HPDF_Dict_AddName (projection, "Subtype", "O");
if (ret != HPDF_OK) {
HPDF_Dict_Free (projection);
return ret;
}
ret = HPDF_Dict_AddReal (projection, "OS", mag);
if (ret != HPDF_OK) {
HPDF_Dict_Free (projection);
return ret;
}
ret = HPDF_Dict_Add (view, "P", projection);
if (ret != HPDF_OK) {
HPDF_Dict_Free (projection);
return ret;
}
return ret;
}
HPDF_STATUS
HPDF_NameDict_SetNameTree (HPDF_NameDict namedict,
HPDF_NameDictKey key,
HPDF_NameTree ntree)
{
return HPDF_Dict_Add (namedict, HPDF_NAMEDICT_KEYS[key], ntree);
}
HPDF_NameTree
HPDF_NameTree_New (HPDF_MMgr mmgr,
HPDF_Xref xref)
{
HPDF_STATUS ret = HPDF_OK;
HPDF_NameTree ntree;
HPDF_Array items;
HPDF_PTRACE (" HPDF_NameTree_New\n");
ntree = HPDF_Dict_New (mmgr);
if (!ntree)
return NULL;
if (HPDF_Xref_Add (xref, ntree) != HPDF_OK)
return NULL;
ntree->header.obj_class |= HPDF_OSUBCLASS_NAMETREE;
items = HPDF_Array_New (mmgr);
if (!ntree)
return NULL;
ret += HPDF_Dict_Add (ntree, "Names", items);
if (ret != HPDF_OK)
return NULL;
return ntree;
}
HPDF_Catalog
HPDF_Catalog_New (HPDF_MMgr mmgr,
HPDF_Xref xref)
{
HPDF_Catalog catalog;
HPDF_STATUS ret = 0;
catalog = HPDF_Dict_New (mmgr);
if (!catalog)
return NULL;
catalog->header.obj_class |= HPDF_OSUBCLASS_CATALOG;
if (HPDF_Xref_Add (xref, catalog) != HPDF_OK)
return NULL;
/* add requiered elements */
ret += HPDF_Dict_AddName (catalog, "Type", "Catalog");
ret += HPDF_Dict_Add (catalog, "Pages", HPDF_Pages_New (mmgr, NULL, xref));
if (ret != HPDF_OK)
return NULL;
return catalog;
}
HPDF_EmbeddedFile
HPDF_EmbeddedFile_New (HPDF_MMgr mmgr,
HPDF_Xref xref,
const char *file)
{
HPDF_STATUS ret = HPDF_OK;
HPDF_Dict ef; /* the dictionary for the embedded file: /Type /EF */
HPDF_String name; /* the name of the file: /F (name) */
HPDF_Dict eff; /* ef has an /EF <<blah>> key - this is it */
HPDF_Dict filestream; /* the stream that /EF <</F _ _ R>> refers to */
HPDF_Stream stream;
ef = HPDF_Dict_New (mmgr);
if (!ef)
return NULL;
if (HPDF_Xref_Add (xref, ef) != HPDF_OK)
return NULL;
filestream = HPDF_DictStream_New (mmgr, xref);
if (!filestream)
return NULL;
stream = HPDF_FileReader_New (mmgr, file);
if (!stream)
return NULL;
HPDF_Stream_Free(filestream->stream);
filestream->stream = stream;
filestream->filter = HPDF_STREAM_FILTER_FLATE_DECODE;
eff = HPDF_Dict_New (mmgr);
if (!eff)
return NULL;
name = HPDF_String_New (mmgr, file, NULL);
if (!name)
return NULL;
ret += HPDF_Dict_AddName (ef, "Type", "F");
ret += HPDF_Dict_Add (ef, "F", name);
ret += HPDF_Dict_Add (ef, "EF", eff);
ret += HPDF_Dict_Add (eff, "F", filestream);
if (ret != HPDF_OK)
return NULL;
return ef;
}
HPDF_ProjectionAnnot_SetExData(HPDF_Annotation annot, HPDF_ExData exdata)
{
HPDF_STATUS ret = HPDF_OK;
ret = HPDF_Dict_Add(annot, "ExData", exdata);
return ret;
}
HPDF_Dict HPDF_3DView_New( HPDF_MMgr mmgr, HPDF_Xref xref, HPDF_U3D u3d, const char *name)
{
HPDF_STATUS ret = HPDF_OK;
HPDF_Dict view;
HPDF_PTRACE ((" HPDF_3DView_New\n"));
if (name == NULL || name[0] == '\0') {
return NULL;
}
view = HPDF_Dict_New (mmgr);
if (!view) {
return NULL;
}
if (HPDF_Xref_Add (xref, view) != HPDF_OK)
return NULL;
ret = HPDF_Dict_AddName (view, "TYPE", "3DView");
if (ret != HPDF_OK) {
HPDF_Dict_Free (view);
return NULL;
}
ret = HPDF_Dict_Add (view, "XN", HPDF_String_New (mmgr, name, NULL));
if (ret != HPDF_OK) {
HPDF_Dict_Free (view);
return NULL;
}
ret = HPDF_Dict_Add (view, "IN", HPDF_String_New (mmgr, name, NULL));
if (ret != HPDF_OK) {
HPDF_Dict_Free (view);
return NULL;
}
ret = HPDF_U3D_Add3DView( u3d, view);
if (ret != HPDF_OK) {
HPDF_Dict_Free (view);
return NULL;
}
return view;
}
HPDF_STATUS
HPDF_Image_SetColorSpace (HPDF_Image image,
HPDF_Array colorspace)
{
if (!HPDF_Image_Validate (image))
return HPDF_INVALID_IMAGE;
return HPDF_Dict_Add (image, "ColorSpace", colorspace);
}
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_Annot_Set3DView ( HPDF_MMgr mmgr,
HPDF_Annotation annot,
HPDF_Annotation annot3d,
HPDF_Dict view3d)
{
HPDF_Proxy proxyView3d;
HPDF_Dict exData = HPDF_Dict_New( mmgr);
HPDF_STATUS retS = HPDF_OK;
retS += HPDF_Dict_AddName( exData, "Type", "ExData");
retS += HPDF_Dict_AddName( exData, "Subtype", "Markup3D");
retS += HPDF_Dict_Add( exData, "3DA", annot3d);
proxyView3d = HPDF_Proxy_New( mmgr, view3d);
retS += HPDF_Dict_Add( exData, "3DV", proxyView3d);
retS += HPDF_Dict_Add( annot, "ExData", exData);
return retS;
}
