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

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_PagesHPDF_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_AnnotationHPDF_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_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_ExDataHPDF_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_EncryptDictHPDF_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_STATUSAddResource  (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_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_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_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_XrefHPDF_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_DictHPDF_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_AnnotationHPDF_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_DictGetInfo  (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_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_NameDictHPDF_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_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;}

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_DictHPDF_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_STATUSHPDF_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_FontHPDF_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;//.........这里部分代码省略.........