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;
}
