自学教程：C++ HPDF_Dict_Add函数代码示例

HPDF_PageHPDF_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_STATUSPrepareTrailer  (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_STATUSHPDF_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_STATUSHPDF_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_AnnotationHPDF_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_STATUSPages_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_STATUSHPDF_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(&ltime);    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_STATUSHPDF_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_STATUSHPDF_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_AnnotationHPDF_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_STATUSHPDF_NameDict_SetNameTree  (HPDF_NameDict     namedict,                            HPDF_NameDictKey  key,                            HPDF_NameTree     ntree){    return HPDF_Dict_Add (namedict, HPDF_NAMEDICT_KEYS[key], ntree);}

HPDF_NameTreeHPDF_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_CatalogHPDF_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_EmbeddedFileHPDF_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_STATUSHPDF_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_STATUSHPDF_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;}