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

static HPDF_STATUSAddAnnotation  (HPDF_Page        page,                HPDF_Annotation  annot){    HPDF_Array array;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_Pages/n"));    /* find "Annots" entry */    array = HPDF_Dict_GetItem (page, "Annots", HPDF_OCLASS_ARRAY);    if (!array) {        array = HPDF_Array_New (page->mmgr);        if (!array)            return HPDF_Error_GetCode (page->error);        ret = HPDF_Dict_Add (page, "Annots", array);        if (ret != HPDF_OK)            return ret;    }        if ((ret = HPDF_Array_Add (array, annot)) != HPDF_OK)       return ret;    /* Add Parent to the annotation  */    ret = HPDF_Dict_Add( annot, "P", page);    return ret;}

HPDF_ArrayHPDF_Box_Array_New  (HPDF_MMgr  mmgr,                     HPDF_Box   box){    HPDF_Array  obj;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_Box_Array_New/n"));    obj = HPDF_Array_New (mmgr);    if (!obj)        return NULL;    ret += HPDF_Array_Add (obj, HPDF_Real_New (mmgr, box.left));    ret += HPDF_Array_Add (obj, HPDF_Real_New (mmgr, box.bottom));    ret += HPDF_Array_Add (obj, HPDF_Real_New (mmgr, box.right));    ret += HPDF_Array_Add (obj, HPDF_Real_New (mmgr, box.top));    if (ret != HPDF_OK) {        HPDF_Array_Free (obj);        return NULL;    }    return obj;}

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

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_DestinationHPDF_Destination_New  (HPDF_MMgr   mmgr,                       HPDF_Page   target,                       HPDF_Xref   xref){    HPDF_Destination dst;    HPDF_PTRACE((" HPDF_Destination_New/n"));    if (!HPDF_Page_Validate (target)) {        HPDF_SetError (mmgr->error, HPDF_INVALID_PAGE, 0);        return NULL;    }    dst = HPDF_Array_New (mmgr);    if (!dst)        return NULL;    dst->header.obj_class |= HPDF_OSUBCLASS_DESTINATION;    if (HPDF_Xref_Add (xref, dst) != HPDF_OK)        return NULL;    /* first item of array must be target page */    if (HPDF_Array_Add (dst, target) != HPDF_OK)        return NULL;    /* default type is HPDF_FIT */    if (HPDF_Array_AddName (dst,            HPDF_DESTINATION_TYPE_NAMES[(HPDF_INT)HPDF_FIT]) != HPDF_OK)        return NULL;    return dst;}

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

/* 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_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_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_LinkAnnot_SetBorderStyle  (HPDF_Annotation  annot,                                HPDF_REAL        width,                                HPDF_UINT16      dash_on,                                HPDF_UINT16      dash_off){    HPDF_Array array;    HPDF_STATUS ret;    HPDF_PTRACE((" HPDF_LinkAnnot_SetBorderStyle/n"));    if (!CheckSubType (annot, HPDF_ANNOT_LINK))        return HPDF_INVALID_ANNOTATION;    if (width < 0)        return HPDF_RaiseError (annot->error, HPDF_INVALID_PARAMETER, 0);    array = HPDF_Array_New (annot->mmgr);    if (!array)        return HPDF_CheckError (annot->error);    if ((ret = HPDF_Dict_Add (annot, "Border", array)) != HPDF_OK)        return HPDF_CheckError (annot->error);    ret += HPDF_Array_AddNumber (array, 0);    ret += HPDF_Array_AddNumber (array, 0);    ret += HPDF_Array_AddReal (array, width);    if (ret != HPDF_OK)        return HPDF_CheckError (annot->error);    if (dash_on && dash_off) {        HPDF_Array dash = HPDF_Array_New (annot->mmgr);        if (!dash)            return HPDF_CheckError (annot->error);        if ((ret = HPDF_Array_Add (array, dash)) != HPDF_OK)            return HPDF_CheckError (annot->error);        ret += HPDF_Array_AddNumber (dash, dash_on);        ret += HPDF_Array_AddNumber (dash, dash_off);        if (ret != HPDF_OK)           return HPDF_CheckError (annot->error);    }    return HPDF_OK;}

HPDF_LineAnnot_SetPosition (HPDF_Annotation annot,                            HPDF_Point startPoint, HPDF_LineAnnotEndingStyle startStyle,                            HPDF_Point endPoint, HPDF_LineAnnotEndingStyle endStyle){    HPDF_Array lineEndPoints;    HPDF_Array lineEndStyles;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_LineAnnot_SetPosition/n"));    lineEndPoints = HPDF_Array_New ( annot->mmgr);    if ( !lineEndPoints)        return HPDF_Error_GetCode ( annot->error);    if ((ret = HPDF_Dict_Add ( annot, "L", lineEndPoints)) != HPDF_OK)        return ret;    ret += HPDF_Array_AddReal (lineEndPoints, startPoint.x);    ret += HPDF_Array_AddReal (lineEndPoints, startPoint.y);    ret += HPDF_Array_AddReal (lineEndPoints, endPoint.x);    ret += HPDF_Array_AddReal (lineEndPoints, endPoint.y);    if (ret != HPDF_OK)       return HPDF_Error_GetCode ( lineEndPoints->error);    lineEndStyles = HPDF_Array_New ( annot->mmgr);    if ( !lineEndStyles)        return HPDF_Error_GetCode ( annot->error);    if ((ret = HPDF_Dict_Add ( annot, "LE", lineEndStyles)) != HPDF_OK)        return ret;    ret += HPDF_Array_AddName (lineEndStyles, HPDF_LINE_ANNOT_ENDING_STYLE_NAMES[(HPDF_INT)startStyle]);    ret += HPDF_Array_AddName (lineEndStyles, HPDF_LINE_ANNOT_ENDING_STYLE_NAMES[(HPDF_INT)endStyle]);    if (ret != HPDF_OK)       return HPDF_Error_GetCode ( lineEndStyles->error);    return HPDF_OK;}

static HPDF_STATUSCreatePallet (HPDF_Dict    image,              png_structp  png_ptr,              png_infop    info_ptr){    HPDF_INT num_pl = 0;    png_color *src_pl = NULL;    HPDF_BYTE *ppallet;    HPDF_BYTE *p;    HPDF_UINT i;    HPDF_Array array;    /* png_get_PLTE does not call PngErrorFunc even if it failed.     * so we call HPDF_Set_Error to set error-code.     */    if (png_get_PLTE(png_ptr, info_ptr, (png_color**)&src_pl, &num_pl) !=            PNG_INFO_PLTE)        return HPDF_SetError (image->error, HPDF_LIBPNG_ERROR,                    HPDF_CANNOT_GET_PALLET);    /* make a pallet array for indexed image. */    ppallet = HPDF_GetMem (image->mmgr, num_pl * 3);    if (!ppallet)        return image->error->error_no;    p = ppallet;    for (i = 0; i < num_pl; i++, src_pl++) {        *p++ = src_pl->red;        *p++ = src_pl->green;        *p++ = src_pl->blue;    }    array = HPDF_Array_New (image->mmgr);    if (array) {        HPDF_Binary b;        HPDF_Dict_Add (image, "ColorSpace", array);        HPDF_Array_AddName (array, "Indexed");        HPDF_Array_AddName (array, "DeviceRGB");        HPDF_Array_AddNumber (array, num_pl - 1);        b = HPDF_Binary_New (image->mmgr, ppallet, num_pl * 3);        if (b)            HPDF_Array_Add (array, b);    }    HPDF_FreeMem (image->mmgr, ppallet);    return image->error->error_no;}

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

HPDF_Annot_SetNoColor (HPDF_Annotation annot){    HPDF_Array cArray;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_Annot_SetNoColor/n"));    cArray = HPDF_Array_New (annot->mmgr);    if (!cArray)        return HPDF_Error_GetCode ( annot->error);    ret = HPDF_Dict_Add (annot, "C", cArray);    return ret;}

HPDF_MarkupAnnot_SetInteriorTransparent (HPDF_Annotation  annot) /* IC with No Color entry */{    HPDF_Array cArray;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_MarkupAnnot_SetInteriorTransparent/n"));    cArray = HPDF_Array_New ( annot->mmgr);    if (!cArray)        return HPDF_Error_GetCode ( annot->error);    ret = HPDF_Dict_Add (annot, "IC", cArray);    return ret;}

HPDF_Image_SetColorMask (HPDF_Image   image,                         HPDF_UINT    rmin,                         HPDF_UINT    rmax,                         HPDF_UINT    gmin,                         HPDF_UINT    gmax,                         HPDF_UINT    bmin,                         HPDF_UINT    bmax){    HPDF_Array array;    const char *name;    HPDF_STATUS ret = HPDF_OK;    if (!HPDF_Image_Validate (image))        return HPDF_INVALID_IMAGE;    if (HPDF_Dict_GetItem (image, "ImageMask", HPDF_OCLASS_BOOLEAN))        return HPDF_RaiseError (image->error, HPDF_INVALID_OPERATION, 0);    if (HPDF_Image_GetBitsPerComponent (image) != 8)        return HPDF_RaiseError (image->error, HPDF_INVALID_BIT_PER_COMPONENT,                0);    name = HPDF_Image_GetColorSpace (image);    if (!name || HPDF_StrCmp (COL_RGB, name) != 0)        return HPDF_RaiseError (image->error, HPDF_INVALID_COLOR_SPACE, 0);    /* Each integer must be in the range 0 to 2^BitsPerComponent - 1 */    if (rmax > 255 || gmax > 255 || bmax > 255)       return HPDF_RaiseError (image->error, HPDF_INVALID_PARAMETER, 0);    array = HPDF_Array_New (image->mmgr);    if (!array)        return HPDF_CheckError (image->error);    ret += HPDF_Dict_Add (image, "Mask", array);    ret += HPDF_Array_AddNumber (array, rmin);    ret += HPDF_Array_AddNumber (array, rmax);    ret += HPDF_Array_AddNumber (array, gmin);    ret += HPDF_Array_AddNumber (array, gmax);    ret += HPDF_Array_AddNumber (array, bmin);    ret += HPDF_Array_AddNumber (array, bmax);    if (ret != HPDF_OK)        return HPDF_CheckError (image->error);    return HPDF_OK;}

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_SetGrayColor (HPDF_Annotation annot, HPDF_REAL color){    HPDF_Array cArray;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_Annot_SetGrayColor/n"));    cArray = HPDF_Array_New (annot->mmgr);    if (!cArray)        return HPDF_Error_GetCode ( annot->error);    ret += HPDF_Dict_Add (annot, "C", cArray);    ret += HPDF_Array_AddReal ( cArray, color);    if (ret != HPDF_OK)        return HPDF_Error_GetCode ( annot->error);    return HPDF_OK;}

HPDF_MarkupAnnot_SetInteriorGrayColor (HPDF_Annotation  annot, HPDF_REAL color)/* IC with Gray entry */{    HPDF_Array cArray;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_MarkupAnnot_SetInteriorGrayColor/n"));    cArray = HPDF_Array_New ( annot->mmgr);    if (!cArray)        return HPDF_Error_GetCode ( annot->error);    ret += HPDF_Dict_Add (annot, "IC", cArray);    ret += HPDF_Array_AddReal (cArray, color);    if (ret != HPDF_OK)        return HPDF_Error_GetCode ( annot->error);    return HPDF_OK;}

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_FreeTextAnnot_SetLineEndingStyle (HPDF_Annotation annot, HPDF_LineAnnotEndingStyle startStyle, HPDF_LineAnnotEndingStyle endStyle){    HPDF_Array lineEndStyles;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_FreeTextAnnot_SetLineEndingStyle/n"));    lineEndStyles = HPDF_Array_New ( annot->mmgr);    if ( !lineEndStyles)        return HPDF_Error_GetCode ( annot->error);    if ((ret = HPDF_Dict_Add ( annot, "LE", lineEndStyles)) != HPDF_OK)        return ret;    ret += HPDF_Array_AddName (lineEndStyles, HPDF_LINE_ANNOT_ENDING_STYLE_NAMES[(HPDF_INT)startStyle]);    ret += HPDF_Array_AddName (lineEndStyles, HPDF_LINE_ANNOT_ENDING_STYLE_NAMES[(HPDF_INT)endStyle]);    if (ret != HPDF_OK)       return HPDF_Error_GetCode (lineEndStyles->error);    return HPDF_OK;}

HPDF_STATUSHPDF_Doc_PrepareEncryption  (HPDF_Doc   pdf){    HPDF_Encrypt e= HPDF_EncryptDict_GetAttr (pdf->encrypt_dict);    HPDF_Dict info = GetInfo (pdf);    HPDF_Array id;    if (!e)        return HPDF_DOC_ENCRYPTDICT_NOT_FOUND;    if (!info)        return pdf->error.error_no;    if (HPDF_EncryptDict_Prepare (pdf->encrypt_dict, info, pdf->xref) !=            HPDF_OK)        return pdf->error.error_no;    /* reset 'ID' to trailer-dictionary */    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;    } else        HPDF_Array_Clear (id);    if (HPDF_Array_Add (id, HPDF_Binary_New (pdf->mmgr, e->encrypt_id,                HPDF_ID_LEN)) != HPDF_OK)        return pdf->error.error_no;    if (HPDF_Array_Add (id, HPDF_Binary_New (pdf->mmgr, e->encrypt_id,                HPDF_ID_LEN)) != HPDF_OK)        return pdf->error.error_no;    return HPDF_OK;}

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

static HPDF_FontCIDFontType2_New (HPDF_Font parent, HPDF_Xref xref){    HPDF_STATUS ret = HPDF_OK;    HPDF_FontAttr attr = (HPDF_FontAttr)parent->attr;    HPDF_FontDef fontdef = attr->fontdef;    HPDF_TTFontDefAttr fontdef_attr = (HPDF_TTFontDefAttr)fontdef->attr;    HPDF_Encoder encoder = attr->encoder;    HPDF_CMapEncoderAttr encoder_attr =                (HPDF_CMapEncoderAttr)encoder->attr;    HPDF_Font font;    HPDF_Array array;    HPDF_UINT i;    HPDF_UNICODE tmp_map[65536];    HPDF_Dict cid_system_info;    HPDF_UINT16 max = 0;    HPDF_PTRACE ((" HPDF_CIDFontType2_New/n"));    font = HPDF_Dict_New (parent->mmgr);    if (!font)        return NULL;    if (HPDF_Xref_Add (xref, font) != HPDF_OK)        return NULL;    parent->before_write_fn = CIDFontType2_BeforeWrite_Func;    ret += HPDF_Dict_AddName (font, "Type", "Font");    ret += HPDF_Dict_AddName (font, "Subtype", "CIDFontType2");    ret += HPDF_Dict_AddNumber (font, "DW", fontdef->missing_width);    if (ret != HPDF_OK)        return NULL;    /* add 'DW2' element */    array = HPDF_Array_New (font->mmgr);    if (!array)        return NULL;    if (HPDF_Dict_Add (font, "DW2", array) != HPDF_OK)        return NULL;    ret += HPDF_Array_AddNumber (array, (HPDF_INT32)(fontdef->font_bbox.bottom));    ret += HPDF_Array_AddNumber (array, (HPDF_INT32)(fontdef->font_bbox.bottom -                fontdef->font_bbox.top));    HPDF_MemSet (tmp_map, 0, sizeof(HPDF_UNICODE) * 65536);    if (ret != HPDF_OK)        return NULL;    for (i = 0; i < 256; i++) {        HPDF_UINT j;        for (j = 0; j < 256; j++) {	    if (encoder->to_unicode_fn == HPDF_CMapEncoder_ToUnicode) {		HPDF_UINT16 cid = encoder_attr->cid_map[i][j];		if (cid != 0) {		    HPDF_UNICODE unicode = encoder_attr->unicode_map[i][j];		    HPDF_UINT16 gid = HPDF_TTFontDef_GetGlyphid (fontdef,								 unicode);		    tmp_map[cid] = gid;		    if (max < cid)			max = cid;		}	    } else {		HPDF_UNICODE unicode = (i << 8) | j;		HPDF_UINT16 gid = HPDF_TTFontDef_GetGlyphid (fontdef,							     unicode);		tmp_map[unicode] = gid;		if (max < unicode)		    max = unicode;	    }	}    }    if (max > 0) {        HPDF_INT16 dw = fontdef->missing_width;        HPDF_UNICODE *ptmp_map = tmp_map;        HPDF_Array tmp_array = NULL;        /* add 'W' element */        array = HPDF_Array_New (font->mmgr);        if (!array)            return NULL;        if (HPDF_Dict_Add (font, "W", array) != HPDF_OK)            return NULL;        for (i = 0; i < max; i++, ptmp_map++) {            HPDF_INT w = HPDF_TTFontDef_GetGidWidth (fontdef, *ptmp_map);            if (w != dw) {                if (!tmp_array) {                    if (HPDF_Array_AddNumber (array, i) != HPDF_OK)                        return NULL;                    tmp_array = HPDF_Array_New (font->mmgr);//.........这里部分代码省略.........

static HPDF_FontCIDFontType0_New (HPDF_Font parent, HPDF_Xref xref){    HPDF_STATUS ret = HPDF_OK;    HPDF_FontAttr attr = (HPDF_FontAttr)parent->attr;    HPDF_FontDef fontdef = attr->fontdef;    HPDF_CIDFontDefAttr fontdef_attr = (HPDF_CIDFontDefAttr)fontdef->attr;    HPDF_Encoder encoder = attr->encoder;    HPDF_CMapEncoderAttr encoder_attr =                (HPDF_CMapEncoderAttr)encoder->attr;    HPDF_UINT16 save_cid = 0;    HPDF_Font font;    HPDF_Array array;    HPDF_Array sub_array = NULL;    HPDF_UINT i;    HPDF_Dict descriptor;    HPDF_Dict cid_system_info;    HPDF_PTRACE ((" HPDF_CIDFontType0_New/n"));    font = HPDF_Dict_New (parent->mmgr);    if (!font)        return NULL;    if (HPDF_Xref_Add (xref, font) != HPDF_OK)        return NULL;    ret += HPDF_Dict_AddName (font, "Type", "Font");    ret += HPDF_Dict_AddName (font, "Subtype", "CIDFontType0");    ret += HPDF_Dict_AddNumber (font, "DW", fontdef_attr->DW);    ret += HPDF_Dict_AddName (font, "BaseFont", fontdef->base_font);    if (ret != HPDF_OK)        return NULL;    /* add 'DW2' element */    array = HPDF_Array_New (parent->mmgr);    if (!array)        return NULL;    if (HPDF_Dict_Add (font, "DW2", array) != HPDF_OK)        return NULL;    ret += HPDF_Array_AddNumber (array, fontdef_attr->DW2[0]);    ret += HPDF_Array_AddNumber (array, fontdef_attr->DW2[1]);    if (ret != HPDF_OK)        return NULL;    /* add 'W' element */    array = HPDF_Array_New (parent->mmgr);    if (!array)        return NULL;    if (HPDF_Dict_Add (font, "W", array) != HPDF_OK)        return NULL;    /* Create W array. */    for (i = 0; i< fontdef_attr->widths->count; i++) {        HPDF_CID_Width *w =                (HPDF_CID_Width *)HPDF_List_ItemAt (fontdef_attr->widths, i);        if (w->cid != save_cid + 1 || !sub_array) {            sub_array = HPDF_Array_New (parent->mmgr);            if (!sub_array)                return NULL;            ret += HPDF_Array_AddNumber (array, w->cid);            ret += HPDF_Array_Add (array, sub_array);        }        ret += HPDF_Array_AddNumber (sub_array, w->width);        save_cid = w->cid;        if (ret != HPDF_OK)            return NULL;    }    /* create descriptor */    descriptor = HPDF_Dict_New (parent->mmgr);    if (!descriptor)        return NULL;    if (HPDF_Xref_Add (xref, descriptor) != HPDF_OK)        return NULL;    if (HPDF_Dict_Add (font, "FontDescriptor", descriptor) != HPDF_OK)        return NULL;    ret += HPDF_Dict_AddName (descriptor, "Type", "FontDescriptor");    ret += HPDF_Dict_AddName (descriptor, "FontName", fontdef->base_font);    ret += HPDF_Dict_AddNumber (descriptor, "Ascent", fontdef->ascent);    ret += HPDF_Dict_AddNumber (descriptor, "Descent", fontdef->descent);    ret += HPDF_Dict_AddNumber (descriptor, "CapHeight",                fontdef->cap_height);    ret += HPDF_Dict_AddNumber (descriptor, "MissingWidth",                fontdef->missing_width);    ret += HPDF_Dict_AddNumber (descriptor, "Flags", fontdef->flags);//.........这里部分代码省略.........