HPDF_LinkAnnot_SetJavaScript(HPDF_Annotation annot, HPDF_JavaScript javascript) { HPDF_Dict action; HPDF_STATUS ret; HPDF_PTRACE((" HPDF_LinkAnnot_SetJavaScript\n")); if (!CheckSubType (annot, HPDF_ANNOT_LINK)) return HPDF_INVALID_ANNOTATION; /* create action dictionary */ action = HPDF_Dict_New (annot->mmgr); if (!action) return HPDF_CheckError ( annot->error); ret = HPDF_Dict_Add (annot, "A", action); if (ret != HPDF_OK) return HPDF_CheckError (annot->error); ret += HPDF_Dict_Add (action, "JS", javascript); ret += HPDF_Dict_AddName (action, "S", "JavaScript"); if (ret != HPDF_OK) return HPDF_CheckError (annot->error); return HPDF_OK; }
HPDF_Pages HPDF_Pages_New (HPDF_MMgr mmgr, HPDF_Pages parent, HPDF_Xref xref) { HPDF_STATUS ret = HPDF_OK; HPDF_Pages pages; HPDF_PTRACE((" HPDF_Pages_New\n")); pages = HPDF_Dict_New (mmgr); if (!pages) return NULL; pages->header.obj_class |= HPDF_OSUBCLASS_PAGES; pages->before_write_fn = Pages_BeforeWrite; if (HPDF_Xref_Add (xref, pages) != HPDF_OK) return NULL; /* add requiered elements */ ret += HPDF_Dict_AddName (pages, "Type", "Pages"); ret += HPDF_Dict_Add (pages, "Kids", HPDF_Array_New (pages->mmgr)); ret += HPDF_Dict_Add (pages, "Count", HPDF_Number_New (pages->mmgr, 0)); if (ret == HPDF_OK && parent) ret += HPDF_Pages_AddKids (parent, pages); if (ret != HPDF_OK) return NULL; return pages; }
HPDF_Annotation HPDF_URILinkAnnot_New (HPDF_MMgr mmgr, HPDF_Xref xref, HPDF_Rect rect, const char *uri) { HPDF_Annotation annot; HPDF_Dict action; HPDF_STATUS ret; HPDF_PTRACE((" HPDF_URILinkAnnot_New\n")); annot = HPDF_Annotation_New (mmgr, xref, HPDF_ANNOT_LINK, rect); if (!annot) return NULL; /* create action dictionary */ action = HPDF_Dict_New (mmgr); if (!action) return NULL; ret = HPDF_Dict_Add (annot, "A", action); if (ret != HPDF_OK) return NULL; ret += HPDF_Dict_AddName (action, "Type", "Action"); ret += HPDF_Dict_AddName (action, "S", "URI"); ret += HPDF_Dict_Add (action, "URI", HPDF_String_New (mmgr, uri, NULL)); if (ret != HPDF_OK) return NULL; return annot; }
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_ExData HPDF_3DAnnotExData_New(HPDF_MMgr mmgr, HPDF_Xref xref) { HPDF_ExData exdata; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE (" HPDF_ExData_New\n"); exdata = HPDF_Dict_New (mmgr); if (!exdata) return NULL; if (HPDF_Xref_Add (xref, exdata) != HPDF_OK) return NULL; ret += HPDF_Dict_AddName (exdata, "Type", "ExData"); ret += HPDF_Dict_AddName (exdata, "Subtype", "3DM"); if (ret != HPDF_OK) return NULL; return exdata; }
HPDF_EncryptDict HPDF_EncryptDict_New (HPDF_MMgr mmgr, HPDF_Xref xref) { HPDF_Encrypt attr; HPDF_EncryptDict dict; HPDF_PTRACE((" HPDF_EncryptDict_New\n")); dict = HPDF_Dict_New (mmgr); if (!dict) return NULL; dict->header.obj_class |= HPDF_OSUBCLASS_ENCRYPT; dict->free_fn = HPDF_EncryptDict_OnFree; attr = HPDF_GetMem (dict->mmgr, sizeof(HPDF_Encrypt_Rec)); if (!attr) { HPDF_Dict_Free (dict); return NULL; } dict->attr = attr; HPDF_Encrypt_Init (attr); if (HPDF_Xref_Add (xref, dict) != HPDF_OK) return NULL; return dict; }
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 AddResource (HPDF_Page page) { HPDF_STATUS ret = HPDF_OK; HPDF_Dict resource; HPDF_Array procset; HPDF_PTRACE((" HPDF_Page_AddResource\n")); resource = HPDF_Dict_New (page->mmgr); if (!resource) return HPDF_Error_GetCode (page->error); /* althoth ProcSet-entry is obsolete, add it to resouce for * compatibility */ ret += HPDF_Dict_Add (page, "Resources", resource); procset = HPDF_Array_New (page->mmgr); if (!procset) return HPDF_Error_GetCode (page->error); ret += HPDF_Dict_Add (resource, "ProcSet", procset); ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "PDF")); ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "Text")); ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "ImageB")); ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "ImageC")); ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "ImageI")); return ret; }
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_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_INT16)(HPDF_DEF_PAGE_WIDTH), (HPDF_INT16)(HPDF_DEF_PAGE_HEIGHT)))); ret += HPDF_Dict_Add (page, "Contents", attr->contents); ret += AddResource (page); if (ret != HPDF_OK) return NULL; return page; }
HPDF_Xref HPDF_Xref_New (HPDF_MMgr mmgr, HPDF_UINT32 offset) { HPDF_Xref xref; HPDF_XrefEntry new_entry; HPDF_PTRACE((" HPDF_Xref_New\n")); xref = (HPDF_Xref)HPDF_GetMem (mmgr, sizeof(HPDF_Xref_Rec)); if (!xref) return NULL; HPDF_MemSet (xref, 0, sizeof(HPDF_Xref_Rec)); xref->mmgr = mmgr; xref->error = mmgr->error; xref->start_offset = offset; xref->entries = HPDF_List_New (mmgr, HPDF_DEFALUT_XREF_ENTRY_NUM); if (!xref->entries) goto Fail; xref->addr = 0; if (xref->start_offset == 0) { new_entry = (HPDF_XrefEntry)HPDF_GetMem (mmgr, sizeof(HPDF_XrefEntry_Rec)); if (!new_entry) goto Fail; if (HPDF_List_Add (xref->entries, new_entry) != HPDF_OK) { HPDF_FreeMem (mmgr, new_entry); goto Fail; } /* add first entry which is free entry and whose generation * number is 0 */ new_entry->entry_typ = HPDF_FREE_ENTRY; new_entry->byte_offset = 0; new_entry->gen_no = HPDF_MAX_GENERATION_NUM; new_entry->obj = NULL; } xref->trailer = HPDF_Dict_New (mmgr); if (!xref->trailer) goto Fail; return xref; Fail: HPDF_PTRACE((" HPDF_Xref_New failed\n")); HPDF_Xref_Free (xref); return NULL; }
HPDF_Dict HPDF_PageLabel_New (HPDF_Doc pdf, HPDF_PageNumStyle style, HPDF_INT first_page, const char *prefix) { HPDF_Dict obj = HPDF_Dict_New (pdf->mmgr); HPDF_PTRACE ((" HPDF_PageLabel_New\n")); if (!obj) return NULL; switch (style) { case HPDF_PAGE_NUM_STYLE_DECIMAL: if (HPDF_Dict_AddName (obj, "S", "D") != HPDF_OK) goto Fail; break; case HPDF_PAGE_NUM_STYLE_UPPER_ROMAN: if (HPDF_Dict_AddName (obj, "S", "R") != HPDF_OK) goto Fail; break; case HPDF_PAGE_NUM_STYLE_LOWER_ROMAN: if (HPDF_Dict_AddName (obj, "S", "r") != HPDF_OK) goto Fail; break; case HPDF_PAGE_NUM_STYLE_UPPER_LETTERS: if (HPDF_Dict_AddName (obj, "S", "A") != HPDF_OK) goto Fail; break; case HPDF_PAGE_NUM_STYLE_LOWER_LETTERS: if (HPDF_Dict_AddName (obj, "S", "a") != HPDF_OK) goto Fail; break; default: HPDF_SetError (&pdf->error, HPDF_PAGE_NUM_STYLE_OUT_OF_RANGE, (HPDF_STATUS)style); goto Fail; } if (prefix && prefix[0] != 0) if (HPDF_Dict_Add (obj, "P", HPDF_String_New (pdf->mmgr, prefix, pdf->def_encoder)) != HPDF_OK) goto Fail; if (first_page != 0) if (HPDF_Dict_AddNumber (obj, "St", first_page) != HPDF_OK) goto Fail; return obj; Fail: HPDF_Dict_Free (obj); return NULL; }
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; }
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_Annotation HPDF_Annotation_New (HPDF_MMgr mmgr, HPDF_Xref xref, HPDF_AnnotType type, HPDF_Rect rect) { HPDF_Annotation annot; HPDF_Array array; HPDF_STATUS ret = HPDF_OK; HPDF_REAL tmp; HPDF_PTRACE((" HPDF_Annotation_New\n")); annot = HPDF_Dict_New (mmgr); if (!annot) return NULL; if (HPDF_Xref_Add (xref, annot) != HPDF_OK) return NULL; array = HPDF_Array_New (mmgr); if (!array) return NULL; if (HPDF_Dict_Add (annot, "Rect", array) != HPDF_OK) return NULL; 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); ret += HPDF_Dict_AddName (annot, "Type", "Annot"); ret += HPDF_Dict_AddName (annot, "Subtype", HPDF_ANNOT_TYPE_NAMES[(HPDF_INT)type]); if (ret != HPDF_OK) return NULL; annot->header.obj_class |= HPDF_OSUBCLASS_ANNOTATION; return annot; }
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; }
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_EXPORT(HPDF_STATUS) HPDF_3DView_SetLighting(HPDF_Dict view, const char *scheme) { HPDF_STATUS ret = HPDF_OK; HPDF_Dict lighting; int i; static const char *schemes[] = { "Artwork", "None", "White", "Day", "Night", "Hard", "Primary", "Blue", "Red", "Cube", "CAD", "Headlamp" }; HPDF_PTRACE ((" HPDF_3DView_SetLighting\n")); if (view == NULL || scheme == NULL || scheme[0] == '\0') { return HPDF_INVALID_U3D_DATA; } for (i = 0; i < 12; i++) { if (!strcmp(scheme, schemes[i])) { break; } } if (i == 12) { return HPDF_INVALID_U3D_DATA; } lighting = HPDF_Dict_New (view->mmgr); if (!lighting) { return HPDF_Error_GetCode (view->error); } ret = HPDF_Dict_AddName (lighting, "Type", "3DLightingScheme"); if (ret != HPDF_OK) { HPDF_Dict_Free (lighting); return ret; } ret = HPDF_Dict_AddName (lighting, "Subtype", scheme); if (ret != HPDF_OK) { HPDF_Dict_Free (lighting); return ret; } ret = HPDF_Dict_Add (view, "LS", lighting); if (ret != HPDF_OK) { HPDF_Dict_Free (lighting); return ret; } 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_NameDict HPDF_NameDict_New (HPDF_MMgr mmgr, HPDF_Xref xref) { HPDF_NameDict ndict; HPDF_PTRACE (" HPDF_NameDict_New\n"); ndict = HPDF_Dict_New (mmgr); if (!ndict) return NULL; if (HPDF_Xref_Add (xref, ndict) != HPDF_OK) return NULL; ndict->header.obj_class |= HPDF_OSUBCLASS_NAMEDICT; return ndict; }
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; }
HPDF_MarkupAnnot_SetCloudEffect (HPDF_Annotation annot, HPDF_INT cloudIntensity) /* BE entry */ { HPDF_Dict borderEffect; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_MarkupAnnot_SetCloudEffect\n")); borderEffect = HPDF_Dict_New ( annot->mmgr); if (!borderEffect) return HPDF_Error_GetCode ( annot->error); ret += HPDF_Dict_Add ( annot, "BE", borderEffect); ret += HPDF_Dict_AddName ( borderEffect, "S", "C"); ret += HPDF_Dict_AddNumber ( borderEffect, "I", cloudIntensity); if (ret != HPDF_OK) return HPDF_Error_GetCode (annot->error); return HPDF_OK; }
HPDF_EXPORT(HPDF_STATUS) HPDF_3DView_SetPerspectiveProjection(HPDF_Dict view, HPDF_REAL fov) { HPDF_STATUS ret = HPDF_OK; HPDF_Dict projection; HPDF_PTRACE ((" HPDF_3DView_SetPerspectiveProjection\n")); if (view == NULL || fov < 0 || fov > 180) { 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", "P"); if (ret != HPDF_OK) { HPDF_Dict_Free (projection); return ret; } ret = HPDF_Dict_AddName (projection, "PS", "Min"); if (ret != HPDF_OK) { HPDF_Dict_Free (projection); return ret; } ret = HPDF_Dict_AddReal (projection, "FOV", fov); 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_Dict HPDF_ExtGState_New (HPDF_MMgr mmgr, HPDF_Xref xref) { HPDF_Dict obj = HPDF_Dict_New (mmgr); HPDF_PTRACE ((" HPDF_ExtGState_New\n")); if (!obj) return NULL; if (HPDF_Xref_Add (xref, obj) != HPDF_OK) return NULL; if (HPDF_Dict_AddName (obj, "Type", "ExtGState") != HPDF_OK) return NULL; obj->header.obj_class |= HPDF_OSUBCLASS_EXT_GSTATE; return obj; }
HPDF_EXPORT(HPDF_Dict) HPDF_Create3DActivation(HPDF_Annotation u3dAnnotation) { HPDF_STATUS ret = HPDF_OK; HPDF_Dict activation; HPDF_PTRACE ((" HPDF_Create3DActivation\n")); activation = HPDF_Dict_New (u3dAnnotation->mmgr); if (!activation) { return NULL; } ret = HPDF_Dict_AddName (activation, "DIS", "U"); if (ret != HPDF_OK) { HPDF_Dict_Free (activation); return NULL; } return activation; }
HPDF_STATUS HPDF_Catalog_AddPageLabel (HPDF_Catalog catalog, HPDF_UINT page_num, HPDF_Dict page_label) { HPDF_STATUS ret; HPDF_Array nums; HPDF_Dict labels = HPDF_Dict_GetItem (catalog, "PageLabels", HPDF_OCLASS_DICT); HPDF_PTRACE ((" HPDF_Catalog_AddPageLabel\n")); if (!labels) { labels = HPDF_Dict_New (catalog->mmgr); if (!labels) return catalog->error->error_no; if ((ret = HPDF_Dict_Add (catalog, "PageLabels", labels)) != HPDF_OK) return ret; } nums = HPDF_Dict_GetItem (labels, "Nums", HPDF_OCLASS_ARRAY); if (!nums) { nums = HPDF_Array_New (catalog->mmgr); if (!nums) return catalog->error->error_no; if ((ret = HPDF_Dict_Add (labels, "Nums", nums)) != HPDF_OK) return ret; } if ((ret = HPDF_Array_AddNumber (nums, page_num)) != HPDF_OK) return ret; return HPDF_Array_Add (nums, page_label); }
HPDF_EXPORT(HPDF_Dict) HPDF_Create3DView(HPDF_MMgr mmgr, const char *name) { HPDF_STATUS ret = HPDF_OK; HPDF_Dict view; HPDF_PTRACE ((" HPDF_Create3DView\n")); if (name == NULL || name[0] == '\0') { return NULL; } view = HPDF_Dict_New (mmgr); if (!view) { 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; } return view; }
HPDF_Font HPDF_Type0Font_New (HPDF_MMgr mmgr, HPDF_FontDef fontdef, HPDF_Encoder encoder, HPDF_Xref xref) { HPDF_Dict font; HPDF_FontAttr attr; HPDF_CMapEncoderAttr encoder_attr; HPDF_STATUS ret = 0; HPDF_Array descendant_fonts; HPDF_PTRACE ((" HPDF_Type0Font_New\n")); font = HPDF_Dict_New (mmgr); if (!font) return NULL; font->header.obj_class |= HPDF_OSUBCLASS_FONT; /* check whether the fontdef object and the encoder object is valid. */ if (encoder->type != HPDF_ENCODER_TYPE_DOUBLE_BYTE) { HPDF_SetError(font->error, HPDF_INVALID_ENCODER_TYPE, 0); return NULL; } if (fontdef->type != HPDF_FONTDEF_TYPE_CID && fontdef->type != HPDF_FONTDEF_TYPE_TRUETYPE) { HPDF_SetError(font->error, HPDF_INVALID_FONTDEF_TYPE, 0); return NULL; } attr = HPDF_GetMem (mmgr, sizeof(HPDF_FontAttr_Rec)); if (!attr) { HPDF_Dict_Free (font); return NULL; } font->header.obj_class |= HPDF_OSUBCLASS_FONT; font->write_fn = NULL; font->free_fn = OnFree_Func; font->attr = attr; encoder_attr = (HPDF_CMapEncoderAttr)encoder->attr; HPDF_MemSet (attr, 0, sizeof(HPDF_FontAttr_Rec)); attr->writing_mode = encoder_attr->writing_mode; attr->text_width_fn = TextWidth; attr->measure_text_fn = MeasureText; attr->fontdef = fontdef; attr->encoder = encoder; attr->xref = xref; if (HPDF_Xref_Add (xref, font) != HPDF_OK) return NULL; ret += HPDF_Dict_AddName (font, "Type", "Font"); ret += HPDF_Dict_AddName (font, "BaseFont", fontdef->base_font); ret += HPDF_Dict_AddName (font, "Subtype", "Type0"); if (fontdef->type == HPDF_FONTDEF_TYPE_CID) { ret += HPDF_Dict_AddName (font, "Encoding", encoder->name); } else { /* * Handle the Unicode encoding, see hpdf_encoding_utf.c For some * reason, xpdf-based readers cannot deal with our cmap but work * fine when using the predefined "Identity-H" * encoding. However, text selection does not work, unless we * add a ToUnicode cmap. This CMap should also be "Identity", * but that does not work -- specifying our cmap as a stream however * does work. Who can understand that ? */ if (HPDF_StrCmp(encoder_attr->ordering, "Identity-H") == 0) { ret += HPDF_Dict_AddName (font, "Encoding", "Identity-H"); attr->cmap_stream = CreateCMap (encoder, xref); if (attr->cmap_stream) { ret += HPDF_Dict_Add (font, "ToUnicode", attr->cmap_stream); } else return NULL; } else { attr->cmap_stream = CreateCMap (encoder, xref); if (attr->cmap_stream) { ret += HPDF_Dict_Add (font, "Encoding", attr->cmap_stream); } else return NULL; } } if (ret != HPDF_OK) return NULL; descendant_fonts = HPDF_Array_New (mmgr); if (!descendant_fonts) return NULL; if (HPDF_Dict_Add (font, "DescendantFonts", descendant_fonts) != HPDF_OK) return NULL; if (fontdef->type == HPDF_FONTDEF_TYPE_CID) { attr->descendant_font = CIDFontType0_New (font, xref); attr->type = HPDF_FONT_TYPE0_CID; } else { attr->descendant_font = CIDFontType2_New (font, xref); attr->type = HPDF_FONT_TYPE0_TT; } if (!attr->descendant_font) return NULL; else if (HPDF_Array_Add (descendant_fonts, attr->descendant_font) != HPDF_OK) return NULL; return font; }